Merge branch 'feature/nongxinweixinnotice' into 'master'

Feature/nongxinweixinnotice



See merge request !7

+package com.tianting.infoloop.mapper;
+
+import com.tianting.infoloop.inject.MyBaseMapper;
+import com.tianting.infoloop.model.db.OrderSubscriptionMessageDb;
+import org.apache.ibatis.annotations.Delete;
+import org.apache.ibatis.annotations.Param;
+
+import java.util.List;
+
+public interface OrderSubscriptionMessageMapper extends MyBaseMapper<OrderSubscriptionMessageDb> {
+
+  /**
+   * 批量物理删除（绕过逻辑删除）
+   */
+  @Delete("<script>" +
+      "DELETE FROM order_subscription_message " +
+      "WHERE enterpriseId = #{enterpriseId} " +
+      "AND id IN " +
+      "<foreach collection='ids' item='id' open='(' separator=',' close=')'>" +
+      "#{id}" +
+      "</foreach>" +
+      "</script>")
+  int physicalDeleteByIds(@Param("ids") List<Long> ids, @Param("enterpriseId") int enterpriseId);
+}
+

+package com.tianting.infoloop.model.db;
+
+import com.baomidou.mybatisplus.annotation.FieldFill;
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableField;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableLogic;
+import com.baomidou.mybatisplus.annotation.TableName;
+import com.baomidou.mybatisplus.extension.activerecord.Model;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.experimental.Accessors;
+
+import java.time.LocalDateTime;
+
+/**
+ * order subscription message DB
+ * @TableName  order_subscription_message
+ */
+@Data
+@Accessors(chain = true)
+@EqualsAndHashCode(callSuper = true)
+@TableName(value = "meal_order_subscription_messages")
+public class OrderSubscriptionMessageDb extends Model<OrderSubscriptionMessageDb> {
+    /**
+     * 主键ID
+     */
+    @TableId(type = IdType.AUTO)
+    private Long id;
+    /**
+     * 企业ID
+     */
+    private Integer enterpriseId;
+    /**
+     * 订餐用户ID（dinerId）
+     */
+    private Integer dinerId;
+    /**
+     * 微信用户OpenID
+     */
+    private String openId;
+    /**
+     * 订阅消息模板ID
+     */
+    private String templateId;
+    /**
+     * 跳转路径（小程序 path）
+     */
+    private String jumpPath;
+    /**
+     * 关联的订餐周期开始时间（精确到秒）
+     */
+    private LocalDateTime orderPeriodStartDate;
+    /**
+     * 关联的订餐周期结束时间（精确到秒）
+     */
+    private LocalDateTime orderPeriodEndDate;
+    /**
+     * 授权时间（创建时间）
+     */
+    @TableField(fill = FieldFill.INSERT)
+    private LocalDateTime createdAt;
+    /**
+     * 更新时间
+     */
+    @TableField(fill = FieldFill.INSERT_UPDATE)
+    private LocalDateTime updatedAt;
+    /**
+     * 授权状态，0-待使用（已授权但未发送），1-已使用（已发送，逻辑删除）
+     */
+    @TableLogic
+    private Boolean isDeleted;
+}
+

+package com.tianting.infoloop.service;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.infoloop.tianting.mealorderservice.CreateOrderSubscriptionMessageRpcRequest;
+import com.infoloop.tianting.mealorderservice.GetUserOrderSubscriptionMessageHistoryRpcRequest;
+import com.tianting.infoloop.model.db.OrderSubscriptionMessageDb;
+
+import java.util.List;
+
+public interface OrderSubscriptionMessageDbService extends IService<OrderSubscriptionMessageDb> {
+
+  OrderSubscriptionMessageDb createOrderSubscriptionMessage(CreateOrderSubscriptionMessageRpcRequest request);
+
+  List<OrderSubscriptionMessageDb> getUserOrderSubscriptionMessageHistory(GetUserOrderSubscriptionMessageHistoryRpcRequest request);
+
+  /**
+   * 批量逻辑删除授权记录（表示已使用）
+   * @param ids 要删除的记录ID列表
+   * @param enterpriseId 企业ID
+   * @return 受影响的行数
+   */
+  int batchDeleteByIds(java.util.List<Long> ids, int enterpriseId);
+
+  /**
+   * 批量物理删除授权记录
+   * @param ids 要删除的记录ID列表
+   * @param enterpriseId 企业ID
+   * @return 受影响的行数
+   */
+  int batchPhysicalDeleteByIds(java.util.List<Long> ids, int enterpriseId);
+
+  /**
+   * 查询待发送的订阅消息（未删除的记录）
+   * @param enterpriseId 企业ID
+   * @return 待发送的订阅消息列表
+   */
+  List<OrderSubscriptionMessageDb> queryPendingMessages(int enterpriseId);
+}
+

@@ -7,6 +7,18 @@ import com.baomidou.mybatisplus.core.toolkit.Wrappers;
 import com.infoloop.tianting.mealorderservice.BatchCreateDinerMealSuspensionRecordsRpcRequest;
 import com.infoloop.tianting.mealorderservice.BatchCreateDinerMealSuspensionRecordsRpcResponse;
 import com.infoloop.tianting.mealorderservice.BatchCreateGradeClassesRpcRequest;
+import com.infoloop.tianting.mealorderservice.BatchDeleteOrderSubscriptionMessagesByIdsRpcRequest;
+import com.infoloop.tianting.mealorderservice.BatchDeleteOrderSubscriptionMessagesByIdsRpcResponse;
+import com.infoloop.tianting.mealorderservice.BatchPhysicalDeleteOrderSubscriptionMessagesByIdsRpcRequest;
+import com.infoloop.tianting.mealorderservice.BatchPhysicalDeleteOrderSubscriptionMessagesByIdsRpcResponse;
+import com.infoloop.tianting.mealorderservice.CreateOrderSubscriptionMessageRpcRequest;
+import com.infoloop.tianting.mealorderservice.CreateOrderSubscriptionMessageRpcResponse;
+import com.infoloop.tianting.mealorderservice.GetUserOrderSubscriptionMessageHistoryRpcRequest;
+import com.infoloop.tianting.mealorderservice.GetUserOrderSubscriptionMessageHistoryRpcResponse;
+import com.infoloop.tianting.mealorderservice.OrderSubscriptionMessageRpcResponse;
+import com.infoloop.tianting.mealorderservice.PendingOrderSubscriptionMessageRpcResponse;
+import com.infoloop.tianting.mealorderservice.QueryPendingOrderSubscriptionMessagesRpcRequest;
+import com.infoloop.tianting.mealorderservice.QueryPendingOrderSubscriptionMessagesRpcResponse;
 import com.infoloop.tianting.mealorderservice.BatchCreateGradeClassesRpcResponse;
 import com.infoloop.tianting.mealorderservice.BatchCreateMealOrdersRpcRequest;
 import com.infoloop.tianting.mealorderservice.BatchCreateMealOrdersRpcResponse;
@@ -124,6 +136,8 @@ import com.tianting.infoloop.service.MealOrderService;
 import com.tianting.infoloop.service.MpAccountDinerRefService;
 import com.tianting.infoloop.service.MpAccountService;
 import com.tianting.infoloop.service.DinerMealSuspensionRecordService;
+import com.tianting.infoloop.service.OrderSubscriptionMessageDbService;
+import com.tianting.infoloop.model.db.OrderSubscriptionMessageDb;
 import com.tianting.infoloop.utils.ProtoBeanUtil;
 import io.grpc.Status;
 import io.grpc.stub.StreamObserver;
@@ -134,10 +148,10 @@ import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
 import java.time.DayOfWeek;
-import java.time.Instant;
 import java.time.LocalDate;
 import java.time.LocalDateTime;
 import java.time.LocalTime;
+import java.time.ZoneId;
 import java.time.temporal.TemporalAdjusters;
 import java.util.ArrayList;
 import java.util.Collections;
@@ -167,6 +181,8 @@ public class MealOrderGrpcService extends MealOrderServiceRpcGrpc.MealOrderServi
 
     private final DinerMealSuspensionRecordService dinerMealSuspensionRecordService;
 
+    private final OrderSubscriptionMessageDbService orderSubscriptionMessageDbService;
+
     @Override
     @DS(DATA_SOURCE_SLAVE)
     public void getMealOrderById(final GetMealOrderByIdRpcRequest request,
@@ -1417,4 +1433,149 @@ public class MealOrderGrpcService extends MealOrderServiceRpcGrpc.MealOrderServi
         responseObserver.onNext(builder.build());
         responseObserver.onCompleted();
     }
+
+    // 订餐订阅消息相关服务实现
+    @Override
+    @DS(DATA_SOURCE_MASTER)
+    public void createOrderSubscriptionMessage(final CreateOrderSubscriptionMessageRpcRequest request,
+            final StreamObserver<CreateOrderSubscriptionMessageRpcResponse> responseObserver) {
+        final var builder = CreateOrderSubscriptionMessageRpcResponse.newBuilder();
+        try {
+            final var data = orderSubscriptionMessageDbService.createOrderSubscriptionMessage(request);
+            builder.setId(data.getId());
+        } catch (final Exception e) {
+            log.error("createOrderSubscriptionMessage error;", e);
+            responseObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException());
+            return;
+        }
+        responseObserver.onNext(builder.build());
+        responseObserver.onCompleted();
+    }
+
+    @Override
+    @DS(DATA_SOURCE_MASTER)
+    public void getUserOrderSubscriptionMessageHistory(final GetUserOrderSubscriptionMessageHistoryRpcRequest request,
+            final StreamObserver<GetUserOrderSubscriptionMessageHistoryRpcResponse> responseObserver) {
+        final var builder = GetUserOrderSubscriptionMessageHistoryRpcResponse.newBuilder();
+        try {
+            final var list = orderSubscriptionMessageDbService.getUserOrderSubscriptionMessageHistory(request);
+            builder.addAllResponse(list.stream()
+                    .map(this::convertToRpcResponse)
+                    .collect(Collectors.toList()));
+        } catch (final Exception e) {
+            log.error("getUserOrderSubscriptionMessageHistory error;", e);
+            responseObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException());
+            return;
+        }
+        responseObserver.onNext(builder.build());
+        responseObserver.onCompleted();
+    }
+
+    private OrderSubscriptionMessageRpcResponse convertToRpcResponse(OrderSubscriptionMessageDb db) {
+        OrderSubscriptionMessageRpcResponse.Builder builder = OrderSubscriptionMessageRpcResponse.newBuilder();
+        builder.setId(db.getId());
+
+        if (db.getJumpPath() != null) {
+            builder.setJumpPath(db.getJumpPath());
+        }
+
+        // 转换LocalDateTime为时间戳（毫秒），与项目中其他时间字段保持一致
+        if (db.getOrderPeriodStartDate() != null) {
+            long timestamp = db.getOrderPeriodStartDate().atZone(ZoneId.systemDefault())
+                    .toInstant()
+                    .toEpochMilli();
+            builder.setOrderPeriodStartDate(timestamp);
+        }
+
+        if (db.getOrderPeriodEndDate() != null) {
+            long timestamp = db.getOrderPeriodEndDate().atZone(ZoneId.systemDefault())
+                    .toInstant()
+                    .toEpochMilli();
+            builder.setOrderPeriodEndDate(timestamp);
+        }
+
+        // 转换LocalDateTime为时间戳（毫秒）
+        if (db.getCreatedAt() != null) {
+            long timestamp = db.getCreatedAt().atZone(ZoneId.systemDefault())
+                    .toInstant()
+                    .toEpochMilli();
+            builder.setCreatedAt(timestamp);
+        }
+
+        builder.setIsDeleted(db.getIsDeleted() != null && db.getIsDeleted());
+        return builder.build();
+    }
+
+    @Override
+    @DS(DATA_SOURCE_MASTER)
+    public void batchDeleteOrderSubscriptionMessagesByIds(final BatchDeleteOrderSubscriptionMessagesByIdsRpcRequest request,
+            final StreamObserver<BatchDeleteOrderSubscriptionMessagesByIdsRpcResponse> responseObserver) {
+        final var builder = BatchDeleteOrderSubscriptionMessagesByIdsRpcResponse.newBuilder();
+        try {
+            final int affectedRows = orderSubscriptionMessageDbService.batchDeleteByIds(
+                    request.getIdsList(),
+                    request.getEnterpriseId());
+            builder.setAffectedRows(affectedRows);
+        } catch (final Exception e) {
+            log.error("batchDeleteOrderSubscriptionMessagesByIds error;", e);
+            responseObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException());
+            return;
+        }
+        responseObserver.onNext(builder.build());
+        responseObserver.onCompleted();
+    }
+
+    @Override
+    @DS(DATA_SOURCE_MASTER)
+    public void batchPhysicalDeleteOrderSubscriptionMessagesByIds(
+            final BatchPhysicalDeleteOrderSubscriptionMessagesByIdsRpcRequest request,
+            final StreamObserver<BatchPhysicalDeleteOrderSubscriptionMessagesByIdsRpcResponse> responseObserver) {
+        final var builder = BatchPhysicalDeleteOrderSubscriptionMessagesByIdsRpcResponse.newBuilder();
+        try {
+            final int affectedRows = orderSubscriptionMessageDbService.batchPhysicalDeleteByIds(
+                    request.getIdsList(),
+                    request.getEnterpriseId());
+            builder.setAffectedRows(affectedRows);
+        } catch (final Exception e) {
+            log.error("batchPhysicalDeleteOrderSubscriptionMessagesByIds error;", e);
+            responseObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException());
+            return;
+        }
+        responseObserver.onNext(builder.build());
+        responseObserver.onCompleted();
+    }
+
+    @Override
+    @DS(DATA_SOURCE_SLAVE)
+    public void queryPendingOrderSubscriptionMessages(
+            final QueryPendingOrderSubscriptionMessagesRpcRequest request,
+            final StreamObserver<QueryPendingOrderSubscriptionMessagesRpcResponse> responseObserver) {
+        final var builder = QueryPendingOrderSubscriptionMessagesRpcResponse.newBuilder();
+        try {
+            final var messages = orderSubscriptionMessageDbService.queryPendingMessages(
+                    request.getEnterpriseId());
+            for (final var message : messages) {
+                builder.addResponses(PendingOrderSubscriptionMessageRpcResponse.newBuilder()
+                        .setId(message.getId())
+                        .setEnterpriseId(message.getEnterpriseId())
+                        .setDinerId(message.getDinerId() != null ? message.getDinerId() : 0)
+                        .setOpenId(message.getOpenId())
+                        .setTemplateId(message.getTemplateId() != null ? message.getTemplateId() : "")
+                        .setOrderPeriodStartDate(message.getOrderPeriodStartDate() != null ?
+                                message.getOrderPeriodStartDate().atZone(ZoneId.systemDefault()).toInstant().toEpochMilli() : 0)
+                        .setJumpPath(message.getJumpPath() != null ? message.getJumpPath() : "")
+                        .setOrderPeriodEndDate(message.getOrderPeriodEndDate() != null ?
+                                message.getOrderPeriodEndDate().atZone(ZoneId.systemDefault()).toInstant().toEpochMilli() : 0)
+                        .setCreatedAt(message.getCreatedAt() != null ?
+                                message.getCreatedAt().atZone(ZoneId.systemDefault()).toInstant().toEpochMilli() : 0)
+                        .build());
+            }
+        } catch (final Exception e) {
+            log.error("queryPendingOrderSubscriptionMessages error;", e);
+            responseObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException());
+            return;
+        }
+        responseObserver.onNext(builder.build());
+        responseObserver.onCompleted();
+    }
 }

+package com.tianting.infoloop.service.impl;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.infoloop.tianting.mealorderservice.CreateOrderSubscriptionMessageRpcRequest;
+import com.infoloop.tianting.mealorderservice.GetUserOrderSubscriptionMessageHistoryRpcRequest;
+import com.tianting.infoloop.mapper.OrderSubscriptionMessageMapper;
+import com.tianting.infoloop.model.db.OrderSubscriptionMessageDb;
+import com.tianting.infoloop.service.OrderSubscriptionMessageDbService;
+import com.tianting.infoloop.utils.exception.ErrorCodeConstants;
+import com.tianting.infoloop.utils.exception.ServiceExceptionUtil;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.time.Instant;
+import java.time.LocalDateTime;
+import java.time.ZoneId;
+import java.util.List;
+
+@Slf4j
+@Service
+@RequiredArgsConstructor(onConstructor_ = @Autowired)
+public class OrderSubscriptionMessageDbServiceImpl extends ServiceImpl<OrderSubscriptionMessageMapper, OrderSubscriptionMessageDb> implements OrderSubscriptionMessageDbService {
+
+  @Override
+  public OrderSubscriptionMessageDb createOrderSubscriptionMessage(CreateOrderSubscriptionMessageRpcRequest request) {
+    OrderSubscriptionMessageDb orderSubscriptionMessageDb = new OrderSubscriptionMessageDb();
+    orderSubscriptionMessageDb.setEnterpriseId(request.getEnterpriseId());
+    if (request.getDinerId() != 0) {
+      orderSubscriptionMessageDb.setDinerId(request.getDinerId());
+    }
+    orderSubscriptionMessageDb.setOpenId(request.getOpenId());
+    orderSubscriptionMessageDb.setTemplateId(request.getTemplateId());
+    if (!request.getJumpPath().isEmpty()) {
+      orderSubscriptionMessageDb.setJumpPath(request.getJumpPath());
+    }
+
+    // 转换时间戳为LocalDateTime（精确到秒），与项目中其他时间字段保持一致
+    LocalDateTime orderPeriodStartDate = Instant.ofEpochMilli(request.getOrderPeriodStartDate())
+        .atZone(ZoneId.systemDefault())
+        .toLocalDateTime();
+    orderSubscriptionMessageDb.setOrderPeriodStartDate(orderPeriodStartDate);
+
+    if (request.getOrderPeriodEndDate() > 0) {
+      LocalDateTime orderPeriodEndDate = Instant.ofEpochMilli(request.getOrderPeriodEndDate())
+          .atZone(ZoneId.systemDefault())
+          .toLocalDateTime();
+      orderSubscriptionMessageDb.setOrderPeriodEndDate(orderPeriodEndDate);
+    }
+
+    boolean res = this.save(orderSubscriptionMessageDb);
+    if (!res) {
+      log.error("创建订阅消息授权记录失败, request: {}", request);
+      throw ServiceExceptionUtil.exception(ErrorCodeConstants.ORDER_GEN_FAIL);
+    }
+    return orderSubscriptionMessageDb;
+  }
+
+  @Override
+  public List<OrderSubscriptionMessageDb> getUserOrderSubscriptionMessageHistory(GetUserOrderSubscriptionMessageHistoryRpcRequest request) {
+    LambdaQueryWrapper<OrderSubscriptionMessageDb> queryWrapper = new LambdaQueryWrapper<>();
+    queryWrapper.eq(OrderSubscriptionMessageDb::getEnterpriseId, request.getEnterpriseId());
+    queryWrapper.eq(OrderSubscriptionMessageDb::getOpenId, request.getOpenId());
+
+    // 如果传入了 orderPeriodStartDate，查询大于等于该值的记录
+    if (request.getOrderPeriodStartDate() > 0) {
+      LocalDateTime orderPeriodStartDate = Instant.ofEpochMilli(request.getOrderPeriodStartDate())
+          .atZone(ZoneId.systemDefault())
+          .toLocalDateTime();
+      queryWrapper.ge(OrderSubscriptionMessageDb::getOrderPeriodStartDate, orderPeriodStartDate);
+    }
+
+    queryWrapper.orderByDesc(OrderSubscriptionMessageDb::getCreatedAt);
+    return this.list(queryWrapper);
+  }
+
+  @Override
+  public int batchDeleteByIds(java.util.List<Long> ids, int enterpriseId) {
+    if (ids == null || ids.isEmpty()) {
+      return 0;
+    }
+    LambdaQueryWrapper<OrderSubscriptionMessageDb> queryWrapper = new LambdaQueryWrapper<>();
+    queryWrapper.eq(OrderSubscriptionMessageDb::getEnterpriseId, enterpriseId);
+    queryWrapper.in(OrderSubscriptionMessageDb::getId, ids);
+    // 逻辑删除（使用 MyBatis-Plus 的 @TableLogic）
+    return this.remove(queryWrapper) ? ids.size() : 0;
+  }
+
+  @Override
+  public int batchPhysicalDeleteByIds(java.util.List<Long> ids, int enterpriseId) {
+    if (ids == null || ids.isEmpty()) {
+      return 0;
+    }
+    // 物理删除（使用 Mapper 中的 SQL，绕过逻辑删除）
+    return this.baseMapper.physicalDeleteByIds(ids, enterpriseId);
+  }
+
+  @Override
+  public List<OrderSubscriptionMessageDb> queryPendingMessages(int enterpriseId) {
+    LambdaQueryWrapper<OrderSubscriptionMessageDb> queryWrapper = new LambdaQueryWrapper<>();
+    queryWrapper.eq(OrderSubscriptionMessageDb::getEnterpriseId, enterpriseId)
+        .eq(OrderSubscriptionMessageDb::getIsDeleted, false)
+        .orderByAsc(OrderSubscriptionMessageDb::getCreatedAt);
+    return this.list(queryWrapper);
+  }
+}
+

@@ -63,6 +63,13 @@ service MealOrderServiceRpc {
   rpc batchCreateDinerMealSuspensionRecords(BatchCreateDinerMealSuspensionRecordsRpcRequest) returns (BatchCreateDinerMealSuspensionRecordsRpcResponse);
   rpc updateDinerMealSuspensionRecord(UpdateDinerMealSuspensionRecordRpcRequest) returns (UpdateDinerMealSuspensionRecordRpcResponse);
   rpc deleteDinerMealSuspensionRecordsByIds(DeleteDinerMealSuspensionRecordsByIdsRpcRequest) returns (DeleteDinerMealSuspensionRecordsRpcResponse);
+
+  // 订餐订阅消息相关服务
+  rpc CreateOrderSubscriptionMessage (CreateOrderSubscriptionMessageRpcRequest) returns (CreateOrderSubscriptionMessageRpcResponse) {}
+  rpc GetUserOrderSubscriptionMessageHistory (GetUserOrderSubscriptionMessageHistoryRpcRequest) returns (GetUserOrderSubscriptionMessageHistoryRpcResponse) {}
+  rpc BatchDeleteOrderSubscriptionMessagesByIds (BatchDeleteOrderSubscriptionMessagesByIdsRpcRequest) returns (BatchDeleteOrderSubscriptionMessagesByIdsRpcResponse) {}
+  rpc BatchPhysicalDeleteOrderSubscriptionMessagesByIds (BatchPhysicalDeleteOrderSubscriptionMessagesByIdsRpcRequest) returns (BatchPhysicalDeleteOrderSubscriptionMessagesByIdsRpcResponse) {}
+  rpc QueryPendingOrderSubscriptionMessages (QueryPendingOrderSubscriptionMessagesRpcRequest) returns (QueryPendingOrderSubscriptionMessagesRpcResponse) {}
 }
 
 enum MealOrderOrderMethodEnum {
@@ -955,3 +962,76 @@ message BatchCreateDinerMealSuspensionRecordsRpcResponse {
   bool isCreated = 1;
   repeated int32 ids = 2;
 }
+
+// 订餐订阅消息相关消息定义
+message CreateOrderSubscriptionMessageRpcRequest {
+  int32 enterpriseId = 1;
+  int32 dinerId = 2;
+  string openId = 3;
+  string templateId = 4;
+  int64 orderPeriodStartDate = 5; // Unix 时间戳（毫秒），精确到秒
+  string jumpPath = 6; // 跳转路径（小程序 path），可选
+  int64 orderPeriodEndDate = 7; // Unix 时间戳（毫秒），精确到秒，可选
+}
+
+message CreateOrderSubscriptionMessageRpcResponse {
+  int64 id = 1;
+}
+
+message GetUserOrderSubscriptionMessageHistoryRpcRequest {
+  int32 enterpriseId = 1;
+  string openId = 2;
+  int64 orderPeriodStartDate = 3; // Unix 时间戳（毫秒），精确到秒，可选，如果传入则查询大于等于该值的记录
+}
+
+message OrderSubscriptionMessageRpcResponse {
+  int64 id = 1;
+  int64 orderPeriodStartDate = 2; // Unix 时间戳（毫秒），精确到秒
+  int64 createdAt = 3; // Unix 时间戳（毫秒）
+  bool isDeleted = 4;
+  string jumpPath = 5; // 跳转路径（小程序 path），可选
+  int64 orderPeriodEndDate = 6; // Unix 时间戳（毫秒），精确到秒，可选
+}
+
+message GetUserOrderSubscriptionMessageHistoryRpcResponse {
+  repeated OrderSubscriptionMessageRpcResponse response = 1;
+}
+
+message BatchDeleteOrderSubscriptionMessagesByIdsRpcRequest {
+  int32 enterpriseId = 1;
+  repeated int64 ids = 2; // 要删除的记录ID列表
+}
+
+message BatchDeleteOrderSubscriptionMessagesByIdsRpcResponse {
+  int32 affectedRows = 1; // 受影响的行数
+}
+
+message BatchPhysicalDeleteOrderSubscriptionMessagesByIdsRpcRequest {
+  int32 enterpriseId = 1;
+  repeated int64 ids = 2; // 要删除的记录ID列表
+}
+
+message BatchPhysicalDeleteOrderSubscriptionMessagesByIdsRpcResponse {
+  int32 affectedRows = 1; // 受影响的行数
+}
+
+// 查询待发送的订阅消息（未删除的记录）
+message QueryPendingOrderSubscriptionMessagesRpcRequest {
+  int32 enterpriseId = 1;
+}
+
+message PendingOrderSubscriptionMessageRpcResponse {
+  int64 id = 1;
+  int32 enterpriseId = 2;
+  int32 dinerId = 3;
+  string openId = 4;
+  string templateId = 5;
+  int64 orderPeriodStartDate = 6;
+  string jumpPath = 7;
+  int64 orderPeriodEndDate = 8;
+  int64 createdAt = 9;
+}
+
+message QueryPendingOrderSubscriptionMessagesRpcResponse {
+  repeated PendingOrderSubscriptionMessageRpcResponse responses = 1;
+}

+package com.tianting.infoloop.service;
+
+import com.infoloop.tianting.ordersubscriptionmessageservice.CreateOrderSubscriptionMessageRpcRequest;
+import com.infoloop.tianting.ordersubscriptionmessageservice.GetUserOrderSubscriptionMessageHistoryRpcRequest;
+
+import java.util.Arrays;
+import java.util.List;
+import com.tianting.infoloop.App;
+import com.tianting.infoloop.model.db.OrderSubscriptionMessageDb;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestInstance;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.test.context.ActiveProfiles;
+
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+@ActiveProfiles("dev")
+@SpringBootTest(classes = App.class)
+@TestInstance(TestInstance.Lifecycle.PER_CLASS)
+class OrderSubscriptionMessageDbServiceTest {
+
+  @Autowired
+  private JdbcTemplate jdbcTemplate;
+
+  @Autowired
+  private OrderSubscriptionMessageDbService orderSubscriptionMessageDbService;
+
+  @BeforeAll
+  void ensureTable() {
+    jdbcTemplate.execute(
+        "CREATE TABLE IF NOT EXISTS order_subscription_message ("
+            + "id BIGINT NOT NULL AUTO_INCREMENT COMMENT '主键ID',"
+            + "enterpriseId INT NOT NULL COMMENT '企业ID',"
+            + "dinerId INT DEFAULT NULL COMMENT '订餐用户ID（dinerId）',"
+            + "openId VARCHAR(255) NOT NULL COMMENT '微信用户OpenID',"
+            + "templateId VARCHAR(255) NOT NULL COMMENT '订阅消息模板ID',"
+            + "jumpPath VARCHAR(255) DEFAULT NULL COMMENT '跳转路径（小程序 path）',"
+            + "orderPeriodStartDate DATETIME DEFAULT NULL COMMENT '关联的订餐周期开始时间（精确到秒）',"
+            + "orderPeriodEndDate DATETIME DEFAULT NULL COMMENT '关联的订餐周期结束时间（精确到秒）',"
+            + "createdAt TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',"
+            + "updatedAt TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '修改时间',"
+            + "isDeleted TINYINT(1) NOT NULL DEFAULT 0 COMMENT '是否删除；0：未删除，1：已删除',"
+            + "PRIMARY KEY (id),"
+            + "KEY idx_enterprise_id (enterpriseId)"
+            + ") ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='订餐订阅消息授权表';");
+
+    // 兼容本地已存在的旧表结构（修改字段类型为 DATETIME，精确到秒）
+    Integer startDateType = jdbcTemplate.queryForObject(
+        "SELECT COUNT(1) FROM information_schema.COLUMNS "
+            + "WHERE table_schema = DATABASE() "
+            + "AND table_name = 'order_subscription_message' "
+            + "AND column_name = 'orderPeriodStartDate' "
+            + "AND data_type IN ('date', 'bigint')",
+        Integer.class);
+    if (startDateType != null && startDateType > 0) {
+      // 如果字段是 bigint，需要先清空数据或转换数据，这里先清空（测试环境）
+      jdbcTemplate.update("UPDATE order_subscription_message SET orderPeriodStartDate = NULL WHERE orderPeriodStartDate IS NOT NULL");
+      jdbcTemplate.execute(
+          "ALTER TABLE order_subscription_message "
+              + "MODIFY COLUMN orderPeriodStartDate DATETIME DEFAULT NULL COMMENT '关联的订餐周期开始时间（精确到秒）'");
+    }
+    
+    Integer endDateExists = jdbcTemplate.queryForObject(
+        "SELECT COUNT(1) FROM information_schema.COLUMNS "
+            + "WHERE table_schema = DATABASE() "
+            + "AND table_name = 'order_subscription_message' "
+            + "AND column_name = 'orderPeriodEndDate'",
+        Integer.class);
+    if (endDateExists == null || endDateExists == 0) {
+      jdbcTemplate.execute(
+          "ALTER TABLE order_subscription_message "
+              + "ADD COLUMN orderPeriodEndDate DATETIME DEFAULT NULL COMMENT '关联的订餐周期结束时间（精确到秒）' "
+              + "AFTER orderPeriodStartDate");
+    } else {
+      Integer endDateType = jdbcTemplate.queryForObject(
+          "SELECT COUNT(1) FROM information_schema.COLUMNS "
+              + "WHERE table_schema = DATABASE() "
+              + "AND table_name = 'order_subscription_message' "
+              + "AND column_name = 'orderPeriodEndDate' "
+              + "AND data_type IN ('date', 'bigint')",
+          Integer.class);
+      if (endDateType != null && endDateType > 0) {
+        // 如果字段是 bigint，需要先清空数据或转换数据，这里先清空（测试环境）
+        jdbcTemplate.update("UPDATE order_subscription_message SET orderPeriodEndDate = NULL WHERE orderPeriodEndDate IS NOT NULL");
+        jdbcTemplate.execute(
+            "ALTER TABLE order_subscription_message "
+                + "MODIFY COLUMN orderPeriodEndDate DATETIME DEFAULT NULL COMMENT '关联的订餐周期结束时间（精确到秒）'");
+      }
+    }
+  }
+
+  @Test
+  void shouldCreateAndQueryHistory() {
+    final String openId = "openId_test_junit_001";
+
+    // clean
+    jdbcTemplate.update("DELETE FROM order_subscription_message WHERE enterpriseId=? AND openId=?", 1, openId);
+
+    // create
+    CreateOrderSubscriptionMessageRpcRequest createReq = CreateOrderSubscriptionMessageRpcRequest.newBuilder()
+        .setEnterpriseId(1)
+        .setDinerId(100)
+        .setOpenId(openId)
+        .setTemplateId("template_test_junit_001")
+        .setJumpPath("/pages/order/index")
+        .setOrderPeriodStartDate(1738512000000L) // 2025-02-03 00:00:00 (毫秒时间戳，转换为 LocalDateTime)
+        .setOrderPeriodEndDate(1739030400000L) // 2025-02-09 00:00:00 (毫秒时间戳，转换为 LocalDateTime)
+        .build();
+
+    OrderSubscriptionMessageDb created = orderSubscriptionMessageDbService.createOrderSubscriptionMessage(createReq);
+    assertThat(created.getId()).isNotNull();
+    assertThat(created.getEnterpriseId()).isEqualTo(1);
+    assertThat(created.getDinerId()).isEqualTo(100);
+    assertThat(created.getJumpPath()).isEqualTo("/pages/order/index");
+    assertThat(created.getOrderPeriodEndDate()).isNotNull();
+
+    // query history
+    GetUserOrderSubscriptionMessageHistoryRpcRequest historyReq = GetUserOrderSubscriptionMessageHistoryRpcRequest.newBuilder()
+        .setEnterpriseId(1)
+        .setOpenId(openId)
+        .setOrderPeriodStartDate(0)
+        .build();
+
+    List<OrderSubscriptionMessageDb> list = orderSubscriptionMessageDbService.getUserOrderSubscriptionMessageHistory(historyReq);
+    assertThat(list).isNotEmpty();
+    assertThat(list.get(0).getOpenId()).isEqualTo(openId);
+    assertThat(list.get(0).getJumpPath()).isEqualTo("/pages/order/index");
+    assertThat(list.get(0).getOrderPeriodEndDate()).isNotNull();
+  }
+
+  @Test
+  void shouldQueryByOrderPeriodStartDateWithGreaterEqual() {
+    final String openId = "openId_test_junit_date_query";
+
+    // clean
+    jdbcTemplate.update("DELETE FROM order_subscription_message WHERE enterpriseId=? AND openId=?", 1, openId);
+
+    // 创建多条不同开始时间的记录
+    // 记录1: 2025-02-03 00:00:00
+    CreateOrderSubscriptionMessageRpcRequest createReq1 = CreateOrderSubscriptionMessageRpcRequest.newBuilder()
+        .setEnterpriseId(1)
+        .setDinerId(100)
+        .setOpenId(openId)
+        .setTemplateId("template_test_date_1")
+        .setJumpPath("/pages/order/index")
+        .setOrderPeriodStartDate(1738512000000L) // 2025-02-03 00:00:00
+        .setOrderPeriodEndDate(1739030400000L) // 2025-02-09 00:00:00
+        .build();
+    OrderSubscriptionMessageDb created1 = orderSubscriptionMessageDbService.createOrderSubscriptionMessage(createReq1);
+
+    // 记录2: 2025-02-10 00:00:00 (晚于记录1)
+    CreateOrderSubscriptionMessageRpcRequest createReq2 = CreateOrderSubscriptionMessageRpcRequest.newBuilder()
+        .setEnterpriseId(1)
+        .setDinerId(100)
+        .setOpenId(openId)
+        .setTemplateId("template_test_date_2")
+        .setJumpPath("/pages/order/index")
+        .setOrderPeriodStartDate(1739116800000L) // 2025-02-10 00:00:00
+        .setOrderPeriodEndDate(1739635200000L) // 2025-02-16 00:00:00
+        .build();
+    OrderSubscriptionMessageDb created2 = orderSubscriptionMessageDbService.createOrderSubscriptionMessage(createReq2);
+
+    // 记录3: 2025-01-27 00:00:00 (早于记录1)
+    CreateOrderSubscriptionMessageRpcRequest createReq3 = CreateOrderSubscriptionMessageRpcRequest.newBuilder()
+        .setEnterpriseId(1)
+        .setDinerId(100)
+        .setOpenId(openId)
+        .setTemplateId("template_test_date_3")
+        .setJumpPath("/pages/order/index")
+        .setOrderPeriodStartDate(1737907200000L) // 2025-01-27 00:00:00
+        .setOrderPeriodEndDate(1738425600000L) // 2025-02-02 00:00:00
+        .build();
+    OrderSubscriptionMessageDb created3 = orderSubscriptionMessageDbService.createOrderSubscriptionMessage(createReq3);
+
+    // 记录4: 2025-02-03 12:00:00 (等于记录1的日期，但时间更晚)
+    CreateOrderSubscriptionMessageRpcRequest createReq4 = CreateOrderSubscriptionMessageRpcRequest.newBuilder()
+        .setEnterpriseId(1)
+        .setDinerId(100)
+        .setOpenId(openId)
+        .setTemplateId("template_test_date_4")
+        .setJumpPath("/pages/order/index")
+        .setOrderPeriodStartDate(1738555200000L) // 2025-02-03 12:00:00
+        .setOrderPeriodEndDate(1739073600000L) // 2025-02-09 12:00:00
+        .build();
+    OrderSubscriptionMessageDb created4 = orderSubscriptionMessageDbService.createOrderSubscriptionMessage(createReq4);
+
+    // 测试1: 查询 orderPeriodStartDate >= 2025-02-03 00:00:00
+    // 应该返回: 记录1(等于), 记录2(大于), 记录4(大于)
+    // 不应该返回: 记录3(小于)
+    GetUserOrderSubscriptionMessageHistoryRpcRequest historyReq = GetUserOrderSubscriptionMessageHistoryRpcRequest.newBuilder()
+        .setEnterpriseId(1)
+        .setOpenId(openId)
+        .setOrderPeriodStartDate(1738512000000L) // 2025-02-03 00:00:00
+        .build();
+
+    List<OrderSubscriptionMessageDb> list = orderSubscriptionMessageDbService.getUserOrderSubscriptionMessageHistory(historyReq);
+    
+    // 验证返回的记录数量：应该包含记录1、记录2、记录4，共3条
+    assertThat(list.size()).isEqualTo(3);
+    
+    // 验证所有返回的记录的开始时间都 >= 2025-02-03 00:00:00
+    java.time.LocalDateTime threshold = java.time.Instant.ofEpochMilli(1738512000000L)
+        .atZone(java.time.ZoneId.systemDefault())
+        .toLocalDateTime();
+    
+    for (OrderSubscriptionMessageDb db : list) {
+      assertThat(db.getOrderPeriodStartDate()).isNotNull();
+      assertThat(db.getOrderPeriodStartDate().isAfter(threshold) || db.getOrderPeriodStartDate().isEqual(threshold))
+          .as("开始时间应该 >= 2025-02-03 00:00:00，实际: %s", db.getOrderPeriodStartDate())
+          .isTrue();
+    }
+    
+    // 验证包含记录1（等于）
+    assertThat(list.stream().anyMatch(db -> db.getId().equals(created1.getId()))).isTrue();
+    
+    // 验证包含记录2（大于）
+    assertThat(list.stream().anyMatch(db -> db.getId().equals(created2.getId()))).isTrue();
+    
+    // 验证包含记录4（大于，同一天但时间更晚）
+    assertThat(list.stream().anyMatch(db -> db.getId().equals(created4.getId()))).isTrue();
+    
+    // 验证不包含记录3（小于）
+    assertThat(list.stream().anyMatch(db -> db.getId().equals(created3.getId()))).isFalse();
+
+    // 测试2: 查询 orderPeriodStartDate >= 2025-02-10 00:00:00
+    // 应该只返回: 记录2(等于)
+    GetUserOrderSubscriptionMessageHistoryRpcRequest historyReq2 = GetUserOrderSubscriptionMessageHistoryRpcRequest.newBuilder()
+        .setEnterpriseId(1)
+        .setOpenId(openId)
+        .setOrderPeriodStartDate(1739116800000L) // 2025-02-10 00:00:00
+        .build();
+
+    List<OrderSubscriptionMessageDb> list2 = orderSubscriptionMessageDbService.getUserOrderSubscriptionMessageHistory(historyReq2);
+    
+    // 验证只返回记录2
+    assertThat(list2.size()).isEqualTo(1);
+    assertThat(list2.get(0).getId()).isEqualTo(created2.getId());
+  }
+
+  @Test
+  void shouldBatchDeleteByIds() {
+    final String openId = "openId_test_junit_delete";
+
+    // clean
+    jdbcTemplate.update("DELETE FROM order_subscription_message WHERE enterpriseId=? AND openId=?", 1, openId);
+
+    // create multiple records
+    CreateOrderSubscriptionMessageRpcRequest createReq1 = CreateOrderSubscriptionMessageRpcRequest.newBuilder()
+        .setEnterpriseId(1)
+        .setDinerId(100)
+        .setOpenId(openId)
+        .setTemplateId("template_test_junit_delete_1")
+        .setJumpPath("/pages/order/index")
+        .setOrderPeriodStartDate(1738512000000L)
+        .setOrderPeriodEndDate(1739030400000L)
+        .build();
+
+    CreateOrderSubscriptionMessageRpcRequest createReq2 = CreateOrderSubscriptionMessageRpcRequest.newBuilder()
+        .setEnterpriseId(1)
+        .setDinerId(100)
+        .setOpenId(openId)
+        .setTemplateId("template_test_junit_delete_2")
+        .setJumpPath("/pages/order/index")
+        .setOrderPeriodStartDate(1738512000000L)
+        .setOrderPeriodEndDate(1739030400000L)
+        .build();
+
+    OrderSubscriptionMessageDb created1 = orderSubscriptionMessageDbService.createOrderSubscriptionMessage(createReq1);
+    OrderSubscriptionMessageDb created2 = orderSubscriptionMessageDbService.createOrderSubscriptionMessage(createReq2);
+    List<Long> ids = Arrays.asList(created1.getId(), created2.getId());
+
+    // verify records exist
+    List<OrderSubscriptionMessageDb> beforeDelete = orderSubscriptionMessageDbService.getUserOrderSubscriptionMessageHistory(
+        GetUserOrderSubscriptionMessageHistoryRpcRequest.newBuilder()
+            .setEnterpriseId(1)
+            .setOpenId(openId)
+            .setOrderPeriodStartDate(0)
+            .build());
+    assertThat(beforeDelete.size()).isGreaterThanOrEqualTo(2);
+
+    // batch delete (逻辑删除)
+    int affectedRows = orderSubscriptionMessageDbService.batchDeleteByIds(ids, 1);
+    assertThat(affectedRows).isEqualTo(2);
+
+    // verify deleted - 逻辑删除后查询不到
+    List<OrderSubscriptionMessageDb> afterDelete = orderSubscriptionMessageDbService.getUserOrderSubscriptionMessageHistory(
+        GetUserOrderSubscriptionMessageHistoryRpcRequest.newBuilder()
+            .setEnterpriseId(1)
+            .setOpenId(openId)
+            .setOrderPeriodStartDate(0)
+            .build());
+    assertThat(afterDelete.size()).isLessThan(beforeDelete.size());
+
+    // verify deleted - 但数据库里还存在（isDeleted=1）
+    Integer count = jdbcTemplate.queryForObject(
+        "SELECT COUNT(1) FROM order_subscription_message WHERE id IN (?,?) AND isDeleted=1",
+        Integer.class,
+        created1.getId(), created2.getId());
+    assertThat(count).isEqualTo(2);
+  }
+
+  @Test
+  void shouldBatchPhysicalDeleteByIds() {
+    final String openId = "openId_test_junit_physical_delete";
+
+    // clean
+    jdbcTemplate.update("DELETE FROM order_subscription_message WHERE enterpriseId=? AND openId=?", 1, openId);
+
+    // create multiple records
+    CreateOrderSubscriptionMessageRpcRequest createReq1 = CreateOrderSubscriptionMessageRpcRequest.newBuilder()
+        .setEnterpriseId(1)
+        .setDinerId(100)
+        .setOpenId(openId)
+        .setTemplateId("template_test_junit_physical_delete_1")
+        .setJumpPath("/pages/order/index")
+        .setOrderPeriodStartDate(1738512000000L)
+        .setOrderPeriodEndDate(1739030400000L)
+        .build();
+
+    CreateOrderSubscriptionMessageRpcRequest createReq2 = CreateOrderSubscriptionMessageRpcRequest.newBuilder()
+        .setEnterpriseId(1)
+        .setDinerId(100)
+        .setOpenId(openId)
+        .setTemplateId("template_test_junit_physical_delete_2")
+        .setJumpPath("/pages/order/index")
+        .setOrderPeriodStartDate(1738512000000L)
+        .setOrderPeriodEndDate(1739030400000L)
+        .build();
+
+    OrderSubscriptionMessageDb created1 = orderSubscriptionMessageDbService.createOrderSubscriptionMessage(createReq1);
+    OrderSubscriptionMessageDb created2 = orderSubscriptionMessageDbService.createOrderSubscriptionMessage(createReq2);
+    List<Long> ids = Arrays.asList(created1.getId(), created2.getId());
+
+    // batch physical delete
+    int affectedRows = orderSubscriptionMessageDbService.batchPhysicalDeleteByIds(ids, 1);
+    assertThat(affectedRows).isEqualTo(2);
+
+    // verify deleted - 物理删除后数据库里也不存在
+    Integer count = jdbcTemplate.queryForObject(
+        "SELECT COUNT(1) FROM order_subscription_message WHERE id IN (?,?)",
+        Integer.class,
+        created1.getId(), created2.getId());
+    assertThat(count).isEqualTo(0);
+  }
+}
+