农信点餐小程序

@@ -6,13 +6,12 @@
  */
 
 plugins {
-    // Apply the application plugin to add support for building a CLI application in Java.
     id 'java'
     id 'idea'
     id 'application'
-    id 'org.springframework.boot' version '2.3.3.RELEASE'
-    id 'io.spring.dependency-management' version '1.0.10.RELEASE'
-    id 'com.google.protobuf' version '0.9.3'
+    id 'org.springframework.boot' version '2.5.12'
+    id 'io.spring.dependency-management' version '1.1.6'
+    id 'com.google.protobuf' version '0.9.4'
 }
 
 repositories {
@@ -29,8 +28,8 @@ application {
 }
 
 ext {
-    grpcVersion = '1.39.0'
-    protobufVersion = '3.17.2'
+    grpcVersion = '1.62.2'
+    protobufVersion = '3.25.3'
 }
 
 dependencies {
@@ -55,20 +54,13 @@ dependencies {
     testImplementation "io.grpc:grpc-testing:${grpcVersion}"
 }
 
-static def isAppleSilicon() {
-    // 检测 macOS 并且使用的是 Apple Silicon 架构
-    return System.getProperty('os.name').toLowerCase().contains('mac') && System.getProperty('os.arch').equals('aarch64')
-}
-
-def protocPlatform = isAppleSilicon() ? ':osx-x86_64' : '';
-
 protobuf {
     protoc {
-        artifact = "com.google.protobuf:protoc:${protobufVersion}${protocPlatform}"
+        artifact = "com.google.protobuf:protoc:${protobufVersion}"
     }
     plugins {
         grpc {
-            artifact = "io.grpc:protoc-gen-grpc-java:${grpcVersion}${protocPlatform}"
+            artifact = "io.grpc:protoc-gen-grpc-java:${grpcVersion}"
         }
     }
     generateProtoTasks {
@@ -87,6 +79,13 @@ tasks.withType(JavaCompile).configureEach {
     it.options.fork = true
 }
 
+tasks {
+    compileJava {
+        dependsOn generateProto
+        source fileTree('build/generated/source/proto/main/java')
+    }
+}
+
 sourceSets {
     main {
         java {

 org.gradle.daemon=true
 org.gradle.parallel=true
 org.gradle.caching=true
-org.gradle.jvmargs=-Xmx4096m -XX:MetaspaceSize=512m -XX:MaxMetaspaceSize=1024m -XX:+HeapDumpOnOutOfMemoryError -Dfile.encoding=UTF-8
+org.gradle.jvmargs=-Xmx8g -XX:MaxMetaspaceSize=1024m -XX:+HeapDumpOnOutOfMemoryError -Dfile.encoding=UTF-8
+org.gradle.incremental=true
 org.gradle.configureondemand=true
-org.gradle.java.home=/usr/lib/jvm/java-11-openjdk-amd64
\ No newline at end of file
+org.gradle.configuration-cache=true
\ No newline at end of file

 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https://mirrors.cloud.tencent.com/gradle/gradle-6.9-bin.zip
+distributionUrl=https://mirrors.cloud.tencent.com/gradle/gradle-8.11-bin.zip
 networkTimeout=10000
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
+#org.gradle.java.home=/usr/lib/jvm/java-17-openjdk-amd64
\ No newline at end of file

@@ -9,6 +9,7 @@ import brave.propagation.B3Propagation;
 import brave.propagation.CurrentTraceContext;
 import brave.propagation.TraceContext;
 import brave.sampler.Sampler;
+import com.tianting.infoloop.service.grpc.MealOrderGrpcService;
 import com.tianting.infoloop.service.grpc.OrderGrpcService;
 import io.grpc.Server;
 import io.grpc.ServerInterceptor;
@@ -64,10 +65,12 @@ public class AppConfig implements ApplicationContextAware {
     @Bean
     public Server serviceServer(@Value(SERVICE_PORT) final int port,
                                 final ServerInterceptor serverInterceptor,
-                                final OrderGrpcService orderGrpcService) {
+                                final OrderGrpcService orderGrpcService,
+                                final MealOrderGrpcService mealOrderGrpcService) {
         return NettyServerBuilder
                 .forPort(port)
                 .addService(ServerInterceptors.intercept(orderGrpcService, serverInterceptor))
+                .addService(ServerInterceptors.intercept(mealOrderGrpcService, serverInterceptor))
                 .build();
     }
 }

+package com.tianting.infoloop.mapper;
+
+import com.tianting.infoloop.inject.MyBaseMapper;
+import com.tianting.infoloop.model.db.Diner;
+
+/**
+* @author zhuyf
+* @description 针对表【diners(就餐人表)】的数据库操作Mapper
+* @createDate 2025-04-10 13:22:20
+* @Entity com.tianting.infoloop.model.db.Diner
+*/
+public interface DinerMapper extends MyBaseMapper<Diner> {
+
+}
+
+
+
+

+package com.tianting.infoloop.mapper;
+
+import com.tianting.infoloop.inject.MyBaseMapper;
+import com.tianting.infoloop.model.db.GradeClass;
+
+/**
+* @author zhuyf
+* @description 针对表【grade_classes(年级班级表)】的数据库操作Mapper
+* @createDate 2025-04-10 13:22:20
+* @Entity com.tianting.infoloop.model.db.GradeClass
+*/
+public interface GradeClassMapper extends MyBaseMapper<GradeClass> {
+
+}
+
+
+
+

+package com.tianting.infoloop.mapper;
+
+import com.tianting.infoloop.inject.MyBaseMapper;
+import com.tianting.infoloop.model.db.MealMenuRecord;
+
+/**
+* @author zhuyf
+* @description 针对表【meal_menu_records(餐单记录表)】的数据库操作Mapper
+* @createDate 2025-04-10 13:22:20
+* @Entity com.tianting.infoloop.model.db.MealMenuRecord
+*/
+public interface MealMenuRecordMapper extends MyBaseMapper<MealMenuRecord> {
+
+}
+
+
+
+

+package com.tianting.infoloop.mapper;
+
+import com.tianting.infoloop.inject.MyBaseMapper;
+import com.tianting.infoloop.model.db.MealOrder;
+
+/**
+* @author zhuyf
+* @description 针对表【meal_orders(订餐记录表)】的数据库操作Mapper
+* @createDate 2025-04-10 13:22:20
+* @Entity com.tianting.infoloop.model.db.MealOrder
+*/
+public interface MealOrderMapper extends MyBaseMapper<MealOrder> {
+
+}
+
+
+
+

+package com.tianting.infoloop.mapper;
+
+import com.tianting.infoloop.inject.MyBaseMapper;
+import com.tianting.infoloop.model.db.MpAccountDinerRef;
+
+/**
+* @author zhuyf
+* @description 针对表【mp_account_diner_refs(小程序账号和就餐人关联表)】的数据库操作Mapper
+* @createDate 2025-04-10 13:22:20
+* @Entity com.tianting.infoloop.model.db.MpAccountDinerRef
+*/
+public interface MpAccountDinerRefMapper extends MyBaseMapper<MpAccountDinerRef> {
+
+}
+
+
+
+

+package com.tianting.infoloop.mapper;
+
+import com.tianting.infoloop.inject.MyBaseMapper;
+import com.tianting.infoloop.model.db.MpAccount;
+
+/**
+* @author zhuyf
+* @description 针对表【mp_accounts(小程序账号表)】的数据库操作Mapper
+* @createDate 2025-04-10 13:22:20
+* @Entity com.tianting.infoloop.model.db.MpAccount
+*/
+public interface MpAccountMapper extends MyBaseMapper<MpAccount> {
+
+}
+
+
+
+

+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.io.Serializable;
+import java.time.LocalDateTime;
+
+/**
+ * @TableName diners
+ */
+@Data
+@Accessors(chain = true)
+@EqualsAndHashCode(callSuper = true)
+@TableName(value ="diners")
+public class Diner extends Model<Diner> implements Serializable  {
+
+    @TableId(type = IdType.AUTO)
+    private Integer id;
+
+    private Integer enterpriseId;
+
+    private Integer clientId;
+
+    private Integer classId;
+
+    private String studentNo;
+
+    private String name;
+
+    private Integer createdBy;
+
+    @TableField(fill = FieldFill.INSERT)
+    private LocalDateTime createdAt;
+
+    private Integer creationSource;
+
+    private Integer updatedBy;
+
+    @TableField(fill = FieldFill.INSERT_UPDATE)
+    private LocalDateTime updatedAt;
+
+    private Integer updateSource;
+
+    @TableLogic
+    private Boolean isDeleted;
+}
\ No newline at end of file

+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.TableName;
+import com.baomidou.mybatisplus.extension.activerecord.Model;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.experimental.Accessors;
+
+import java.io.Serializable;
+import java.time.LocalDateTime;
+
+/**
+ * @TableName grade_classes
+ */
+@Data
+@Accessors(chain = true)
+@EqualsAndHashCode(callSuper = true)
+@TableName(value ="grade_classes")
+public class GradeClass extends Model<GradeClass> implements Serializable {
+
+    @TableId(type = IdType.AUTO)
+    private Integer id;
+
+    private Integer enterpriseId;
+
+    private Integer clientId;
+
+    private String gradeName;
+
+    private String className;
+
+    private String fullName;
+
+    private Integer createdBy;
+
+    @TableField(fill = FieldFill.INSERT)
+    private LocalDateTime createdAt;
+
+    private Integer creationSource;
+
+    private Integer updatedBy;
+
+    @TableField(fill = FieldFill.INSERT_UPDATE)
+    private LocalDateTime updatedAt;
+
+    private Integer updateSource;
+
+    private Boolean isDeleted;
+}
\ No newline at end of file

+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.TableName;
+import com.baomidou.mybatisplus.extension.activerecord.Model;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.experimental.Accessors;
+
+import java.io.Serializable;
+import java.time.LocalDateTime;
+
+/**
+ * @TableName meal_menu_records
+ */
+@Data
+@Accessors(chain = true)
+@EqualsAndHashCode(callSuper = true)
+@TableName(value ="meal_menu_records")
+public class MealMenuRecord extends Model<MealMenuRecord> implements Serializable {
+
+    @TableId(type = IdType.AUTO)
+    private Integer id;
+
+    private Integer enterpriseId;
+
+    private Integer clientId;
+
+    private String name;
+
+    private String imageUrl;
+
+    private Integer createdBy;
+
+    @TableField(fill = FieldFill.INSERT)
+    private LocalDateTime createdAt;
+
+    private Integer creationSource;
+
+    private Integer updatedBy;
+
+    @TableField(fill = FieldFill.INSERT_UPDATE)
+    private LocalDateTime updatedAt;
+
+    private Integer updateSource;
+
+    private Boolean isDeleted;
+}
\ No newline at end of file

+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.TableName;
+import com.baomidou.mybatisplus.extension.activerecord.Model;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.experimental.Accessors;
+
+import java.io.Serializable;
+import java.time.LocalDateTime;
+
+/**
+ * @TableName meal_orders
+ */
+@Data
+@Accessors(chain = true)
+@EqualsAndHashCode(callSuper = true)
+@TableName(value ="meal_orders")
+public class MealOrder extends Model<MealOrder> implements Serializable {
+
+    @TableId(type = IdType.AUTO)
+    private Integer id;
+
+    private Integer enterpriseId;
+
+    private Integer clientId;
+
+    private Integer menuId;
+
+    private Integer accountId;
+
+    private Integer orderMethod;
+
+    private Integer dinerId;
+
+    private String dinerName;
+
+    private String clientName;
+
+    private String gradeName;
+
+    private String className;
+
+    private String studentNo;
+
+    private LocalDateTime reserveDate;
+
+    private String meals;
+
+    private Integer createdBy;
+
+    @TableField(fill = FieldFill.INSERT)
+    private LocalDateTime createdAt;
+
+    private Integer creationSource;
+
+    private Integer updatedBy;
+
+    @TableField(fill = FieldFill.INSERT_UPDATE)
+    private LocalDateTime updatedAt;
+
+    private Integer updateSource;
+
+    private Boolean isDeleted;
+}
\ No newline at end of file

+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.TableName;
+import com.baomidou.mybatisplus.extension.activerecord.Model;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.experimental.Accessors;
+
+import java.io.Serializable;
+import java.time.LocalDateTime;
+
+/**
+ * @TableName mp_accounts
+ */
+@Data
+@Accessors(chain = true)
+@EqualsAndHashCode(callSuper = true)
+@TableName(value ="mp_accounts")
+public class MpAccount extends Model<MpAccount> implements Serializable {
+
+    @TableId(type = IdType.AUTO)
+    private Integer id;
+
+    private Integer enterpriseId;
+
+    private String openId;
+
+    private String unionId;
+
+    private String nickname;
+
+    private String avatarUrl;
+
+    private Integer gender;
+
+    private String phoneNumber;
+
+    private Integer status;
+
+    private Integer createdBy;
+
+    @TableField(fill = FieldFill.INSERT)
+    private LocalDateTime createdAt;
+
+    private Integer creationSource;
+
+    private Integer updatedBy;
+
+    @TableField(fill = FieldFill.INSERT_UPDATE)
+    private LocalDateTime updatedAt;
+
+    private Integer updateSource;
+
+    private Boolean isDeleted;
+}
\ No newline at end of file

+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.TableName;
+import com.baomidou.mybatisplus.extension.activerecord.Model;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.experimental.Accessors;
+
+import java.io.Serializable;
+import java.time.LocalDateTime;
+
+/**
+ * @TableName mp_account_diner_refs
+ */
+@Data
+@Accessors(chain = true)
+@EqualsAndHashCode(callSuper = true)
+@TableName(value ="mp_account_diner_refs")
+public class MpAccountDinerRef extends Model<MpAccountDinerRef> implements Serializable {
+
+    @TableId(type = IdType.AUTO)
+    private Integer id;
+
+    private Integer enterpriseId;
+
+    private Integer accountId;
+
+    private Integer dinerId;
+
+    private Integer createdBy;
+
+    @TableField(fill = FieldFill.INSERT)
+    private LocalDateTime createdAt;
+
+    private Integer creationSource;
+}
\ No newline at end of file

+package com.tianting.infoloop.service;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.tianting.infoloop.model.db.Diner;
+
+/**
+* @author zhuyf
+* @description 针对表【diners(就餐人表)】的数据库操作Service
+* @createDate 2025-04-10 13:22:20
+*/
+public interface DinerService extends IService<Diner> {
+
+}

+package com.tianting.infoloop.service;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.tianting.infoloop.model.db.GradeClass;
+
+/**
+* @author zhuyf
+* @description 针对表【grade_classes(年级班级表)】的数据库操作Service
+* @createDate 2025-04-10 13:22:20
+*/
+public interface GradeClassService extends IService<GradeClass> {
+
+}

+package com.tianting.infoloop.service;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.tianting.infoloop.model.db.MealMenuRecord;
+
+/**
+* @author zhuyf
+* @description 针对表【meal_menu_records(餐单记录表)】的数据库操作Service
+* @createDate 2025-04-10 13:22:20
+*/
+public interface MealMenuRecordService extends IService<MealMenuRecord> {
+
+}

+package com.tianting.infoloop.service;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.tianting.infoloop.model.db.MealOrder;
+
+/**
+* @author zhuyf
+* @description 针对表【meal_orders(订餐记录表)】的数据库操作Service
+* @createDate 2025-04-10 13:22:20
+*/
+public interface MealOrderService extends IService<MealOrder> {
+
+}

+package com.tianting.infoloop.service;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.tianting.infoloop.model.db.MpAccountDinerRef;
+
+/**
+* @author zhuyf
+* @description 针对表【mp_account_diner_refs(小程序账号和就餐人关联表)】的数据库操作Service
+* @createDate 2025-04-10 13:22:20
+*/
+public interface MpAccountDinerRefService extends IService<MpAccountDinerRef> {
+
+}

+package com.tianting.infoloop.service;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.tianting.infoloop.model.db.MpAccount;
+
+/**
+* @author zhuyf
+* @description 针对表【mp_accounts(小程序账号表)】的数据库操作Service
+* @createDate 2025-04-10 13:22:20
+*/
+public interface MpAccountService extends IService<MpAccount> {
+
+}

+package com.tianting.infoloop.service.grpc;
+
+import cn.hutool.core.date.LocalDateTimeUtil;
+import com.baomidou.dynamic.datasource.annotation.DS;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.core.toolkit.Wrappers;
+import com.infoloop.tianting.mealorderservice.BatchCreateGradeClassesRpcRequest;
+import com.infoloop.tianting.mealorderservice.BatchCreateGradeClassesRpcResponse;
+import com.infoloop.tianting.mealorderservice.BatchCreateMealOrdersRpcRequest;
+import com.infoloop.tianting.mealorderservice.BatchCreateMealOrdersRpcResponse;
+import com.infoloop.tianting.mealorderservice.BatchSaveOrUpdateDinersRpcRequest;
+import com.infoloop.tianting.mealorderservice.BatchSaveOrUpdateDinersRpcResponse;
+import com.infoloop.tianting.mealorderservice.BatchSaveOrUpdateGradeClassesRpcRequest;
+import com.infoloop.tianting.mealorderservice.BatchSaveOrUpdateGradeClassesRpcResponse;
+import com.infoloop.tianting.mealorderservice.CreateDinerRpcRequest;
+import com.infoloop.tianting.mealorderservice.CreateDinerRpcResponse;
+import com.infoloop.tianting.mealorderservice.CreateGradeClassRpcRequest;
+import com.infoloop.tianting.mealorderservice.CreateGradeClassRpcResponse;
+import com.infoloop.tianting.mealorderservice.CreateMealMenuRecordRpcRequest;
+import com.infoloop.tianting.mealorderservice.CreateMealMenuRecordRpcResponse;
+import com.infoloop.tianting.mealorderservice.CreateMealOrderRpcRequest;
+import com.infoloop.tianting.mealorderservice.CreateMealOrderRpcResponse;
+import com.infoloop.tianting.mealorderservice.CreateMpAccountDinerRefRpcRequest;
+import com.infoloop.tianting.mealorderservice.CreateMpAccountDinerRefRpcResponse;
+import com.infoloop.tianting.mealorderservice.CreateMpAccountRpcRequest;
+import com.infoloop.tianting.mealorderservice.CreateMpAccountRpcResponse;
+import com.infoloop.tianting.mealorderservice.DeleteDinersByIdsRpcRequest;
+import com.infoloop.tianting.mealorderservice.DeleteDinersRpcResponse;
+import com.infoloop.tianting.mealorderservice.DeleteGradeClassesAndDinersByClassIdsRpcRequest;
+import com.infoloop.tianting.mealorderservice.DeleteGradeClassesAndDinersByClassIdsRpcResponse;
+import com.infoloop.tianting.mealorderservice.DeleteGradeClassesAndDinersByClientIdsRpcRequest;
+import com.infoloop.tianting.mealorderservice.DeleteGradeClassesAndDinersByClientIdsRpcResponse;
+import com.infoloop.tianting.mealorderservice.DeleteGradeClassesByIdsRpcRequest;
+import com.infoloop.tianting.mealorderservice.DeleteGradeClassesRpcResponse;
+import com.infoloop.tianting.mealorderservice.DeleteMealOrdersByIdsRpcRequest;
+import com.infoloop.tianting.mealorderservice.DeleteMealOrdersRpcResponse;
+import com.infoloop.tianting.mealorderservice.DeleteMpAccountDinerRefsByIdsRpcRequest;
+import com.infoloop.tianting.mealorderservice.DeleteMpAccountDinerRefsRpcResponse;
+import com.infoloop.tianting.mealorderservice.DeleteMpAccountsByIdsRpcRequest;
+import com.infoloop.tianting.mealorderservice.DeleteMpAccountsRpcResponse;
+import com.infoloop.tianting.mealorderservice.DinerModification;
+import com.infoloop.tianting.mealorderservice.GetDinerByIdRpcRequest;
+import com.infoloop.tianting.mealorderservice.GetDinerByIdRpcResponse;
+import com.infoloop.tianting.mealorderservice.GetDinersByIdsRpcRequest;
+import com.infoloop.tianting.mealorderservice.GetDinersByIdsRpcResponse;
+import com.infoloop.tianting.mealorderservice.GetGradeClassByIdRpcRequest;
+import com.infoloop.tianting.mealorderservice.GetGradeClassByIdRpcResponse;
+import com.infoloop.tianting.mealorderservice.GetGradeClassesByIdsRpcRequest;
+import com.infoloop.tianting.mealorderservice.GetGradeClassesByIdsRpcResponse;
+import com.infoloop.tianting.mealorderservice.GetMealMenuRecordByIdRpcRequest;
+import com.infoloop.tianting.mealorderservice.GetMealMenuRecordByIdRpcResponse;
+import com.infoloop.tianting.mealorderservice.GetMealMenuRecordsByIdsRpcRequest;
+import com.infoloop.tianting.mealorderservice.GetMealMenuRecordsByIdsRpcResponse;
+import com.infoloop.tianting.mealorderservice.GetMealOrderByIdRpcRequest;
+import com.infoloop.tianting.mealorderservice.GetMealOrderByIdRpcResponse;
+import com.infoloop.tianting.mealorderservice.GetMealOrdersByIdsRpcRequest;
+import com.infoloop.tianting.mealorderservice.GetMealOrdersByIdsRpcResponse;
+import com.infoloop.tianting.mealorderservice.GetMpAccountByIdRpcRequest;
+import com.infoloop.tianting.mealorderservice.GetMpAccountByIdRpcResponse;
+import com.infoloop.tianting.mealorderservice.GetMpAccountByOpenIdRpcRequest;
+import com.infoloop.tianting.mealorderservice.GetMpAccountByOpenIdRpcResponse;
+import com.infoloop.tianting.mealorderservice.GetMpAccountDinerRefsByIdsRpcRequest;
+import com.infoloop.tianting.mealorderservice.GetMpAccountDinerRefsByIdsRpcResponse;
+import com.infoloop.tianting.mealorderservice.GetMpAccountsByIdsRpcRequest;
+import com.infoloop.tianting.mealorderservice.GetMpAccountsByIdsRpcResponse;
+import com.infoloop.tianting.mealorderservice.MealOrderServiceRpcGrpc;
+import com.infoloop.tianting.mealorderservice.MenuSchedule;
+import com.infoloop.tianting.mealorderservice.QueryDinersByConditionRpcRequest;
+import com.infoloop.tianting.mealorderservice.QueryDinersByConditionRpcResponse;
+import com.infoloop.tianting.mealorderservice.QueryGradeClassesByConditionRpcRequest;
+import com.infoloop.tianting.mealorderservice.QueryGradeClassesByConditionRpcResponse;
+import com.infoloop.tianting.mealorderservice.QueryLatestMealMenuRecordsByClientIdsRpcRequest;
+import com.infoloop.tianting.mealorderservice.QueryLatestMealMenuRecordsByClientIdsRpcResponse;
+import com.infoloop.tianting.mealorderservice.QueryMealMenuRecordsByConditionRpcRequest;
+import com.infoloop.tianting.mealorderservice.QueryMealMenuRecordsByConditionRpcResponse;
+import com.infoloop.tianting.mealorderservice.QueryMealOrdersByConditionRpcRequest;
+import com.infoloop.tianting.mealorderservice.QueryMealOrdersByConditionRpcResponse;
+import com.infoloop.tianting.mealorderservice.QueryMpAccountDinerRefsByConditionRpcRequest;
+import com.infoloop.tianting.mealorderservice.QueryMpAccountDinerRefsByConditionRpcResponse;
+import com.infoloop.tianting.mealorderservice.QueryMpAccountsByConditionRpcRequest;
+import com.infoloop.tianting.mealorderservice.QueryMpAccountsByConditionRpcResponse;
+import com.infoloop.tianting.mealorderservice.QueryReserveMealOrdersByDinerIdsRpcRequest;
+import com.infoloop.tianting.mealorderservice.QueryReserveMealOrdersByDinerIdsRpcResponse;
+import com.infoloop.tianting.mealorderservice.SingleDinerRpcResponse;
+import com.infoloop.tianting.mealorderservice.SingleGradeClassRpcResponse;
+import com.infoloop.tianting.mealorderservice.SingleMealMenuRecordRpcResponse;
+import com.infoloop.tianting.mealorderservice.SingleMealOrderRpcResponse;
+import com.infoloop.tianting.mealorderservice.SingleMpAccountDinerRefRpcResponse;
+import com.infoloop.tianting.mealorderservice.SingleMpAccountRpcResponse;
+import com.infoloop.tianting.mealorderservice.UpdateDinerRpcRequest;
+import com.infoloop.tianting.mealorderservice.UpdateDinerRpcResponse;
+import com.infoloop.tianting.mealorderservice.UpdateGradeClassRpcRequest;
+import com.infoloop.tianting.mealorderservice.UpdateGradeClassRpcResponse;
+import com.infoloop.tianting.mealorderservice.UpdateMpAccountRpcRequest;
+import com.infoloop.tianting.mealorderservice.UpdateMpAccountRpcResponse;
+import com.tianting.infoloop.model.db.Diner;
+import com.tianting.infoloop.model.db.GradeClass;
+import com.tianting.infoloop.model.db.MealMenuRecord;
+import com.tianting.infoloop.model.db.MealOrder;
+import com.tianting.infoloop.model.db.MpAccount;
+import com.tianting.infoloop.model.db.MpAccountDinerRef;
+import com.tianting.infoloop.service.DinerService;
+import com.tianting.infoloop.service.GradeClassService;
+import com.tianting.infoloop.service.MealMenuRecordService;
+import com.tianting.infoloop.service.MealOrderService;
+import com.tianting.infoloop.service.MpAccountDinerRefService;
+import com.tianting.infoloop.service.MpAccountService;
+import com.tianting.infoloop.utils.ProtoBeanUtil;
+import io.grpc.Status;
+import io.grpc.stub.StreamObserver;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.time.DayOfWeek;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.LocalTime;
+import java.time.temporal.TemporalAdjusters;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+import static com.tianting.infoloop.constants.ConfigConstants.DATA_SOURCE_MASTER;
+import static com.tianting.infoloop.constants.ConfigConstants.DATA_SOURCE_SLAVE;
+
+@Slf4j
+@Service
+@RequiredArgsConstructor(onConstructor_ = @Autowired)
+public class MealOrderGrpcService extends MealOrderServiceRpcGrpc.MealOrderServiceRpcImplBase {
+
+    private final DinerService dinerService;
+
+    private final GradeClassService gradeClassService;
+
+    private final MealMenuRecordService mealMenuRecordService;
+
+    private final MealOrderService mealOrderService;
+
+    private final MpAccountDinerRefService mpAccountDinerRefService;
+
+    private final MpAccountService mpAccountService;
+
+    @Override
+    @DS(DATA_SOURCE_SLAVE)
+    public void getMealOrderById(final GetMealOrderByIdRpcRequest request,
+                                 final StreamObserver<GetMealOrderByIdRpcResponse> responseObserver) {
+        final var builder = GetMealOrderByIdRpcResponse.newBuilder();
+        try {
+            final var mealOrder = mealOrderService.getById(request.getId());
+            if (mealOrder != null) {
+                final var mealOrderRpcResponse = ProtoBeanUtil.beanToProto(mealOrder, SingleMealOrderRpcResponse.class, "meals");
+                final var build = mealOrderRpcResponse.toBuilder().addAllMeals(ProtoBeanUtil.jsonToProtoList(mealOrder.getMeals(), MenuSchedule.class)).build();
+                builder.setResponse(build);
+            }
+        } catch (final Exception e) {
+            log.error("getMealOrderById error;", e);
+            responseObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException());
+        }
+        responseObserver.onNext(builder.build());
+        responseObserver.onCompleted();
+    }
+
+    @Override
+    @DS(DATA_SOURCE_SLAVE)
+    public void getMealOrdersByIds(final GetMealOrdersByIdsRpcRequest request,
+                                   final StreamObserver<GetMealOrdersByIdsRpcResponse> responseObserver) {
+        final var builder = GetMealOrdersByIdsRpcResponse.newBuilder();
+        try {
+            final var mealOrders = mealOrderService.listByIds(request.getIdsList());
+            if (!mealOrders.isEmpty()) {
+                for (final var mealOrder : mealOrders) {
+                    final var mealOrderRpcResponse = ProtoBeanUtil.beanToProto(mealOrder, SingleMealOrderRpcResponse.class, "meals");
+                    final var build = mealOrderRpcResponse.toBuilder().addAllMeals(ProtoBeanUtil.jsonToProtoList(mealOrder.getMeals(), MenuSchedule.class)).build();
+                    builder.addResponses(build);
+                }
+            }
+        } catch (final Exception e) {
+            log.error("getMealOrdersByIds error;", e);
+            responseObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException());
+        }
+        responseObserver.onNext(builder.build());
+        responseObserver.onCompleted();
+    }
+
+    @Override
+    @DS(DATA_SOURCE_SLAVE)
+    public void queryMealOrdersByCondition(final QueryMealOrdersByConditionRpcRequest request,
+                                           final StreamObserver<QueryMealOrdersByConditionRpcResponse> responseObserver) {
+        final var builder = QueryMealOrdersByConditionRpcResponse.newBuilder();
+        try {
+            LambdaQueryWrapper<MealOrder> queryWrapper = new LambdaQueryWrapper<>();
+            queryWrapper.eq(MealOrder::getEnterpriseId, request.getEnterpriseId());
+            if (request.getShouldFilterClientIds()) {
+                queryWrapper.in(!request.getClientIdsList().isEmpty(), MealOrder::getClientId, request.getClientIdsList());
+            }
+            if (request.getShouldFilterMenuIds()) {
+                queryWrapper.in(!request.getMenuIdsList().isEmpty(), MealOrder::getMenuId, request.getMenuIdsList());
+            }
+            if (request.getShouldFilterAccountIds()) {
+                queryWrapper.in(!request.getAccountIdsList().isEmpty(), MealOrder::getAccountId, request.getAccountIdsList());
+            }
+            if (request.getShouldFilterOrderMethod()) {
+                queryWrapper.eq(MealOrder::getOrderMethod, request.getOrderMethodValue());
+            }
+            if (request.getShouldFilterDinerIds()) {
+                queryWrapper.in(!request.getDinerIdsList().isEmpty(), MealOrder::getDinerId, request.getDinerIdsList());
+            }
+            if (request.getShouldFilterReserveDateStart()) {
+                queryWrapper.ge(MealOrder::getReserveDate, LocalDateTimeUtil.of(request.getReserveDateStart()));
+            }
+            if (request.getShouldFilterReserveDateEnd()) {
+                queryWrapper.lt(MealOrder::getReserveDate, LocalDateTimeUtil.of(request.getReserveDateEnd()));
+            }
+            queryWrapper.orderByDesc(MealOrder::getReserveDate);
+            final var mealOrders = mealOrderService.list(queryWrapper);
+            if (!mealOrders.isEmpty()) {
+                for (final var mealOrder : mealOrders) {
+                    final var mealOrderRpcResponse = ProtoBeanUtil.beanToProto(mealOrder, SingleMealOrderRpcResponse.class, "meals");
+                    final var build = mealOrderRpcResponse.toBuilder().addAllMeals(ProtoBeanUtil.jsonToProtoList(mealOrder.getMeals(), MenuSchedule.class)).build();
+                    builder.addResponses(build);
+                }
+            }
+        } catch (final Exception e) {
+            log.error("queryMealOrdersByCondition error;", e);
+            responseObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException());
+        }
+        responseObserver.onNext(builder.build());
+        responseObserver.onCompleted();
+    }
+
+    @Override
+    @DS(DATA_SOURCE_SLAVE)
+    public void queryReserveMealOrdersByDinerIds(final QueryReserveMealOrdersByDinerIdsRpcRequest request,
+                                                 final StreamObserver<QueryReserveMealOrdersByDinerIdsRpcResponse> responseObserver) {
+        final var builder = QueryReserveMealOrdersByDinerIdsRpcResponse.newBuilder();
+        try {
+            LambdaQueryWrapper<MealOrder> queryWrapper = new LambdaQueryWrapper<>();
+            queryWrapper.eq(MealOrder::getEnterpriseId, request.getEnterpriseId());
+            queryWrapper.in(!request.getDinerIdsList().isEmpty(), MealOrder::getDinerId, request.getDinerIdsList());
+            LocalDate today = LocalDate.now();
+            LocalDate thisMonday = today.with(TemporalAdjusters.previousOrSame(DayOfWeek.MONDAY));
+            LocalDateTime thisMondayStart = LocalDateTime.of(thisMonday, LocalTime.MIN);
+            LocalDate thisSunday = today.with(TemporalAdjusters.nextOrSame(DayOfWeek.SUNDAY));
+            LocalDateTime thisSundayEnd = LocalDateTime.of(thisSunday, LocalTime.MAX);
+            queryWrapper.ge(MealOrder::getReserveDate, thisMondayStart);
+            queryWrapper.lt(MealOrder::getReserveDate, thisSundayEnd);
+            final var mealOrders = mealOrderService.list(queryWrapper);
+            if (!mealOrders.isEmpty()) {
+                for (final var mealOrder : mealOrders) {
+                    final var mealOrderRpcResponse = ProtoBeanUtil.beanToProto(mealOrder, SingleMealOrderRpcResponse.class, "meals");
+                    final var build = mealOrderRpcResponse.toBuilder().addAllMeals(ProtoBeanUtil.jsonToProtoList(mealOrder.getMeals(), MenuSchedule.class)).build();
+                    builder.addResponses(build);
+                }
+            }
+        } catch (final Exception e) {
+            log.error("queryReserveMealOrdersByDinerIds error;", e);
+            responseObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException());
+        }
+        responseObserver.onNext(builder.build());
+        responseObserver.onCompleted();
+    }
+
+    @Override
+    @DS(DATA_SOURCE_MASTER)
+    public void createMealOrder(final CreateMealOrderRpcRequest request,
+                                final StreamObserver<CreateMealOrderRpcResponse> responseObserver) {
+        final var builder = CreateMealOrderRpcResponse.newBuilder();
+        try {
+            MealOrder mealOrder = new MealOrder();
+            mealOrder.setEnterpriseId(request.getEnterpriseId());
+            mealOrder.setCreatedBy(request.getCreatedBy());
+            mealOrder.setCreationSource(request.getCreationSource());
+            mealOrder.setUpdatedBy(request.getCreatedBy());
+            mealOrder.setUpdateSource(request.getCreationSource());
+            mealOrder.setClientId(request.getCreation().getClientId());
+            mealOrder.setMenuId(request.getCreation().getMenuId());
+            mealOrder.setAccountId(request.getCreation().getAccountId());
+            mealOrder.setOrderMethod(request.getCreation().getOrderMethodValue());
+            mealOrder.setDinerId(request.getCreation().getDinerId());
+            mealOrder.setDinerName(request.getCreation().getDinerName());
+            mealOrder.setClientName(request.getCreation().getClientName());
+            mealOrder.setGradeName(request.getCreation().getGradeName());
+            mealOrder.setClassName(request.getCreation().getClassName());
+            mealOrder.setStudentNo(request.getCreation().getStudentNo());
+            mealOrder.setReserveDate(LocalDateTimeUtil.of(request.getCreation().getReserveDate()));
+            mealOrder.setMeals(ProtoBeanUtil.protoListToJson(request.getCreation().getMealsList()));
+            builder.setIsCreated(mealOrderService.save(mealOrder)).setId(mealOrder.getId());
+        } catch (final Exception e) {
+            log.error("createMealOrder error;", e);
+            responseObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException());
+        }
+        responseObserver.onNext(builder.build());
+        responseObserver.onCompleted();
+    }
+
+    @Override
+    @DS(DATA_SOURCE_MASTER)
+    public void batchCreateMealOrders(final BatchCreateMealOrdersRpcRequest request,
+                                      final StreamObserver<BatchCreateMealOrdersRpcResponse> responseObserver) {
+        final var builder = BatchCreateMealOrdersRpcResponse.newBuilder();
+        try {
+            final var mealOrders = new ArrayList<MealOrder>();
+            for (final var creation : request.getCreationsList()) {
+                MealOrder mealOrder = new MealOrder();
+                mealOrder.setEnterpriseId(request.getEnterpriseId());
+                mealOrder.setCreatedBy(request.getCreatedBy());
+                mealOrder.setCreationSource(request.getCreationSource());
+                mealOrder.setUpdatedBy(request.getCreatedBy());
+                mealOrder.setUpdateSource(request.getCreationSource());
+                mealOrder.setClientId(creation.getClientId());
+                mealOrder.setMenuId(creation.getMenuId());
+                mealOrder.setAccountId(creation.getAccountId());
+                mealOrder.setOrderMethod(creation.getOrderMethodValue());
+                mealOrder.setDinerId(creation.getDinerId());
+                mealOrder.setDinerName(creation.getDinerName());
+                mealOrder.setClientName(creation.getClientName());
+                mealOrder.setGradeName(creation.getGradeName());
+                mealOrder.setClassName(creation.getClassName());
+                mealOrder.setStudentNo(creation.getStudentNo());
+                mealOrder.setReserveDate(LocalDateTimeUtil.of(creation.getReserveDate()));
+                mealOrder.setMeals(ProtoBeanUtil.protoListToJson(creation.getMealsList()));
+                mealOrders.add(mealOrder);
+            }
+            builder.setIsCreated(mealOrderService.saveBatch(mealOrders)).addAllIds(mealOrders.stream().map(MealOrder::getId).toList());
+        } catch (final Exception e) {
+            log.error("batchCreateMealOrders error;", e);
+            responseObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException());
+        }
+        responseObserver.onNext(builder.build());
+        responseObserver.onCompleted();
+    }
+
+    @Override
+    @DS(DATA_SOURCE_MASTER)
+    public void deleteMealOrdersByIds(final DeleteMealOrdersByIdsRpcRequest request,
+                                      final StreamObserver<DeleteMealOrdersRpcResponse> responseObserver) {
+        final var builder = DeleteMealOrdersRpcResponse.newBuilder();
+        try {
+            builder.setIsDeleted(mealOrderService.removeBatchByIds(request.getIdsList()));
+        } catch (final Exception e) {
+            log.error("deleteMealOrdersByIds error;", e);
+            responseObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException());
+        }
+        responseObserver.onNext(builder.build());
+        responseObserver.onCompleted();
+    }
+
+    @Override
+    @DS(DATA_SOURCE_SLAVE)
+    public void getMpAccountById(final GetMpAccountByIdRpcRequest request,
+                                 final StreamObserver<GetMpAccountByIdRpcResponse> responseObserver) {
+        final var builder = GetMpAccountByIdRpcResponse.newBuilder();
+        try {
+            final var mealOrder = mpAccountService.getById(request.getId());
+            if (mealOrder != null) {
+                builder.setResponse(ProtoBeanUtil.beanToProto(mealOrder, SingleMpAccountRpcResponse.class));
+            }
+        } catch (final Exception e) {
+            log.error("getMpAccountById error;", e);
+            responseObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException());
+        }
+        responseObserver.onNext(builder.build());
+        responseObserver.onCompleted();
+    }
+
+    @Override
+    @DS(DATA_SOURCE_SLAVE)
+    public void getMpAccountByOpenId(final GetMpAccountByOpenIdRpcRequest request,
+                                     final StreamObserver<GetMpAccountByOpenIdRpcResponse> responseObserver) {
+        final var builder = GetMpAccountByOpenIdRpcResponse.newBuilder();
+        try {
+            LambdaQueryWrapper<MpAccount> queryWrapper = Wrappers.lambdaQuery();
+            queryWrapper.eq(MpAccount::getOpenId, request.getOpenId());
+            final var mpAccount = mpAccountService.getOne(queryWrapper);
+            if (mpAccount != null) {
+                builder.setResponse(ProtoBeanUtil.beanToProto(mpAccount, SingleMpAccountRpcResponse.class));
+            }
+        } catch (final Exception e) {
+            log.error("getMpAccountByOpenId error;", e);
+            responseObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException());
+        }
+        responseObserver.onNext(builder.build());
+        responseObserver.onCompleted();
+    }
+
+    @Override
+    @DS(DATA_SOURCE_SLAVE)
+    public void getMpAccountsByIds(final GetMpAccountsByIdsRpcRequest request,
+                                   final StreamObserver<GetMpAccountsByIdsRpcResponse> responseObserver) {
+        final var builder = GetMpAccountsByIdsRpcResponse.newBuilder();
+        try {
+            final var mealOrders = mpAccountService.listByIds(request.getIdsList());
+            if (!mealOrders.isEmpty()) {
+                builder.addAllResponses(ProtoBeanUtil.beanListToProtoList(mealOrders, SingleMpAccountRpcResponse.class));
+            }
+        } catch (final Exception e) {
+            log.error("getMpAccountsByIds error;", e);
+            responseObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException());
+        }
+        responseObserver.onNext(builder.build());
+        responseObserver.onCompleted();
+    }
+
+    @Override
+    @DS(DATA_SOURCE_SLAVE)
+    public void queryMpAccountsByCondition(final QueryMpAccountsByConditionRpcRequest request,
+                                           final StreamObserver<QueryMpAccountsByConditionRpcResponse> responseObserver) {
+        final var builder = QueryMpAccountsByConditionRpcResponse.newBuilder();
+        try {
+            LambdaQueryWrapper<MpAccount> queryWrapper = new LambdaQueryWrapper<>();
+            queryWrapper.eq(MpAccount::getEnterpriseId, request.getEnterpriseId());
+            if (request.getShouldFilterOpenId()) {
+                queryWrapper.eq(MpAccount::getOpenId, request.getOpenId());
+            }
+            if (request.getShouldFilterUnionId()) {
+                queryWrapper.eq(MpAccount::getUnionId, request.getUnionId());
+            }
+            if (request.getShouldFilterPhoneNumber()) {
+                queryWrapper.eq(MpAccount::getPhoneNumber, request.getPhoneNumber());
+            }
+            if (request.getShouldFilterStatus()) {
+                queryWrapper.eq(MpAccount::getStatus, request.getStatusValue());
+            }
+            final var mealOrders = mpAccountService.list(queryWrapper);
+            if (!mealOrders.isEmpty()) {
+                builder.addAllResponses(ProtoBeanUtil.beanListToProtoList(mealOrders, SingleMpAccountRpcResponse.class));
+            }
+        } catch (final Exception e) {
+            log.error("queryMpAccountsByCondition error;", e);
+            responseObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException());
+        }
+        responseObserver.onNext(builder.build());
+        responseObserver.onCompleted();
+    }
+
+    @Override
+    @DS(DATA_SOURCE_MASTER)
+    public void createMpAccount(final CreateMpAccountRpcRequest request,
+                                final StreamObserver<CreateMpAccountRpcResponse> responseObserver) {
+        final var builder = CreateMpAccountRpcResponse.newBuilder();
+        try {
+            MpAccount mpAccount = new MpAccount();
+            mpAccount.setEnterpriseId(request.getEnterpriseId());
+            mpAccount.setCreatedBy(request.getCreatedBy());
+            mpAccount.setCreationSource(request.getCreationSource());
+            mpAccount.setUpdatedBy(request.getCreatedBy());
+            mpAccount.setUpdateSource(request.getCreationSource());
+            mpAccount.setOpenId(request.getCreation().getOpenId());
+            if (request.getCreation().getShouldCreateUnionId()) {
+                mpAccount.setUnionId(request.getCreation().getUnionId());
+            }
+            if (request.getCreation().getShouldCreateNickname()) {
+                mpAccount.setNickname(request.getCreation().getNickname());
+            }
+            if (request.getCreation().getShouldCreateAvatarUrl()) {
+                mpAccount.setAvatarUrl(request.getCreation().getAvatarUrl());
+            }
+            mpAccount.setGender(request.getCreation().getGenderValue());
+            mpAccount.setPhoneNumber(request.getCreation().getPhoneNumber());
+            mpAccount.setStatus(request.getCreation().getStatusValue());
+            builder.setIsCreated(mpAccountService.save(mpAccount)).setId(mpAccount.getId());
+        } catch (final Exception e) {
+            log.error("createMpAccount error;", e);
+            responseObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException());
+        }
+        responseObserver.onNext(builder.build());
+        responseObserver.onCompleted();
+    }
+
+    @Override
+    @DS(DATA_SOURCE_MASTER)
+    public void updateMpAccount(final UpdateMpAccountRpcRequest request,
+                                final StreamObserver<UpdateMpAccountRpcResponse> responseObserver) {
+        final var builder = UpdateMpAccountRpcResponse.newBuilder();
+        try {
+            MpAccount mpAccount = new MpAccount();
+            mpAccount.setId(request.getModification().getId());
+            mpAccount.setEnterpriseId(request.getEnterpriseId());
+            mpAccount.setUpdatedBy(request.getUpdatedBy());
+            mpAccount.setUpdateSource(request.getUpdateSource());
+            if (request.getModification().getShouldUpdateNickname()) {
+                mpAccount.setNickname(request.getModification().getNickname());
+            }
+            if (request.getModification().getShouldUpdateAvatarUrl()) {
+                mpAccount.setAvatarUrl(request.getModification().getAvatarUrl());
+            }
+            if (request.getModification().getShouldUpdateGender()) {
+                mpAccount.setGender(request.getModification().getGenderValue());
+            }
+            if (request.getModification().getShouldUpdatePhoneNumber()) {
+                mpAccount.setPhoneNumber(request.getModification().getPhoneNumber());
+            }
+            if (request.getModification().getShouldUpdateStatus()) {
+                mpAccount.setStatus(request.getModification().getStatusValue());
+            }
+            builder.setIsUpdated(mpAccountService.updateById(mpAccount));
+        } catch (final Exception e) {
+            log.error("updateMpAccount error;", e);
+            responseObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException());
+        }
+        responseObserver.onNext(builder.build());
+        responseObserver.onCompleted();
+    }
+
+    @Override
+    @DS(DATA_SOURCE_MASTER)
+    public void deleteMpAccountsByIds(final DeleteMpAccountsByIdsRpcRequest request,
+                                      final StreamObserver<DeleteMpAccountsRpcResponse> responseObserver) {
+        final var builder = DeleteMpAccountsRpcResponse.newBuilder();
+        try {
+            builder.setIsDeleted(mpAccountService.removeBatchByIds(request.getIdsList()));
+        } catch (final Exception e) {
+            log.error("deleteMpAccountsByIds error;", e);
+            responseObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException());
+        }
+        responseObserver.onNext(builder.build());
+        responseObserver.onCompleted();
+    }
+
+    @Override
+    @DS(DATA_SOURCE_SLAVE)
+    public void getDinerById(final GetDinerByIdRpcRequest request,
+                             final StreamObserver<GetDinerByIdRpcResponse> responseObserver) {
+        final var builder = GetDinerByIdRpcResponse.newBuilder();
+        try {
+            final var mealOrder = dinerService.getById(request.getId());
+            if (mealOrder != null) {
+                builder.setResponse(ProtoBeanUtil.beanToProto(mealOrder, SingleDinerRpcResponse.class));
+            }
+        } catch (final Exception e) {
+            log.error("getDinerById error;", e);
+            responseObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException());
+        }
+        responseObserver.onNext(builder.build());
+        responseObserver.onCompleted();
+    }
+
+    @Override
+    @DS(DATA_SOURCE_SLAVE)
+    public void getDinersByIds(final GetDinersByIdsRpcRequest request,
+                               final StreamObserver<GetDinersByIdsRpcResponse> responseObserver) {
+        final var builder = GetDinersByIdsRpcResponse.newBuilder();
+        try {
+            final var mealOrders = dinerService.listByIds(request.getIdsList());
+            if (!mealOrders.isEmpty()) {
+                builder.addAllResponses(ProtoBeanUtil.beanListToProtoList(mealOrders, SingleDinerRpcResponse.class));
+            }
+        } catch (final Exception e) {
+            log.error("getDinersByIds error;", e);
+            responseObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException());
+        }
+        responseObserver.onNext(builder.build());
+        responseObserver.onCompleted();
+    }
+
+    @Override
+    @DS(DATA_SOURCE_SLAVE)
+    public void queryDinersByCondition(final QueryDinersByConditionRpcRequest request,
+                                       final StreamObserver<QueryDinersByConditionRpcResponse> responseObserver) {
+        final var builder = QueryDinersByConditionRpcResponse.newBuilder();
+        try {
+            LambdaQueryWrapper<Diner> queryWrapper = new LambdaQueryWrapper<>();
+            queryWrapper.eq(Diner::getEnterpriseId, request.getEnterpriseId());
+            if (request.getShouldFilterClientIds()) {
+                queryWrapper.in(!request.getClientIdsList().isEmpty(), Diner::getClientId, request.getClientIdsList());
+            }
+            if (request.getShouldFilterClassIds()) {
+                queryWrapper.in(!request.getClassIdsList().isEmpty(), Diner::getClassId, request.getClassIdsList());
+            }
+            if (request.getShouldFilterStudentNo()) {
+                queryWrapper.eq(Diner::getStudentNo, request.getStudentNo());
+            }
+            if (request.getShouldFilterName()) {
+                queryWrapper.eq(Diner::getName, request.getName());
+            }
+            final var diners = dinerService.list(queryWrapper);
+            if (!diners.isEmpty()) {
+                builder.addAllResponses(ProtoBeanUtil.beanListToProtoList(diners, SingleDinerRpcResponse.class));
+            }
+        } catch (final Exception e) {
+            log.error("queryDinersByCondition error;", e);
+            responseObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException());
+        }
+        responseObserver.onNext(builder.build());
+        responseObserver.onCompleted();
+    }
+
+    @Override
+    @DS(DATA_SOURCE_MASTER)
+    public void createDiner(final CreateDinerRpcRequest request,
+                            final StreamObserver<CreateDinerRpcResponse> responseObserver) {
+        final var builder = CreateDinerRpcResponse.newBuilder();
+        try {
+            Diner diner = new Diner();
+            diner.setEnterpriseId(request.getEnterpriseId());
+            diner.setCreatedBy(request.getCreatedBy());
+            diner.setCreationSource(request.getCreationSource());
+            diner.setUpdatedBy(request.getCreatedBy());
+            diner.setUpdateSource(request.getCreationSource());
+            diner.setClientId(request.getCreation().getClientId());
+            diner.setClassId(request.getCreation().getClassId());
+            diner.setStudentNo(request.getCreation().getStudentNo());
+            diner.setName(request.getCreation().getName());
+            builder.setIsCreated(dinerService.save(diner)).setId(diner.getId());
+        } catch (final Exception e) {
+            log.error("createDiner error;", e);
+            responseObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException());
+        }
+        responseObserver.onNext(builder.build());
+        responseObserver.onCompleted();
+    }
+
+    @Override
+    @DS(DATA_SOURCE_MASTER)
+    public void updateDiner(final UpdateDinerRpcRequest request,
+                            final StreamObserver<UpdateDinerRpcResponse> responseObserver) {
+        final var builder = UpdateDinerRpcResponse.newBuilder();
+        try {
+            Diner diner = new Diner();
+            diner.setId(request.getModification().getId());
+            diner.setEnterpriseId(request.getEnterpriseId());
+            diner.setUpdatedBy(request.getUpdatedBy());
+            diner.setUpdateSource(request.getUpdateSource());
+            if (request.getModification().getShouldUpdateClientId()) {
+                diner.setClientId(request.getModification().getClientId());
+            }
+            if (request.getModification().getShouldUpdateClassId()) {
+                diner.setClassId(request.getModification().getClassId());
+            }
+            if (request.getModification().getShouldUpdateStudentNo()) {
+                diner.setStudentNo(request.getModification().getStudentNo());
+            }
+            if (request.getModification().getShouldUpdateName()) {
+                diner.setName(request.getModification().getName());
+            }
+            builder.setIsUpdated(dinerService.updateById(diner));
+        } catch (final Exception e) {
+            log.error("updateDiner error;", e);
+            responseObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException());
+        }
+        responseObserver.onNext(builder.build());
+        responseObserver.onCompleted();
+    }
+
+    @Override
+    @DS(DATA_SOURCE_MASTER)
+    public void batchSaveOrUpdateDiners(final BatchSaveOrUpdateDinersRpcRequest request,
+                                        final StreamObserver<BatchSaveOrUpdateDinersRpcResponse> responseObserver) {
+        final var builder = BatchSaveOrUpdateDinersRpcResponse.newBuilder();
+        try {
+            final var diners = new ArrayList<Diner>();
+            for (DinerModification modification : request.getModificationsList()) {
+                Diner diner = new Diner();
+                diner.setId(modification.getId() == 0 ? null : modification.getId());
+                diner.setEnterpriseId(request.getEnterpriseId());
+                if (modification.getId() == 0) {
+                    diner.setCreatedBy(request.getUpdatedBy());
+                    diner.setCreationSource(request.getUpdateSource());
+                }
+                diner.setUpdatedBy(request.getUpdatedBy());
+                diner.setUpdateSource(request.getUpdateSource());
+                if (modification.getShouldUpdateClientId()) {
+                    diner.setClientId(modification.getClientId());
+                }
+                if (modification.getShouldUpdateClassId()) {
+                    diner.setClassId(modification.getClassId());
+                }
+                if (modification.getShouldUpdateStudentNo()) {
+                    diner.setStudentNo(modification.getStudentNo());
+                }
+                if (modification.getShouldUpdateName()) {
+                    diner.setName(modification.getName());
+                }
+                diners.add(diner);
+            }
+            builder.setIsUpdated(dinerService.saveOrUpdateBatch(diners));
+        } catch (final Exception e) {
+            log.error("batchSaveOrUpdateDiners error;", e);
+            responseObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException());
+        }
+        responseObserver.onNext(builder.build());
+        responseObserver.onCompleted();
+    }
+
+    @Override
+    @DS(DATA_SOURCE_MASTER)
+    public void deleteDinersByIds(final DeleteDinersByIdsRpcRequest request,
+                                  final StreamObserver<DeleteDinersRpcResponse> responseObserver) {
+        final var builder = DeleteDinersRpcResponse.newBuilder();
+        try {
+            builder.setIsDeleted(dinerService.removeBatchByIds(request.getIdsList()));
+        } catch (final Exception e) {
+            log.error("deleteDinersByIds error;", e);
+            responseObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException());
+        }
+        responseObserver.onNext(builder.build());
+        responseObserver.onCompleted();
+    }
+
+    @Override
+    @DS(DATA_SOURCE_SLAVE)
+    public void getMpAccountDinerRefsByIds(final GetMpAccountDinerRefsByIdsRpcRequest request,
+                                           final StreamObserver<GetMpAccountDinerRefsByIdsRpcResponse> responseObserver) {
+        final var builder = GetMpAccountDinerRefsByIdsRpcResponse.newBuilder();
+        try {
+            final var mpAccountDinerRefs = mpAccountDinerRefService.listByIds(request.getIdsList());
+            if (!mpAccountDinerRefs.isEmpty()) {
+                builder.addAllResponses(ProtoBeanUtil.beanListToProtoList(mpAccountDinerRefs, SingleMpAccountDinerRefRpcResponse.class));
+            }
+        } catch (final Exception e) {
+            log.error("getMpAccountDinerRefsByIds error;", e);
+            responseObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException());
+        }
+        responseObserver.onNext(builder.build());
+        responseObserver.onCompleted();
+    }
+
+    @Override
+    @DS(DATA_SOURCE_SLAVE)
+    public void queryMpAccountDinerRefsByCondition(final QueryMpAccountDinerRefsByConditionRpcRequest request,
+                                                   final StreamObserver<QueryMpAccountDinerRefsByConditionRpcResponse> responseObserver) {
+        final var builder = QueryMpAccountDinerRefsByConditionRpcResponse.newBuilder();
+        try {
+            LambdaQueryWrapper<MpAccountDinerRef> queryWrapper = new LambdaQueryWrapper<>();
+            queryWrapper.eq(MpAccountDinerRef::getEnterpriseId, request.getEnterpriseId());
+            if (request.getShouldFilterAccountIds()) {
+                queryWrapper.in(!request.getAccountIdsList().isEmpty(), MpAccountDinerRef::getAccountId, request.getAccountIdsList());
+            }
+            if (request.getShouldFilterDinerIds()) {
+                queryWrapper.in(!request.getDinerIdsList().isEmpty(), MpAccountDinerRef::getDinerId, request.getDinerIdsList());
+            }
+            final var diners = mpAccountDinerRefService.list(queryWrapper);
+            if (!diners.isEmpty()) {
+                builder.addAllResponses(ProtoBeanUtil.beanListToProtoList(diners, SingleMpAccountDinerRefRpcResponse.class));
+            }
+        } catch (final Exception e) {
+            log.error("queryMpAccountDinerRefsByCondition error;", e);
+            responseObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException());
+        }
+        responseObserver.onNext(builder.build());
+        responseObserver.onCompleted();
+    }
+
+    @Override
+    @DS(DATA_SOURCE_MASTER)
+    public void createMpAccountDinerRef(final CreateMpAccountDinerRefRpcRequest request,
+                                        final StreamObserver<CreateMpAccountDinerRefRpcResponse> responseObserver) {
+        final var builder = CreateMpAccountDinerRefRpcResponse.newBuilder();
+        try {
+            MpAccountDinerRef mpAccountDinerRef = new MpAccountDinerRef();
+            mpAccountDinerRef.setEnterpriseId(request.getEnterpriseId());
+            mpAccountDinerRef.setCreatedBy(request.getCreatedBy());
+            mpAccountDinerRef.setCreationSource(request.getCreationSource());
+            mpAccountDinerRef.setAccountId(request.getCreation().getAccountId());
+            mpAccountDinerRef.setDinerId(request.getCreation().getDinerId());
+            builder.setIsCreated(mpAccountDinerRefService.save(mpAccountDinerRef)).setId(mpAccountDinerRef.getId());
+        } catch (final Exception e) {
+            log.error("createMpAccountDinerRef error;", e);
+            responseObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException());
+        }
+        responseObserver.onNext(builder.build());
+        responseObserver.onCompleted();
+    }
+
+    @Override
+    @DS(DATA_SOURCE_MASTER)
+    public void deleteMpAccountDinerRefsByIds(final DeleteMpAccountDinerRefsByIdsRpcRequest request,
+                                              final StreamObserver<DeleteMpAccountDinerRefsRpcResponse> responseObserver) {
+        final var builder = DeleteMpAccountDinerRefsRpcResponse.newBuilder();
+        try {
+            builder.setIsDeleted(mpAccountDinerRefService.removeBatchByIds(request.getIdsList()));
+        } catch (final Exception e) {
+            log.error("deleteMpAccountDinerRefsByIds error;", e);
+            responseObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException());
+        }
+        responseObserver.onNext(builder.build());
+        responseObserver.onCompleted();
+    }
+
+    @Override
+    @DS(DATA_SOURCE_SLAVE)
+    public void getGradeClassById(final GetGradeClassByIdRpcRequest request,
+                                  final StreamObserver<GetGradeClassByIdRpcResponse> responseObserver) {
+        final var builder = GetGradeClassByIdRpcResponse.newBuilder();
+        try {
+            final var gradeClass = gradeClassService.getById(request.getId());
+            if (gradeClass != null) {
+                builder.setResponse(ProtoBeanUtil.beanToProto(gradeClass, SingleGradeClassRpcResponse.class));
+            }
+        } catch (final Exception e) {
+            log.error("getGradeClassById error;", e);
+            responseObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException());
+        }
+        responseObserver.onNext(builder.build());
+        responseObserver.onCompleted();
+    }
+
+    @Override
+    @DS(DATA_SOURCE_SLAVE)
+    public void getGradeClassesByIds(final GetGradeClassesByIdsRpcRequest request,
+                                     final StreamObserver<GetGradeClassesByIdsRpcResponse> responseObserver) {
+        final var builder = GetGradeClassesByIdsRpcResponse.newBuilder();
+        try {
+            final var gradeClasses = gradeClassService.listByIds(request.getIdsList());
+            if (!gradeClasses.isEmpty()) {
+                builder.addAllResponses(ProtoBeanUtil.beanListToProtoList(gradeClasses, SingleGradeClassRpcResponse.class));
+            }
+        } catch (final Exception e) {
+            log.error("getGradeClassesByIds error;", e);
+            responseObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException());
+        }
+        responseObserver.onNext(builder.build());
+        responseObserver.onCompleted();
+    }
+
+    @Override
+    @DS(DATA_SOURCE_SLAVE)
+    public void queryGradeClassesByCondition(final QueryGradeClassesByConditionRpcRequest request,
+                                             final StreamObserver<QueryGradeClassesByConditionRpcResponse> responseObserver) {
+        final var builder = QueryGradeClassesByConditionRpcResponse.newBuilder();
+        try {
+            LambdaQueryWrapper<GradeClass> queryWrapper = new LambdaQueryWrapper<>();
+            queryWrapper.eq(GradeClass::getEnterpriseId, request.getEnterpriseId());
+            if (request.getShouldFilterClientIds()) {
+                queryWrapper.in(!request.getClientIdsList().isEmpty(), GradeClass::getClientId, request.getClientIdsList());
+            }
+            if (request.getShouldFilterGradeNames()) {
+                queryWrapper.in(GradeClass::getGradeName, request.getGradeNameList());
+            }
+            final var gradeClasses = gradeClassService.list(queryWrapper);
+            if (!gradeClasses.isEmpty()) {
+                builder.addAllResponses(ProtoBeanUtil.beanListToProtoList(gradeClasses, SingleGradeClassRpcResponse.class));
+            }
+        } catch (final Exception e) {
+            log.error("queryGradeClassesByCondition error;", e);
+            responseObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException());
+        }
+        responseObserver.onNext(builder.build());
+        responseObserver.onCompleted();
+    }
+
+    @Override
+    @DS(DATA_SOURCE_MASTER)
+    public void createGradeClass(final CreateGradeClassRpcRequest request,
+                                 final StreamObserver<CreateGradeClassRpcResponse> responseObserver) {
+        final var builder = CreateGradeClassRpcResponse.newBuilder();
+        try {
+            GradeClass gradeClass = new GradeClass();
+            gradeClass.setEnterpriseId(request.getEnterpriseId());
+            gradeClass.setCreatedBy(request.getCreatedBy());
+            gradeClass.setCreationSource(request.getCreationSource());
+            gradeClass.setUpdatedBy(request.getCreatedBy());
+            gradeClass.setUpdateSource(request.getCreationSource());
+            gradeClass.setClientId(request.getCreation().getClientId());
+            gradeClass.setGradeName(request.getCreation().getGradeName());
+            gradeClass.setClassName(request.getCreation().getClassName());
+            builder.setIsCreated(gradeClassService.save(gradeClass)).setId(gradeClass.getId());
+        } catch (final Exception e) {
+            log.error("createGradeClass error;", e);
+            responseObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException());
+        }
+        responseObserver.onNext(builder.build());
+        responseObserver.onCompleted();
+    }
+
+    @Override
+    @DS(DATA_SOURCE_MASTER)
+    public void batchCreateGradeClasses(final BatchCreateGradeClassesRpcRequest request,
+                                        final StreamObserver<BatchCreateGradeClassesRpcResponse> responseObserver) {
+        final var builder = BatchCreateGradeClassesRpcResponse.newBuilder();
+        try {
+            final var gradeClasses = new ArrayList<GradeClass>();
+            for (final var creation : request.getCreationsList()) {
+                final var gradeClass = new GradeClass();
+                gradeClass.setEnterpriseId(request.getEnterpriseId());
+                gradeClass.setCreatedBy(request.getCreatedBy());
+                gradeClass.setCreationSource(request.getCreationSource());
+                gradeClass.setUpdatedBy(request.getCreatedBy());
+                gradeClass.setUpdateSource(request.getCreationSource());
+                gradeClass.setClientId(creation.getClientId());
+                gradeClass.setGradeName(creation.getGradeName());
+                gradeClass.setClassName(creation.getClassName());
+                gradeClasses.add(gradeClass);
+            }
+            builder.setIsCreated(gradeClassService.saveBatch(gradeClasses)).addAllIds(gradeClasses.stream().map(GradeClass::getId).collect(Collectors.toList()));
+        } catch (final Exception e) {
+            log.error("batchCreateGradeClasses error;", e);
+            responseObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException());
+        }
+        responseObserver.onNext(builder.build());
+        responseObserver.onCompleted();
+    }
+
+    @Override
+    @DS(DATA_SOURCE_MASTER)
+    public void updateGradeClass(final UpdateGradeClassRpcRequest request,
+                                 final StreamObserver<UpdateGradeClassRpcResponse> responseObserver) {
+        final var builder = UpdateGradeClassRpcResponse.newBuilder();
+        try {
+            GradeClass gradeClass = new GradeClass();
+            gradeClass.setId(request.getModification().getId());
+            gradeClass.setEnterpriseId(request.getEnterpriseId());
+            gradeClass.setUpdatedBy(request.getUpdatedBy());
+            gradeClass.setUpdateSource(request.getUpdateSource());
+            if (request.getModification().getShouldUpdateClientId()) {
+                gradeClass.setClientId(request.getModification().getClientId());
+            }
+            if (request.getModification().getShouldUpdateClassName()) {
+                gradeClass.setClassName(request.getModification().getClassName());
+            }
+            if (request.getModification().getShouldUpdateGradeName()) {
+                gradeClass.setGradeName(request.getModification().getGradeName());
+            }
+            builder.setIsUpdated(gradeClassService.updateById(gradeClass));
+        } catch (final Exception e) {
+            log.error("updateGradeClass error;", e);
+            responseObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException());
+        }
+        responseObserver.onNext(builder.build());
+        responseObserver.onCompleted();
+    }
+
+    @Override
+    @DS(DATA_SOURCE_MASTER)
+    public void batchSaveOrUpdateGradeClasses(final BatchSaveOrUpdateGradeClassesRpcRequest request,
+                                              final StreamObserver<BatchSaveOrUpdateGradeClassesRpcResponse> responseObserver) {
+        final var builder = BatchSaveOrUpdateGradeClassesRpcResponse.newBuilder();
+        try {
+            List<GradeClass> gradeClasses = new ArrayList<>();
+            for (final var modification : request.getModificationsList()) {
+                GradeClass gradeClass = new GradeClass();
+                gradeClass.setId(modification.getId() == 0 ? null : modification.getId());
+                gradeClass.setEnterpriseId(request.getEnterpriseId());
+                if (modification.getId() == 0) {
+                    gradeClass.setCreatedBy(request.getUpdatedBy());
+                    gradeClass.setCreationSource(request.getUpdateSource());
+                }
+                gradeClass.setUpdatedBy(request.getUpdatedBy());
+                gradeClass.setUpdateSource(request.getUpdateSource());
+                if (modification.getShouldUpdateClientId()) {
+                    gradeClass.setClientId(modification.getClientId());
+                }
+                if (modification.getShouldUpdateClassName()) {
+                    gradeClass.setClassName(modification.getClassName());
+                }
+                if (modification.getShouldUpdateGradeName()) {
+                    gradeClass.setGradeName(modification.getGradeName());
+                }
+                gradeClasses.add(gradeClass);
+            }
+            builder.setIsUpdated(gradeClassService.saveOrUpdateBatch(gradeClasses));
+        } catch (final Exception e) {
+            log.error("updateGradeClass error;", e);
+            responseObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException());
+        }
+        responseObserver.onNext(builder.build());
+        responseObserver.onCompleted();
+    }
+
+    @Override
+    @DS(DATA_SOURCE_MASTER)
+    public void deleteGradeClassesByIds(final DeleteGradeClassesByIdsRpcRequest request,
+                                        final StreamObserver<DeleteGradeClassesRpcResponse> responseObserver) {
+        final var builder = DeleteGradeClassesRpcResponse.newBuilder();
+        try {
+            builder.setIsDeleted(gradeClassService.removeBatchByIds(request.getIdsList()));
+        } catch (final Exception e) {
+            log.error("deleteGradeClassesByIds error;", e);
+            responseObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException());
+        }
+        responseObserver.onNext(builder.build());
+        responseObserver.onCompleted();
+    }
+
+    @Override
+    @DS(DATA_SOURCE_MASTER)
+    @Transactional(rollbackFor = Exception.class)
+    public void deleteGradeClassesAndDinersByClientIds(final DeleteGradeClassesAndDinersByClientIdsRpcRequest request,
+                                                       final StreamObserver<DeleteGradeClassesAndDinersByClientIdsRpcResponse> responseObserver) {
+        final var builder = DeleteGradeClassesAndDinersByClientIdsRpcResponse.newBuilder();
+        try {
+            final var enterpriseId = request.getEnterpriseId();
+            final var clientIds = request.getClientIdsList();
+            if (clientIds.isEmpty()) {
+                builder.setIsDeleted(false);
+                responseObserver.onNext(builder.build());
+                responseObserver.onCompleted();
+                return;
+             }
+            final var gradeClassDeleted = gradeClassService.remove(Wrappers.<GradeClass>lambdaQuery().eq(GradeClass::getEnterpriseId, enterpriseId).in(!clientIds.isEmpty(), GradeClass::getClientId, clientIds));
+            final var diners = dinerService.list(Wrappers.<Diner>lambdaQuery().eq(Diner::getEnterpriseId, enterpriseId).in(!clientIds.isEmpty(), Diner::getClientId, clientIds));
+            final var dinerDeleted = dinerService.remove(Wrappers.<Diner>lambdaQuery().eq(Diner::getEnterpriseId, enterpriseId).in(!clientIds.isEmpty(), Diner::getClientId, clientIds));
+            boolean mpAccountDinerRefDeleted = true;
+            if (!diners.isEmpty()) {
+                final var dinerIds = diners.stream().map(Diner::getId).collect(Collectors.toList());
+                mpAccountDinerRefDeleted = mpAccountDinerRefService.remove(Wrappers.<MpAccountDinerRef>lambdaQuery().eq(MpAccountDinerRef::getEnterpriseId, enterpriseId).in(!dinerIds.isEmpty(), MpAccountDinerRef::getDinerId, dinerIds));
+            }
+            builder.setIsDeleted(gradeClassDeleted && dinerDeleted && mpAccountDinerRefDeleted);
+        } catch (final Exception e) {
+            log.error("deleteGradeClassesAndDinersByClientIds error;", e);
+            responseObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException());
+        }
+        responseObserver.onNext(builder.build());
+        responseObserver.onCompleted();
+    }
+
+    @Override
+    @DS(DATA_SOURCE_MASTER)
+    @Transactional(rollbackFor = Exception.class)
+    public void deleteGradeClassesAndDinersByClassIds(final DeleteGradeClassesAndDinersByClassIdsRpcRequest request,
+                                                      final StreamObserver<DeleteGradeClassesAndDinersByClassIdsRpcResponse> responseObserver) {
+        final var builder = DeleteGradeClassesAndDinersByClassIdsRpcResponse.newBuilder();
+        try {
+            final var enterpriseId = request.getEnterpriseId();
+            final var classIds = request.getClassIdsList();
+            if (classIds.isEmpty()) {
+                builder.setIsDeleted(false);
+                responseObserver.onNext(builder.build());
+                responseObserver.onCompleted();
+                return;
+            }
+            final var gradeClassRemoved = gradeClassService.remove(Wrappers.<GradeClass>lambdaQuery().eq(GradeClass::getEnterpriseId, enterpriseId).in(GradeClass::getId, classIds));
+            final var diners = dinerService.list(Wrappers.<Diner>lambdaQuery().eq(Diner::getEnterpriseId, enterpriseId).in(!classIds.isEmpty(), Diner::getClassId, classIds));
+            boolean dinerRemoved = dinerService.remove(Wrappers.<Diner>lambdaQuery().eq(Diner::getEnterpriseId, enterpriseId).in(!classIds.isEmpty(), Diner::getClassId, classIds));
+            boolean refRemoved = diners.isEmpty() || mpAccountDinerRefService.remove(Wrappers.<MpAccountDinerRef>lambdaQuery().eq(MpAccountDinerRef::getEnterpriseId, enterpriseId).in(MpAccountDinerRef::getDinerId, diners.stream().map(Diner::getId).collect(Collectors.toList())));
+            builder.setIsDeleted(gradeClassRemoved && dinerRemoved && refRemoved);
+        } catch (final Exception e) {
+            log.error("deleteGradeClassesAndDinersByClassIds error;", e);
+            responseObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException());
+        }
+        responseObserver.onNext(builder.build());
+        responseObserver.onCompleted();
+    }
+
+    @Override
+    @DS(DATA_SOURCE_SLAVE)
+    public void getMealMenuRecordById(final GetMealMenuRecordByIdRpcRequest request,
+                                      final StreamObserver<GetMealMenuRecordByIdRpcResponse> responseObserver) {
+        final var builder = GetMealMenuRecordByIdRpcResponse.newBuilder();
+        try {
+            final var mealMenuRecord = mealMenuRecordService.getById(request.getId());
+            if (mealMenuRecord != null) {
+                builder.setResponse(ProtoBeanUtil.beanToProto(mealMenuRecord, SingleMealMenuRecordRpcResponse.class));
+            }
+        } catch (final Exception e) {
+            log.error("getMealMenuRecordById error;", e);
+            responseObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException());
+        }
+        responseObserver.onNext(builder.build());
+        responseObserver.onCompleted();
+    }
+
+    @Override
+    @DS(DATA_SOURCE_SLAVE)
+    public void getMealMenuRecordsByIds(final GetMealMenuRecordsByIdsRpcRequest request,
+                                        final StreamObserver<GetMealMenuRecordsByIdsRpcResponse> responseObserver) {
+        final var builder = GetMealMenuRecordsByIdsRpcResponse.newBuilder();
+        try {
+            final var mealMenuRecords = mealMenuRecordService.listByIds(request.getIdsList());
+            if (!mealMenuRecords.isEmpty()) {
+                builder.addAllResponses(ProtoBeanUtil.beanListToProtoList(mealMenuRecords, SingleMealMenuRecordRpcResponse.class));
+            }
+        } catch (final Exception e) {
+            log.error("getMealMenuRecordsByIds error;", e);
+            responseObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException());
+        }
+        responseObserver.onNext(builder.build());
+        responseObserver.onCompleted();
+    }
+
+    @Override
+    @DS(DATA_SOURCE_SLAVE)
+    public void queryMealMenuRecordsByCondition(final QueryMealMenuRecordsByConditionRpcRequest request,
+                                                final StreamObserver<QueryMealMenuRecordsByConditionRpcResponse> responseObserver) {
+        final var builder = QueryMealMenuRecordsByConditionRpcResponse.newBuilder();
+        try {
+            LambdaQueryWrapper<MealMenuRecord> queryWrapper = new LambdaQueryWrapper<>();
+            queryWrapper.eq(MealMenuRecord::getEnterpriseId, request.getEnterpriseId());
+            if (request.getShouldFilterClientIds()) {
+                queryWrapper.in(!request.getClientIdsList().isEmpty(), MealMenuRecord::getClientId, request.getClientIdsList());
+            }
+            if (request.getShouldFilterName()) {
+                queryWrapper.eq(MealMenuRecord::getName, request.getName());
+            }
+            final var diners = mealMenuRecordService.list(queryWrapper);
+            if (!diners.isEmpty()) {
+                builder.addAllResponses(ProtoBeanUtil.beanListToProtoList(diners, SingleMealMenuRecordRpcResponse.class));
+            }
+        } catch (final Exception e) {
+            log.error("queryMealMenuRecordsByCondition error;", e);
+            responseObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException());
+        }
+        responseObserver.onNext(builder.build());
+        responseObserver.onCompleted();
+    }
+
+    @Override
+    @DS(DATA_SOURCE_SLAVE)
+    public void queryLatestMealMenuRecordsByClientIds(final QueryLatestMealMenuRecordsByClientIdsRpcRequest request,
+                                                      final StreamObserver<QueryLatestMealMenuRecordsByClientIdsRpcResponse> responseObserver) {
+        final var builder = QueryLatestMealMenuRecordsByClientIdsRpcResponse.newBuilder();
+        try {
+            final var queryWrapper = new LambdaQueryWrapper<MealMenuRecord>();
+            queryWrapper.eq(MealMenuRecord::getEnterpriseId, request.getEnterpriseId());
+            queryWrapper.in(MealMenuRecord::getClientId, request.getClientIdList());
+            queryWrapper.orderByDesc(MealMenuRecord::getCreatedAt);
+            final var allRecords = mealMenuRecordService.list(queryWrapper);
+            final var latestRecordsMap = allRecords.stream().collect(Collectors.toMap(MealMenuRecord::getClientId, Function.identity(), (existing, replacement) -> existing));
+            if (!latestRecordsMap.isEmpty()) {
+                builder.addAllResponses(ProtoBeanUtil.beanListToProtoList(new ArrayList<>(latestRecordsMap.values()), SingleMealMenuRecordRpcResponse.class));
+            }
+        } catch (final Exception e) {
+            log.error("queryLatestMealMenuRecordsByClientIds error;", e);
+            responseObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException());
+        }
+        responseObserver.onNext(builder.build());
+        responseObserver.onCompleted();
+    }
+
+    @Override
+    @DS(DATA_SOURCE_MASTER)
+    public void createMealMenuRecord(final CreateMealMenuRecordRpcRequest request,
+                                     final StreamObserver<CreateMealMenuRecordRpcResponse> responseObserver) {
+        final var builder = CreateMealMenuRecordRpcResponse.newBuilder();
+        try {
+            MealMenuRecord mealMenuRecord = new MealMenuRecord();
+            mealMenuRecord.setEnterpriseId(request.getEnterpriseId());
+            mealMenuRecord.setCreatedBy(request.getCreatedBy());
+            mealMenuRecord.setCreationSource(request.getCreationSource());
+            mealMenuRecord.setUpdatedBy(request.getCreatedBy());
+            mealMenuRecord.setUpdateSource(request.getCreationSource());
+            mealMenuRecord.setClientId(request.getCreation().getClientId());
+            mealMenuRecord.setName(request.getCreation().getName());
+            mealMenuRecord.setImageUrl(request.getCreation().getImageUrl());
+            builder.setIsCreated(mealMenuRecordService.save(mealMenuRecord)).setId(mealMenuRecord.getId());
+        } catch (final Exception e) {
+            log.error("createMealMenuRecord error;", e);
+            responseObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException());
+        }
+        responseObserver.onNext(builder.build());
+        responseObserver.onCompleted();
+    }
+}

+package com.tianting.infoloop.service.impl;
+
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.tianting.infoloop.mapper.DinerMapper;
+import com.tianting.infoloop.model.db.Diner;
+import com.tianting.infoloop.service.DinerService;
+import org.springframework.stereotype.Service;
+
+/**
+* @author zhuyf
+* @description 针对表【diners(就餐人表)】的数据库操作Service实现
+* @createDate 2025-04-10 13:22:20
+*/
+@Service
+public class DinerServiceImpl extends ServiceImpl<DinerMapper, Diner>
+    implements DinerService{
+
+}
+
+
+
+

+package com.tianting.infoloop.service.impl;
+
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.tianting.infoloop.mapper.GradeClassMapper;
+import com.tianting.infoloop.model.db.GradeClass;
+import com.tianting.infoloop.service.GradeClassService;
+import org.springframework.stereotype.Service;
+
+/**
+* @author zhuyf
+* @description 针对表【grade_classes(年级班级表)】的数据库操作Service实现
+* @createDate 2025-04-10 13:22:20
+*/
+@Service
+public class GradeClassServiceImpl extends ServiceImpl<GradeClassMapper, GradeClass>
+    implements GradeClassService{
+
+}
+
+
+
+

+package com.tianting.infoloop.service.impl;
+
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.tianting.infoloop.mapper.MealMenuRecordMapper;
+import com.tianting.infoloop.model.db.MealMenuRecord;
+import com.tianting.infoloop.service.MealMenuRecordService;
+import org.springframework.stereotype.Service;
+
+/**
+* @author zhuyf
+* @description 针对表【meal_menu_records(餐单记录表)】的数据库操作Service实现
+* @createDate 2025-04-10 13:22:20
+*/
+@Service
+public class MealMenuRecordServiceImpl extends ServiceImpl<MealMenuRecordMapper, MealMenuRecord>
+    implements MealMenuRecordService{
+
+}
+
+
+
+

+package com.tianting.infoloop.service.impl;
+
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.tianting.infoloop.mapper.MealOrderMapper;
+import com.tianting.infoloop.model.db.MealOrder;
+import com.tianting.infoloop.service.MealOrderService;
+import org.springframework.stereotype.Service;
+
+/**
+* @author zhuyf
+* @description 针对表【meal_orders(订餐记录表)】的数据库操作Service实现
+* @createDate 2025-04-10 13:22:20
+*/
+@Service
+public class MealOrderServiceImpl extends ServiceImpl<MealOrderMapper, MealOrder>
+    implements MealOrderService{
+
+}
+
+
+
+

+package com.tianting.infoloop.service.impl;
+
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.tianting.infoloop.mapper.MpAccountDinerRefMapper;
+import com.tianting.infoloop.model.db.MpAccountDinerRef;
+import com.tianting.infoloop.service.MpAccountDinerRefService;
+import org.springframework.stereotype.Service;
+
+/**
+* @author zhuyf
+* @description 针对表【mp_account_diner_refs(小程序账号和就餐人关联表)】的数据库操作Service实现
+* @createDate 2025-04-10 13:22:20
+*/
+@Service
+public class MpAccountDinerRefServiceImpl extends ServiceImpl<MpAccountDinerRefMapper, MpAccountDinerRef>
+    implements MpAccountDinerRefService{
+
+}
+
+
+
+

+package com.tianting.infoloop.service.impl;
+
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.tianting.infoloop.mapper.MpAccountMapper;
+import com.tianting.infoloop.model.db.MpAccount;
+import com.tianting.infoloop.service.MpAccountService;
+import org.springframework.stereotype.Service;
+
+/**
+* @author zhuyf
+* @description 针对表【mp_accounts(小程序账号表)】的数据库操作Service实现
+* @createDate 2025-04-10 13:22:20
+*/
+@Service
+public class MpAccountServiceImpl extends ServiceImpl<MpAccountMapper, MpAccount>
+    implements MpAccountService{
+
+}
+
+
+
+

+package com.tianting.infoloop.utils;
+
+import com.fasterxml.jackson.annotation.JsonInclude;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.DeserializationFeature;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.module.SimpleModule;
+import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
+
+import java.io.IOException;
+import java.util.List;
+
+public final class JSONUtil {
+    private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper();
+
+    static {
+        final SimpleModule module  = new SimpleModule();
+        module.addSerializer(Long.class, ToStringSerializer.instance);
+        module.addSerializer(long.class, ToStringSerializer.instance);
+        OBJECT_MAPPER.registerModule(module);
+        // 如果json中有新增的字段并且是实体类类中不存在的，不报错
+        OBJECT_MAPPER.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
+        // 序列化时忽略值为null的属性
+        OBJECT_MAPPER.setSerializationInclusion(JsonInclude.Include.NON_NULL);
+    }
+
+    public static String writeAsJson(final Object object) {
+        try {
+            return OBJECT_MAPPER.writeValueAsString(object);
+        } catch (final JsonProcessingException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public static <T> T readJsonAs(final String json, final Class<T> clazz) {
+        try {
+            return OBJECT_MAPPER.readerFor(clazz).readValue(json);
+        } catch (final IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public static <T> List<T> readJsonAsList(String jsonString, Class<T> clazz) {
+        try {
+            return OBJECT_MAPPER.readValue(jsonString, new TypeReference<>() {
+            });
+        } catch (Exception e) {
+            throw new RuntimeException("Failed to convert JSON to List<" + clazz.getSimpleName() + ">", e);
+        }
+    }
+
+    public static <T> JsonNode readTree(final String json) {
+        try {
+            return OBJECT_MAPPER.readTree(json);
+        } catch (final IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+    private JSONUtil() {}
+}

 package com.tianting.infoloop.utils;
 
 import cn.hutool.core.date.LocalDateTimeUtil;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.ObjectNode;
 import com.google.gson.Gson;
 import com.google.gson.GsonBuilder;
+import com.google.gson.JsonArray;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonParser;
 import com.google.gson.TypeAdapter;
 import com.google.gson.stream.JsonReader;
 import com.google.gson.stream.JsonWriter;
@@ -23,6 +29,8 @@ import java.util.List;
 
 public class ProtoBeanUtil {
 
+    private static Gson gson = getGson();
+
     /**
      * protoBean -> string
      *
@@ -31,13 +39,68 @@ public class ProtoBeanUtil {
      */
     public static String protoToJson(MessageOrBuilder sourceMessage) {
         try {
-            return JsonFormat.printer().print(sourceMessage);
+            return JsonFormat.printer().includingDefaultValueFields().print(sourceMessage);
         } catch (Exception e) {
             throw new IllegalArgumentException("ProtoBeanUtil->toJson->errorMessage:proto序列化string异常", e);
         }
     }
 
-    private static Gson gson = getGson();
+    @SuppressWarnings("unchecked")
+    public static <T extends Message> T jsonToProto(String json, Class<T> protoBean) {
+        try {
+            Constructor<T> declaredConstructor = protoBean.getDeclaredConstructor((Class<?>[]) null);
+            declaredConstructor.setAccessible(Boolean.TRUE);
+            T instance = declaredConstructor.newInstance();
+            final var builder = instance.toBuilder();
+            if (json == null || json.isEmpty() || json.trim().equals("{}")) {
+                return (T) builder.build();
+            }
+            JsonFormat.parser().ignoringUnknownFields().merge(json, builder);
+            return (T) builder.build();
+        } catch (Exception e) {
+            throw new IllegalArgumentException("json to proto error", e);
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    public static <T extends Message> List<T> jsonToProtoList(String jsonArray, Class<T> protoBean) {
+        try {
+            if (jsonArray == null || jsonArray.isEmpty() || jsonArray.trim().equals("[]")) {
+                return new ArrayList<>();
+            }
+            Constructor<T> declaredConstructor = protoBean.getDeclaredConstructor();
+            declaredConstructor.setAccessible(true);
+            List<T> protoList = new ArrayList<>();
+            JsonArray jsonElements = JsonParser.parseString(jsonArray).getAsJsonArray();
+            for (JsonElement jsonElement : jsonElements) {
+                T instance = declaredConstructor.newInstance();
+                Message.Builder builder = instance.toBuilder();
+                JsonFormat.parser().ignoringUnknownFields().merge(jsonElement.toString(), builder);
+                protoList.add((T) builder.build());
+            }
+            return protoList;
+        } catch (Exception e) {
+            throw new IllegalArgumentException("jsonArray to protoList error", e);
+        }
+    }
+
+    public static String protoListToJson(List<? extends Message> sourceList) {
+        try {
+            StringBuilder jsonArrayBuilder = new StringBuilder();
+            jsonArrayBuilder.append("[");
+            for (int i = 0; i < sourceList.size(); i++) {
+                String json = protoToJson(sourceList.get(i));
+                jsonArrayBuilder.append(json);
+                if (i < sourceList.size() - 1) {
+                    jsonArrayBuilder.append(",");
+                }
+            }
+            jsonArrayBuilder.append("]");
+            return jsonArrayBuilder.toString();
+        } catch (Exception e) {
+            throw new IllegalArgumentException("ProtoList to jsonArray error", e);
+        }
+    }
 
     /**
      * @desc: String 转 Builder对象
@@ -53,7 +116,7 @@ public class ProtoBeanUtil {
     /**
      * @desc: JavaBean 转 Builder对象
      */
-    private static <M extends Message.Builder, T> M beanToBuilder(T beanSource, Class<M> targetBuilderClass) {
+    private static <M extends Message.Builder, T> M beanToBuilder(T beanSource, Class<M> targetBuilderClass, String... ignoreFields) {
         try {
             Constructor<M> declaredConstructor = targetBuilderClass.getDeclaredConstructor((Class<?>[]) null);
 
@@ -65,8 +128,15 @@ public class ProtoBeanUtil {
 
             String json = gson.toJson(beanSource);
 
-            jsonToBuilder(instance, json);
-
+            ObjectMapper mapper = new ObjectMapper();
+            JsonNode root = mapper.readTree(json);
+            if (root instanceof ObjectNode objNode) {
+                for (String field : ignoreFields) {
+                    objNode.remove(field);
+                }
+            }
+            String filteredJson = mapper.writeValueAsString(root);
+            jsonToBuilder(instance, filteredJson);
             return instance;
         } catch (Exception e) {
             throw new IllegalArgumentException("ProtoBeanUtil->beanToBuilder->errorMessage:JavaBean 转 Builder对象异常", e);
@@ -78,7 +148,7 @@ public class ProtoBeanUtil {
      */
     @SneakyThrows
     @SuppressWarnings("unchecked")
-    public static <M extends Message, T> M beanToProto(T bean, Class<M> targetProtoClass) {
+    public static <M extends Message, T> M beanToProto(T bean, Class<M> targetProtoClass, String... ignoreFields) {
 
         Constructor<M> declaredConstructor = targetProtoClass.getDeclaredConstructor((Class<?>[]) null);
 
@@ -92,7 +162,16 @@ public class ProtoBeanUtil {
 
         Message.Builder builder = instance.toBuilder();
 
-        jsonToBuilder(builder, json);
+        ObjectMapper mapper = new ObjectMapper();
+        JsonNode root = mapper.readTree(json);
+        if (root instanceof ObjectNode objNode) {
+            for (String field : ignoreFields) {
+                objNode.remove(field);
+            }
+        }
+
+        String filteredJson = mapper.writeValueAsString(root);
+        jsonToBuilder(builder, filteredJson);
 
         return (M) builder.build();
     }
@@ -101,7 +180,7 @@ public class ProtoBeanUtil {
      * @desc: javaBean 列表 转 ProtoBean 列表
      */
     @SuppressWarnings("unchecked")
-    public static <M, T extends Message> List<T> beanListToProtoList(Collection<M> beanSourceList, Class<T> protoBean) {
+    public static <M, T extends Message> List<T> beanListToProtoList(Collection<M> beanSourceList, Class<T> protoBean, String... ignoreFields) {
         try {
             List<T> resultList = new ArrayList<>();
             for (Object bean : beanSourceList) {
@@ -114,7 +193,7 @@ public class ProtoBeanUtil {
 
                 Class<? extends Message.Builder> aClass = instance.toBuilder().getClass();
 
-                Message.Builder builder = beanToBuilder(bean, aClass);
+                Message.Builder builder = beanToBuilder(bean, aClass, ignoreFields);
 
                 resultList.add((T) builder.build());
             }

+syntax = "proto3";
+
+option java_multiple_files = true;
+option java_package = "com.infoloop.tianting.mealorderservice";
+option java_outer_classname = "MealOrderServiceProto";
+option objc_class_prefix = "OP";
+
+package com.infoloop.tianting.mealorderservice;
+
+service MealOrderServiceRpc {
+  rpc GetMealOrderById (GetMealOrderByIdRpcRequest) returns (GetMealOrderByIdRpcResponse) {}
+  rpc GetMealOrdersByIds (GetMealOrdersByIdsRpcRequest) returns (GetMealOrdersByIdsRpcResponse) {}
+  rpc QueryMealOrdersByCondition (QueryMealOrdersByConditionRpcRequest) returns (QueryMealOrdersByConditionRpcResponse) {}
+  rpc QueryReserveMealOrdersByDinerIds (QueryReserveMealOrdersByDinerIdsRpcRequest) returns (QueryReserveMealOrdersByDinerIdsRpcResponse) {}
+  rpc CreateMealOrder (CreateMealOrderRpcRequest) returns (CreateMealOrderRpcResponse) {}
+  rpc BatchCreateMealOrders (BatchCreateMealOrdersRpcRequest) returns (BatchCreateMealOrdersRpcResponse) {}
+  rpc DeleteMealOrdersByIds (DeleteMealOrdersByIdsRpcRequest) returns (DeleteMealOrdersRpcResponse) {}
+
+  rpc GetMpAccountById (GetMpAccountByIdRpcRequest) returns (GetMpAccountByIdRpcResponse) {}
+  rpc GetMpAccountByOpenId (GetMpAccountByOpenIdRpcRequest) returns (GetMpAccountByOpenIdRpcResponse) {}
+  rpc GetMpAccountsByIds (GetMpAccountsByIdsRpcRequest) returns (GetMpAccountsByIdsRpcResponse) {}
+  rpc QueryMpAccountsByCondition (QueryMpAccountsByConditionRpcRequest) returns (QueryMpAccountsByConditionRpcResponse) {}
+  rpc CreateMpAccount (CreateMpAccountRpcRequest) returns (CreateMpAccountRpcResponse) {}
+  rpc UpdateMpAccount (UpdateMpAccountRpcRequest) returns (UpdateMpAccountRpcResponse) {}
+  rpc DeleteMpAccountsByIds (DeleteMpAccountsByIdsRpcRequest) returns (DeleteMpAccountsRpcResponse) {}
+
+  rpc GetDinerById (GetDinerByIdRpcRequest) returns (GetDinerByIdRpcResponse) {}
+  rpc GetDinersByIds (GetDinersByIdsRpcRequest) returns (GetDinersByIdsRpcResponse) {}
+  rpc QueryDinersByCondition (QueryDinersByConditionRpcRequest) returns (QueryDinersByConditionRpcResponse) {}
+  rpc CreateDiner (CreateDinerRpcRequest) returns (CreateDinerRpcResponse) {}
+  rpc UpdateDiner (UpdateDinerRpcRequest) returns (UpdateDinerRpcResponse) {}
+  rpc BatchSaveOrUpdateDiners (BatchSaveOrUpdateDinersRpcRequest) returns (BatchSaveOrUpdateDinersRpcResponse) {}
+  rpc DeleteDinersByIds (DeleteDinersByIdsRpcRequest) returns (DeleteDinersRpcResponse) {}
+
+  rpc GetMpAccountDinerRefsByIds (GetMpAccountDinerRefsByIdsRpcRequest) returns (GetMpAccountDinerRefsByIdsRpcResponse) {}
+  rpc QueryMpAccountDinerRefsByCondition (QueryMpAccountDinerRefsByConditionRpcRequest) returns (QueryMpAccountDinerRefsByConditionRpcResponse) {}
+  rpc CreateMpAccountDinerRef (CreateMpAccountDinerRefRpcRequest) returns (CreateMpAccountDinerRefRpcResponse) {}
+  rpc DeleteMpAccountDinerRefsByIds (DeleteMpAccountDinerRefsByIdsRpcRequest) returns (DeleteMpAccountDinerRefsRpcResponse) {}
+
+  rpc GetGradeClassById (GetGradeClassByIdRpcRequest) returns (GetGradeClassByIdRpcResponse) {}
+  rpc GetGradeClassesByIds (GetGradeClassesByIdsRpcRequest) returns (GetGradeClassesByIdsRpcResponse) {}
+  rpc QueryGradeClassesByCondition (QueryGradeClassesByConditionRpcRequest) returns (QueryGradeClassesByConditionRpcResponse) {}
+  rpc CreateGradeClass (CreateGradeClassRpcRequest) returns (CreateGradeClassRpcResponse) {}
+  rpc BatchCreateGradeClasses (BatchCreateGradeClassesRpcRequest) returns (BatchCreateGradeClassesRpcResponse) {}
+  rpc UpdateGradeClass (UpdateGradeClassRpcRequest) returns (UpdateGradeClassRpcResponse) {}
+  rpc BatchSaveOrUpdateGradeClasses (BatchSaveOrUpdateGradeClassesRpcRequest) returns (BatchSaveOrUpdateGradeClassesRpcResponse) {}
+  rpc DeleteGradeClassesByIds (DeleteGradeClassesByIdsRpcRequest) returns (DeleteGradeClassesRpcResponse) {}
+  rpc DeleteGradeClassesAndDinersByClientIds (DeleteGradeClassesAndDinersByClientIdsRpcRequest) returns (DeleteGradeClassesAndDinersByClientIdsRpcResponse) {}
+  rpc DeleteGradeClassesAndDinersByClassIds (DeleteGradeClassesAndDinersByClassIdsRpcRequest) returns (DeleteGradeClassesAndDinersByClassIdsRpcResponse) {}
+
+  rpc GetMealMenuRecordById (GetMealMenuRecordByIdRpcRequest) returns (GetMealMenuRecordByIdRpcResponse) {}
+  rpc GetMealMenuRecordsByIds (GetMealMenuRecordsByIdsRpcRequest) returns (GetMealMenuRecordsByIdsRpcResponse) {}
+  rpc QueryMealMenuRecordsByCondition (QueryMealMenuRecordsByConditionRpcRequest) returns (QueryMealMenuRecordsByConditionRpcResponse) {}
+  rpc CreateMealMenuRecord (CreateMealMenuRecordRpcRequest) returns (CreateMealMenuRecordRpcResponse) {}
+  rpc QueryLatestMealMenuRecordsByClientIds (QueryLatestMealMenuRecordsByClientIdsRpcRequest) returns (QueryLatestMealMenuRecordsByClientIdsRpcResponse) {}
+}
+
+enum MealOrderOrderMethodEnum {
+  MEAL_ORDER_METHOD_SYSTEM = 0;
+  MEAL_ORDER_METHOD_MICRO = 1;
+}
+
+message SingleMealOrderRpcResponse {
+  int32 id = 1;
+  int32 enterpriseId = 2;
+  int32 clientId = 3;
+  int32 menuId = 4;
+  int32 accountId = 5;
+  MealOrderOrderMethodEnum orderMethod = 6;
+  int32 dinerId = 7;
+  string dinerName = 8;
+  string clientName = 9;
+  string gradeName = 10;
+  string className = 11;
+  string studentNo = 12;
+  int64 reserveDate = 13;
+  repeated MenuSchedule meals = 14;
+  int32 createdBy = 15;
+  int64 createdAt = 16;
+  int32 creationSource = 17;
+  int32 updatedBy = 18;
+  int64 updatedAt = 19;
+  int32 updateSource = 20;
+  bool isDeleted = 21;
+}
+
+message GetMealOrderByIdRpcRequest {
+  int32 id = 1;
+  int32 enterpriseId = 2;
+  bool includeDeleted = 3;
+}
+
+message GetMealOrderByIdRpcResponse {
+  SingleMealOrderRpcResponse response = 1;
+}
+
+message GetMealOrdersByIdsRpcRequest {
+  repeated int32 ids = 1;
+  int32 enterpriseId = 2;
+  bool includeDeleted = 3;
+}
+
+message GetMealOrdersByIdsRpcResponse {
+  repeated SingleMealOrderRpcResponse responses = 1;
+}
+
+message QueryMealOrdersByConditionRpcRequest {
+  int32 enterpriseId = 1;
+  bool shouldFilterClientIds = 2;
+  repeated int32 clientIds = 3;
+  bool shouldFilterMenuIds = 4;
+  repeated int32 menuIds = 5;
+  bool shouldFilterAccountIds = 6;
+  repeated int32 accountIds = 7;
+  bool shouldFilterOrderMethod = 8;
+  MealOrderOrderMethodEnum orderMethod = 9;
+  bool shouldFilterDinerIds = 10;
+  repeated int32 dinerIds = 11;
+  bool shouldFilterReserveDateStart = 12;
+  int64 reserveDateStart = 13;
+  bool shouldFilterReserveDateEnd = 14;
+  int64 reserveDateEnd = 15;
+  bool includeDeleted = 16;
+}
+
+message QueryMealOrdersByConditionRpcResponse {
+  repeated SingleMealOrderRpcResponse responses = 1;
+}
+
+message QueryReserveMealOrdersByDinerIdsRpcRequest {
+  int32 enterpriseId = 1;
+  repeated int32 dinerIds = 2;
+}
+
+message QueryReserveMealOrdersByDinerIdsRpcResponse {
+  repeated SingleMealOrderRpcResponse responses = 1;
+}
+
+message MealOrderCreation{
+  int32 clientId = 1;
+  int32 menuId = 2;
+  int32 accountId = 3;
+  MealOrderOrderMethodEnum orderMethod = 4;
+  int32 dinerId = 5;
+  string dinerName = 6;
+  string clientName = 7;
+  string gradeName = 8;
+  string className = 9;
+  string studentNo = 10;
+  int64 reserveDate = 11;
+  repeated MenuSchedule meals = 12;
+}
+
+message MenuSchedule {
+  string date = 1;  // 日期字段，类型是 string
+  string menu = 2;  // 菜单字段，类型是 string
+}
+
+message CreateMealOrderRpcRequest {
+  MealOrderCreation creation = 1;
+  int32 enterpriseId = 2;
+  int32 createdBy = 3;
+  int32 creationSource = 4;
+}
+
+message CreateMealOrderRpcResponse {
+  int32 id = 1;
+  bool isCreated = 2;
+}
+
+message BatchCreateMealOrdersRpcRequest {
+  repeated MealOrderCreation creations = 1;
+  int32 enterpriseId = 2;
+  int32 createdBy = 3;
+  int32 creationSource = 4;
+}
+
+message BatchCreateMealOrdersRpcResponse {
+  repeated int32 ids = 1;
+  bool isCreated = 2;
+}
+
+message MealOrderModification {
+  int32 id = 1;
+  bool shouldUpdateClientId = 2;
+  int32 clientId = 3;
+  bool shouldUpdateMenuId = 4;
+  int32 menuId = 5;
+  bool shouldUpdateAccountId = 6;
+  int32 accountId = 7;
+  bool shouldUpdateOrderMethod = 8;
+  MealOrderOrderMethodEnum orderMethod = 9;
+  bool shouldUpdateDinerId = 10;
+  int32 dinerId = 11;
+  bool shouldUpdateDinerName = 12;
+  string dinerName = 13;
+  bool shouldUpdateClientName = 14;
+  string clientName = 15;
+  bool shouldUpdateGradeName = 16;
+  string gradeName = 17;
+  bool shouldUpdateClassName = 18;
+  string className = 19;
+  bool shouldUpdateStudentNo = 20;
+  string studentNo = 21;
+  bool shouldUpdateReserveDate = 22;
+  int64 reserveDate = 23;
+  bool shouldUpdateMeals = 24;
+  repeated MenuSchedule meals = 25;
+}
+
+message UpdateMealOrderRpcRequest {
+  MealOrderModification modification = 1;
+  int32 enterpriseId = 2;
+  int32 updatedBy = 3;
+  int32 updateSource = 4;
+}
+
+message UpdateMealOrderRpcResponse {
+  bool isUpdated = 1;
+}
+
+message BatchUpdateMealOrdersRpcRequest {
+  repeated MealOrderModification modifications = 1;
+  int32 enterpriseId = 2;
+  int32 updatedBy = 3;
+  int32 updateSource = 4;
+}
+
+message BatchUpdateMealOrdersRpcResponse {
+  bool isUpdated = 1;
+}
+
+message DeleteMealOrdersByIdsRpcRequest {
+  repeated int32 ids = 1;
+  int32 enterpriseId = 2;
+  int32 updatedBy = 3;
+  int32 updateSource = 4;
+}
+
+message DeleteMealOrdersRpcResponse {
+  bool isDeleted = 1;
+}
+
+message SingleDinerRpcResponse {
+  int32 id = 1;
+  int32 enterpriseId = 2;
+  int32 clientId = 3;
+  int32 classId = 4;
+  string studentNo = 5;
+  string name = 6;
+  int32 createdBy = 7;
+  int64 createdAt = 8;
+  int32 creationSource = 9;
+  int32 updatedBy = 10;
+  int64 updatedAt = 11;
+  int32 updateSource = 12;
+  bool isDeleted = 13;
+}
+
+message GetDinerByIdRpcRequest {
+  int32 id = 1;
+  int32 enterpriseId = 2;
+  bool includeDeleted = 3;
+}
+
+message GetDinerByIdRpcResponse {
+  SingleDinerRpcResponse response = 1;
+}
+
+message GetDinersByIdsRpcRequest {
+  repeated int32 ids = 1;
+  int32 enterpriseId = 2;
+  bool includeDeleted = 3;
+}
+
+message GetDinersByIdsRpcResponse {
+  repeated SingleDinerRpcResponse responses = 1;
+}
+
+message QueryDinersByConditionRpcRequest {
+  int32 enterpriseId = 1;
+  bool shouldFilterClientIds = 2;
+  repeated int32 clientIds = 3;
+  bool shouldFilterClassIds = 4;
+  repeated int32 classIds = 5;
+  bool shouldFilterStudentNo = 6;
+  string studentNo = 7;
+  bool shouldFilterName = 8;
+  string name = 9;
+  bool includeDeleted = 10;
+}
+
+message QueryDinersByConditionRpcResponse {
+  repeated SingleDinerRpcResponse responses = 1;
+}
+
+message DinerCreation{
+  int32 clientId = 1;
+  int32 classId = 2;
+  string studentNo = 3;
+  string name = 4;
+}
+
+message CreateDinerRpcRequest {
+  DinerCreation creation = 1;
+  int32 enterpriseId = 2;
+  int32 createdBy = 3;
+  int32 creationSource = 4;
+}
+
+message CreateDinerRpcResponse {
+  int32 id = 1;
+  bool isCreated = 2;
+}
+
+message DinerModification {
+  int32 id = 1;
+  bool shouldUpdateClientId = 2;
+  int32 clientId = 3;
+  bool shouldUpdateClassId = 4;
+  int32 classId = 5;
+  bool shouldUpdateStudentNo = 6;
+  string studentNo = 7;
+  bool shouldUpdateName = 8;
+  string name = 9;
+}
+
+message UpdateDinerRpcRequest {
+  DinerModification modification = 1;
+  int32 enterpriseId = 2;
+  int32 updatedBy = 3;
+  int32 updateSource = 4;
+}
+
+message UpdateDinerRpcResponse {
+  bool isUpdated = 1;
+}
+
+message BatchSaveOrUpdateDinersRpcRequest {
+  repeated DinerModification modifications = 1;
+  int32 enterpriseId = 2;
+  int32 updatedBy = 3;
+  int32 updateSource = 4;
+}
+
+message BatchSaveOrUpdateDinersRpcResponse {
+  bool isUpdated = 1;
+}
+
+message DeleteDinersByIdsRpcRequest {
+  repeated int32 ids = 1;
+  int32 enterpriseId = 2;
+  int32 updatedBy = 3;
+  int32 updateSource = 4;
+}
+
+message DeleteDinersRpcResponse {
+  bool isDeleted = 1;
+}
+
+enum MpAccountGenderEnum {
+  MP_ACCOUNT_GENDER_MAN = 0;
+  MP_ACCOUNT_GENDER_WOMAN = 1;
+}
+enum MpAccountStatusEnum {
+  MP_ACCOUNT_STATUS_ENABLE = 0;
+  MP_ACCOUNT_STATUS_DISABLE = 1;
+}
+
+message SingleMpAccountRpcResponse {
+  int32 id = 1;
+  int32 enterpriseId = 2;
+  string openId = 3;
+  string unionId = 4;
+  string nickname = 5;
+  string avatarUrl = 6;
+  MpAccountGenderEnum gender = 7;
+  string phoneNumber = 8;
+  MpAccountStatusEnum status = 9;
+  int32 createdBy = 10;
+  int64 createdAt = 11;
+  int32 creationSource = 12;
+  int32 updatedBy = 13;
+  int64 updatedAt = 14;
+  int32 updateSource = 15;
+  bool isDeleted = 16;
+}
+
+message GetMpAccountByIdRpcRequest {
+  int32 id = 1;
+  int32 enterpriseId = 2;
+  bool includeDeleted = 3;
+}
+
+message GetMpAccountByIdRpcResponse {
+  SingleMpAccountRpcResponse response = 1;
+}
+
+message GetMpAccountByOpenIdRpcRequest {
+  string openId = 1;
+}
+
+message GetMpAccountByOpenIdRpcResponse {
+  SingleMpAccountRpcResponse response = 1;
+}
+
+message GetMpAccountsByIdsRpcRequest {
+  repeated int32 ids = 1;
+  int32 enterpriseId = 2;
+  bool includeDeleted = 3;
+}
+
+message GetMpAccountsByIdsRpcResponse {
+  repeated SingleMpAccountRpcResponse responses = 1;
+}
+
+message QueryMpAccountsByConditionRpcRequest {
+  int32 enterpriseId = 1;
+  bool shouldFilterOpenId = 2;
+  string openId = 3;
+  bool shouldFilterUnionId = 4;
+  string unionId = 5;
+  bool shouldFilterPhoneNumber = 6;
+  string phoneNumber = 7;
+  bool shouldFilterStatus = 8;
+  MpAccountStatusEnum status = 9;
+  bool includeDeleted = 10;
+}
+
+message QueryMpAccountsByConditionRpcResponse {
+  repeated SingleMpAccountRpcResponse responses = 1;
+}
+
+message MpAccountCreation{
+  string openId = 1;
+  bool shouldCreateUnionId = 2;
+  string unionId = 3;
+  bool shouldCreateNickname = 4;
+  string nickname = 5;
+  bool shouldCreateAvatarUrl = 6;
+  string avatarUrl = 7;
+  MpAccountGenderEnum gender = 8;
+  string phoneNumber = 9;
+  MpAccountStatusEnum status = 10;
+}
+
+message CreateMpAccountRpcRequest {
+  MpAccountCreation creation = 1;
+  int32 enterpriseId = 2;
+  int32 createdBy = 3;
+  int32 creationSource = 4;
+}
+
+message CreateMpAccountRpcResponse {
+  int32 id = 1;
+  bool isCreated = 2;
+}
+
+message MpAccountModification {
+  int32 id = 1;
+  bool shouldUpdateOpenId = 2;
+  string openId = 3;
+  bool shouldUpdateUnionId = 4;
+  string unionId = 5;
+  bool shouldUpdateNickname = 6;
+  string nickname = 7;
+  bool shouldUpdateAvatarUrl = 8;
+  string avatarUrl = 9;
+  bool shouldUpdateGender = 10;
+  MpAccountGenderEnum gender = 11;
+  bool shouldUpdatePhoneNumber = 12;
+  string phoneNumber = 13;
+  bool shouldUpdateStatus = 14;
+  MpAccountStatusEnum status = 15;
+}
+
+message UpdateMpAccountRpcRequest {
+  MpAccountModification modification = 1;
+  int32 enterpriseId = 2;
+  int32 updatedBy = 3;
+  int32 updateSource = 4;
+}
+
+message UpdateMpAccountRpcResponse {
+  bool isUpdated = 1;
+}
+
+message DeleteMpAccountsByIdsRpcRequest {
+  repeated int32 ids = 1;
+  int32 enterpriseId = 2;
+  int32 updatedBy = 3;
+  int32 updateSource = 4;
+}
+
+message DeleteMpAccountsRpcResponse {
+  bool isDeleted = 1;
+}
+
+message SingleMpAccountDinerRefRpcResponse {
+  int32 id = 1;
+  int32 enterpriseId = 2;
+  int32 accountId = 3;
+  int32 dinerId = 4;
+  int32 createdBy = 5;
+  int64 createdAt = 6;
+  int32 creationSource = 7;
+}
+
+message GetMpAccountDinerRefsByIdsRpcRequest {
+  repeated int32 ids = 1;
+  int32 enterpriseId = 2;
+}
+
+message GetMpAccountDinerRefsByIdsRpcResponse {
+  repeated SingleMpAccountDinerRefRpcResponse responses = 1;
+}
+
+message QueryMpAccountDinerRefsByConditionRpcRequest {
+  int32 enterpriseId = 1;
+  bool shouldFilterAccountIds = 2;
+  repeated int32 accountIds = 3;
+  bool shouldFilterDinerIds = 4;
+  repeated int32 dinerIds = 5;
+}
+
+message QueryMpAccountDinerRefsByConditionRpcResponse {
+  repeated SingleMpAccountDinerRefRpcResponse responses = 1;
+}
+
+message MpAccountDinerRefCreation{
+  int32 accountId = 1;
+  int32 dinerId = 2;
+}
+
+message CreateMpAccountDinerRefRpcRequest {
+  MpAccountDinerRefCreation creation = 1;
+  int32 enterpriseId = 2;
+  int32 createdBy = 3;
+  int32 creationSource = 4;
+}
+
+message CreateMpAccountDinerRefRpcResponse {
+  int32 id = 1;
+  bool isCreated = 2;
+}
+
+message BatchCreateMpAccountDinerRefsRpcRequest {
+  repeated MpAccountDinerRefCreation creations = 1;
+  int32 enterpriseId = 2;
+  int32 createdBy = 3;
+  int32 creationSource = 4;
+}
+
+message BatchCreateMpAccountDinerRefsRpcResponse {
+  repeated int32 ids = 1;
+  bool isCreated = 2;
+}
+
+message DeleteMpAccountDinerRefsByIdsRpcRequest {
+  repeated int32 ids = 1;
+  int32 enterpriseId = 2;
+}
+
+message DeleteMpAccountDinerRefsRpcResponse {
+  bool isDeleted = 1;
+}
+
+message SingleGradeClassRpcResponse {
+  int32 id = 1;
+  int32 enterpriseId = 2;
+  int32 clientId = 3;
+  string gradeName = 4;
+  string className = 5;
+  string fullName = 6;
+  int32 createdBy = 7;
+  int64 createdAt = 8;
+  int32 creationSource = 9;
+  int32 updatedBy = 10;
+  int64 updatedAt = 11;
+  int32 updateSource = 12;
+  bool isDeleted = 13;
+}
+
+message GetGradeClassByIdRpcRequest {
+  int32 id = 1;
+  int32 enterpriseId = 2;
+  bool includeDeleted = 3;
+}
+
+message GetGradeClassByIdRpcResponse {
+  SingleGradeClassRpcResponse response = 1;
+}
+
+message GetGradeClassesByIdsRpcRequest {
+  repeated int32 ids = 1;
+  int32 enterpriseId = 2;
+  bool includeDeleted = 3;
+}
+
+message GetGradeClassesByIdsRpcResponse {
+  repeated SingleGradeClassRpcResponse responses = 1;
+}
+
+message GetAllGradeClassesRpcRequest {
+  int32 enterpriseId = 1;
+  bool includeDeleted = 2;
+}
+
+message GetAllGradeClassesRpcResponse {
+  repeated SingleGradeClassRpcResponse responses = 1;
+}
+
+message QueryGradeClassesByConditionRpcRequest {
+  int32 enterpriseId = 1;
+  bool shouldFilterClientIds = 2;
+  repeated int32 clientIds = 3;
+  bool shouldFilterGradeNames = 4;
+  repeated string gradeName = 5;
+  bool includeDeleted = 6;
+}
+
+message QueryGradeClassesByConditionRpcResponse {
+  repeated SingleGradeClassRpcResponse responses = 1;
+}
+
+message GradeClassCreation{
+  int32 clientId = 1;
+  string gradeName = 2;
+  string className = 3;
+  bool shouldCreateFullName = 4;
+  string fullName = 5;
+}
+
+message CreateGradeClassRpcRequest {
+  GradeClassCreation creation = 1;
+  int32 enterpriseId = 2;
+  int32 createdBy = 3;
+  int32 creationSource = 4;
+}
+
+message CreateGradeClassRpcResponse {
+  int32 id = 1;
+  bool isCreated = 2;
+}
+
+message BatchCreateGradeClassesRpcRequest {
+  repeated GradeClassCreation creations = 1;
+  int32 enterpriseId = 2;
+  int32 createdBy = 3;
+  int32 creationSource = 4;
+}
+
+message BatchCreateGradeClassesRpcResponse {
+  repeated int32 ids = 1;
+  bool isCreated = 2;
+}
+
+message GradeClassModification {
+  int32 id = 1;
+  bool shouldUpdateClientId = 2;
+  int32 clientId = 3;
+  bool shouldUpdateGradeName = 4;
+  string gradeName = 5;
+  bool shouldUpdateClassName = 6;
+  string className = 7;
+  bool shouldUpdateFullName = 8;
+  string fullName = 9;
+}
+
+message UpdateGradeClassRpcRequest {
+  GradeClassModification modification = 1;
+  int32 enterpriseId = 2;
+  int32 updatedBy = 3;
+  int32 updateSource = 4;
+}
+
+message UpdateGradeClassRpcResponse {
+  bool isUpdated = 1;
+}
+
+message BatchSaveOrUpdateGradeClassesRpcRequest {
+  repeated GradeClassModification modifications = 1;
+  int32 enterpriseId = 2;
+  int32 updatedBy = 3;
+  int32 updateSource = 4;
+}
+
+message BatchSaveOrUpdateGradeClassesRpcResponse {
+  bool isUpdated = 1;
+}
+
+message BatchUpdateGradeClassesRpcRequest {
+  repeated GradeClassModification modifications = 1;
+  int32 enterpriseId = 2;
+  int32 updatedBy = 3;
+  int32 updateSource = 4;
+}
+
+message BatchUpdateGradeClassesRpcResponse {
+  bool isUpdated = 1;
+}
+
+message DeleteGradeClassesByIdsRpcRequest {
+  repeated int32 ids = 1;
+  int32 enterpriseId = 2;
+  int32 updatedBy = 3;
+  int32 updateSource = 4;
+}
+
+message DeleteGradeClassesRpcResponse {
+  bool isDeleted = 1;
+}
+
+message DeleteGradeClassesAndDinersByClientIdsRpcRequest {
+  repeated int32 clientIds = 1;
+  int32 enterpriseId = 2;
+  int32 updatedBy = 3;
+  int32 updateSource = 4;
+}
+
+message DeleteGradeClassesAndDinersByClientIdsRpcResponse {
+  bool isDeleted = 1;
+}
+
+message DeleteGradeClassesAndDinersByClassIdsRpcRequest {
+  repeated int32 classIds = 1;
+  int32 enterpriseId = 2;
+  int32 updatedBy = 3;
+  int32 updateSource = 4;
+}
+
+message DeleteGradeClassesAndDinersByClassIdsRpcResponse {
+  bool isDeleted = 1;
+}
+
+
+message SingleMealMenuRecordRpcResponse {
+  int32 id = 1;
+  int32 enterpriseId = 2;
+  int32 clientId = 3;
+  string name = 4;
+  string imageUrl = 5;
+  int32 createdBy = 6;
+  int64 createdAt = 7;
+  int32 creationSource = 8;
+  int32 updatedBy = 9;
+  int64 updatedAt = 10;
+  int32 updateSource = 11;
+  bool isDeleted = 12;
+}
+
+message GetMealMenuRecordByIdRpcRequest {
+  int32 id = 1;
+  int32 enterpriseId = 2;
+  bool includeDeleted = 3;
+}
+
+message GetMealMenuRecordByIdRpcResponse {
+  SingleMealMenuRecordRpcResponse response = 1;
+}
+
+message GetMealMenuRecordsByIdsRpcRequest {
+  repeated int32 ids = 1;
+  int32 enterpriseId = 2;
+  bool includeDeleted = 3;
+}
+
+message GetMealMenuRecordsByIdsRpcResponse {
+  repeated SingleMealMenuRecordRpcResponse responses = 1;
+}
+
+message QueryMealMenuRecordsByConditionRpcRequest {
+  int32 enterpriseId = 1;
+  bool shouldFilterClientIds = 2;
+  repeated int32 clientIds = 3;
+  bool shouldFilterName = 4;
+  string name = 5;
+  bool includeDeleted = 6;
+}
+
+message QueryMealMenuRecordsByConditionRpcResponse {
+  repeated SingleMealMenuRecordRpcResponse responses = 1;
+}
+
+message MealMenuRecordCreation{
+  int32 clientId = 1;
+  string name = 2;
+  bool shouldCreateImageUrl = 3;
+  string imageUrl = 4;
+}
+
+message CreateMealMenuRecordRpcRequest {
+  MealMenuRecordCreation creation = 1;
+  int32 enterpriseId = 2;
+  int32 createdBy = 3;
+  int32 creationSource = 4;
+}
+
+message CreateMealMenuRecordRpcResponse {
+  int32 id = 1;
+  bool isCreated = 2;
+}
+
+message QueryLatestMealMenuRecordsByClientIdsRpcRequest {
+  int32 enterpriseId = 1;
+  repeated int32 clientId = 2;
+}
+
+message QueryLatestMealMenuRecordsByClientIdsRpcResponse {
+  repeated SingleMealMenuRecordRpcResponse responses = 1;
+}

@@ -7,20 +7,13 @@ spring.main.web-application-type=none
 spring.application.name=order-service
 spring.datasource.driver-class-name=com.mysql.jdbc.Driver
 
-spring.datasource.dynamic.datasource.master.url=jdbc:mysql://localhost:3306/cater?autoReconnect=true&tcpKeepAlive=true&rewriteBatchedStatements=true&statementInterceptors=com.tianting.infoloop.tracing.MysqlZipkinInterceptor&useSSL=false
+spring.datasource.dynamic.datasource.master.url=jdbc:mysql://localhost:3306/test?autoReconnect=true&tcpKeepAlive=true&rewriteBatchedStatements=true&statementInterceptors=com.tianting.infoloop.tracing.MysqlZipkinInterceptor&useSSL=false
 spring.datasource.dynamic.datasource.master.username=root
-spring.datasource.dynamic.datasource.master.password=QAZwsx098
-spring.datasource.dynamic.datasource.slave.url=jdbc:mysql://localhost:3306/cater_slave?autoReconnect=true&tcpKeepAlive=true&statementInterceptors=com.tianting.infoloop.tracing.MysqlZipkinInterceptor&useSSL=false
+spring.datasource.dynamic.datasource.master.password=123456
+spring.datasource.dynamic.datasource.slave.url=jdbc:mysql://localhost:3306/test?autoReconnect=true&tcpKeepAlive=true&statementInterceptors=com.tianting.infoloop.tracing.MysqlZipkinInterceptor&useSSL=false
 spring.datasource.dynamic.datasource.slave.username=root
-spring.datasource.dynamic.datasource.slave.password=QAZwsx098
+spring.datasource.dynamic.datasource.slave.password=123456
 spring.datasource.dynamic.primary=master
-#spring.datasource.dynamic.datasource.master.url=jdbc:mysql://rm-uf63gfjzejp163e3g4o.mysql.rds.aliyuncs.com:3306/qingniu?autoReconnect=true&tcpKeepAlive=true&rewriteBatchedStatements=true&statementInterceptors=com.tianting.infoloop.tracing.MysqlZipkinInterceptor&useSSL=false
-#spring.datasource.dynamic.datasource.master.username=jj_infoloop_stage
-#spring.datasource.dynamic.datasource.master.password=H8kjNeChi1wimXw
-#spring.datasource.dynamic.datasource.slave.url=jdbc:mysql://rm-uf63gfjzejp163e3g4o.mysql.rds.aliyuncs.com:3306/qingniu?autoReconnect=true&tcpKeepAlive=true&statementInterceptors=com.tianting.infoloop.tracing.MysqlZipkinInterceptor&useSSL=false
-#spring.datasource.dynamic.datasource.slave.username=jj_infoloop_stage
-#spring.datasource.dynamic.datasource.slave.password=H8kjNeChi1wimXw
-#spring.datasource.dynamic.primary=master
 
 logging.config=classpath:logback-spring.xml
 

+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper
+        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
+        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="com.tianting.infoloop.mapper.DinerMapper">
+
+    <resultMap id="BaseResultMap" type="com.tianting.infoloop.model.db.Diner">
+            <id property="id" column="id" jdbcType="INTEGER"/>
+            <result property="enterpriseId" column="enterpriseId" jdbcType="INTEGER"/>
+            <result property="clientId" column="clientId" jdbcType="INTEGER"/>
+            <result property="classId" column="classId" jdbcType="INTEGER"/>
+            <result property="studentNo" column="studentNo" jdbcType="VARCHAR"/>
+            <result property="name" column="name" jdbcType="VARCHAR"/>
+            <result property="createdBy" column="createdBy" jdbcType="INTEGER"/>
+            <result property="createdAt" column="createdAt" jdbcType="TIMESTAMP"/>
+            <result property="creationSource" column="creationSource" jdbcType="INTEGER"/>
+            <result property="updatedBy" column="updatedBy" jdbcType="INTEGER"/>
+            <result property="updatedAt" column="updatedAt" jdbcType="TIMESTAMP"/>
+            <result property="updateSource" column="updateSource" jdbcType="INTEGER"/>
+            <result property="isDeleted" column="isDeleted" jdbcType="TINYINT"/>
+    </resultMap>
+
+    <sql id="Base_Column_List">
+        id,enterpriseId,clientId,
+        classId,studentNo,name,
+        createdBy,createdAt,creationSource,
+        updatedBy,updatedAt,updateSource,
+        isDeleted
+    </sql>
+</mapper>

+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper
+        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
+        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="com.tianting.infoloop.mapper.GradeClassMapper">
+
+    <resultMap id="BaseResultMap" type="com.tianting.infoloop.model.db.GradeClass">
+            <id property="id" column="id" jdbcType="INTEGER"/>
+            <result property="enterpriseId" column="enterpriseId" jdbcType="INTEGER"/>
+            <result property="clientId" column="clientId" jdbcType="INTEGER"/>
+            <result property="gradeName" column="gradeName" jdbcType="VARCHAR"/>
+            <result property="className" column="className" jdbcType="VARCHAR"/>
+            <result property="fullName" column="fullName" jdbcType="VARCHAR"/>
+            <result property="createdBy" column="createdBy" jdbcType="INTEGER"/>
+            <result property="createdAt" column="createdAt" jdbcType="TIMESTAMP"/>
+            <result property="creationSource" column="creationSource" jdbcType="INTEGER"/>
+            <result property="updatedBy" column="updatedBy" jdbcType="INTEGER"/>
+            <result property="updatedAt" column="updatedAt" jdbcType="TIMESTAMP"/>
+            <result property="updateSource" column="updateSource" jdbcType="INTEGER"/>
+            <result property="isDeleted" column="isDeleted" jdbcType="TINYINT"/>
+    </resultMap>
+
+    <sql id="Base_Column_List">
+        id,enterpriseId,clientId,
+        gradeName,className,fullName,
+        createdBy,createdAt,creationSource,
+        updatedBy,updatedAt,updateSource,
+        isDeleted
+    </sql>
+</mapper>

+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper
+        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
+        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="com.tianting.infoloop.mapper.MealMenuRecordMapper">
+
+    <resultMap id="BaseResultMap" type="com.tianting.infoloop.model.db.MealMenuRecord">
+            <id property="id" column="id" jdbcType="INTEGER"/>
+            <result property="enterpriseId" column="enterpriseId" jdbcType="INTEGER"/>
+            <result property="clientId" column="clientId" jdbcType="INTEGER"/>
+            <result property="name" column="name" jdbcType="VARCHAR"/>
+            <result property="imageUrl" column="imageUrl" jdbcType="VARCHAR"/>
+            <result property="createdBy" column="createdBy" jdbcType="INTEGER"/>
+            <result property="createdAt" column="createdAt" jdbcType="TIMESTAMP"/>
+            <result property="creationSource" column="creationSource" jdbcType="INTEGER"/>
+            <result property="updatedBy" column="updatedBy" jdbcType="INTEGER"/>
+            <result property="updatedAt" column="updatedAt" jdbcType="TIMESTAMP"/>
+            <result property="updateSource" column="updateSource" jdbcType="INTEGER"/>
+            <result property="isDeleted" column="isDeleted" jdbcType="TINYINT"/>
+    </resultMap>
+
+    <sql id="Base_Column_List">
+        id,enterpriseId,clientId,
+        name,imageUrl,createdBy,
+        createdAt,creationSource,updatedBy,
+        updatedAt,updateSource,isDeleted
+    </sql>
+</mapper>

+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper
+        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
+        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="com.tianting.infoloop.mapper.MealOrderMapper">
+
+    <resultMap id="BaseResultMap" type="com.tianting.infoloop.model.db.MealOrder">
+            <id property="id" column="id" jdbcType="INTEGER"/>
+            <result property="enterpriseId" column="enterpriseId" jdbcType="INTEGER"/>
+            <result property="clientId" column="clientId" jdbcType="INTEGER"/>
+            <result property="menuId" column="menuId" jdbcType="INTEGER"/>
+            <result property="accountId" column="accountId" jdbcType="INTEGER"/>
+            <result property="orderMethod" column="orderMethod" jdbcType="TINYINT"/>
+            <result property="dinerId" column="dinerId" jdbcType="INTEGER"/>
+            <result property="dinerName" column="dinerName" jdbcType="VARCHAR"/>
+            <result property="clientName" column="clientName" jdbcType="VARCHAR"/>
+            <result property="gradeName" column="gradeName" jdbcType="VARCHAR"/>
+            <result property="className" column="className" jdbcType="VARCHAR"/>
+            <result property="studentNo" column="studentNo" jdbcType="VARCHAR"/>
+            <result property="reserveDate" column="reserveDate" jdbcType="TIMESTAMP"/>
+            <result property="meals" column="meals" jdbcType="OTHER"/>
+            <result property="createdBy" column="createdBy" jdbcType="INTEGER"/>
+            <result property="createdAt" column="createdAt" jdbcType="TIMESTAMP"/>
+            <result property="creationSource" column="creationSource" jdbcType="INTEGER"/>
+            <result property="updatedBy" column="updatedBy" jdbcType="INTEGER"/>
+            <result property="updatedAt" column="updatedAt" jdbcType="TIMESTAMP"/>
+            <result property="updateSource" column="updateSource" jdbcType="INTEGER"/>
+            <result property="isDeleted" column="isDeleted" jdbcType="TINYINT"/>
+    </resultMap>
+
+    <sql id="Base_Column_List">
+        id,enterpriseId,clientId,
+        menuId,accountId,orderMethod,
+        dinerId,dinerName,clientName,
+        gradeName,className,studentNo,
+        reserveDate,meals,createdBy,
+        createdAt,creationSource,updatedBy,
+        updatedAt,updateSource,isDeleted
+    </sql>
+</mapper>

+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper
+        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
+        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="com.tianting.infoloop.mapper.MpAccountDinerRefMapper">
+
+    <resultMap id="BaseResultMap" type="com.tianting.infoloop.model.db.MpAccountDinerRef">
+            <id property="id" column="id" jdbcType="INTEGER"/>
+            <result property="enterpriseId" column="enterpriseId" jdbcType="INTEGER"/>
+            <result property="accountId" column="accountId" jdbcType="INTEGER"/>
+            <result property="dinerId" column="dinerId" jdbcType="INTEGER"/>
+            <result property="createdBy" column="createdBy" jdbcType="INTEGER"/>
+            <result property="createdAt" column="createdAt" jdbcType="TIMESTAMP"/>
+            <result property="creationSource" column="creationSource" jdbcType="INTEGER"/>
+    </resultMap>
+
+    <sql id="Base_Column_List">
+        id,enterpriseId,accountId,
+        dinerId,createdBy,createdAt,
+        creationSource
+    </sql>
+</mapper>

+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper
+        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
+        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="com.tianting.infoloop.mapper.MpAccountMapper">
+
+    <resultMap id="BaseResultMap" type="com.tianting.infoloop.model.db.MpAccount">
+            <id property="id" column="id" jdbcType="INTEGER"/>
+            <result property="enterpriseId" column="enterpriseId" jdbcType="INTEGER"/>
+            <result property="openId" column="openId" jdbcType="VARCHAR"/>
+            <result property="unionId" column="unionId" jdbcType="VARCHAR"/>
+            <result property="nickname" column="nickname" jdbcType="VARCHAR"/>
+            <result property="avatarUrl" column="avatarUrl" jdbcType="VARCHAR"/>
+            <result property="gender" column="gender" jdbcType="TINYINT"/>
+            <result property="phoneNumber" column="phoneNumber" jdbcType="VARCHAR"/>
+            <result property="status" column="status" jdbcType="TINYINT"/>
+            <result property="createdBy" column="createdBy" jdbcType="INTEGER"/>
+            <result property="createdAt" column="createdAt" jdbcType="TIMESTAMP"/>
+            <result property="creationSource" column="creationSource" jdbcType="INTEGER"/>
+            <result property="updatedBy" column="updatedBy" jdbcType="INTEGER"/>
+            <result property="updatedAt" column="updatedAt" jdbcType="TIMESTAMP"/>
+            <result property="updateSource" column="updateSource" jdbcType="INTEGER"/>
+            <result property="isDeleted" column="isDeleted" jdbcType="TINYINT"/>
+    </resultMap>
+
+    <sql id="Base_Column_List">
+        id,enterpriseId,openId,
+        unionId,nickname,avatarUrl,
+        gender,phoneNumber,status,
+        createdBy,createdAt,creationSource,
+        updatedBy,updatedAt,updateSource,
+        isDeleted
+    </sql>
+</mapper>