Merge pull request 'v1.0.57' (#69) from dev into master

Reviewed-on: #69

.gitignore

@@ -4,6 +4,7 @@
 /target
 /temp
 /AGENTS.md
+/.workbuddy
 
 multilingualField/
 !.mvn/wrapper/maven-wrapper.jar

pom.xml

@@ -11,7 +11,7 @@
 
 	<groupId>com.imyeyu.timiserverapi</groupId>
 	<artifactId>TimiServerAPI</artifactId>
-	<version>1.0.49</version>
+	<version>1.0.57</version>
 	<packaging>jar</packaging>
 	<name>TimiServerAPI</name>
 	<description>imyeyu.com API</description>
@@ -188,7 +188,11 @@
 		<dependency>
 			<groupId>com.imyeyu.spring</groupId>
 			<artifactId>timi-spring</artifactId>
-			<version>0.0.19</version>
+			<version>0.0.20</version>
+		</dependency>
+		<dependency>
+			<groupId>org.springframework.boot</groupId>
+			<artifactId>spring-boot-starter-freemarker</artifactId>
 		</dependency>
 		<dependency>
 			<groupId>com.imyeyu.network</groupId>

src/main/java/com/imyeyu/api/modules/common/entity/Attachment.java

@@ -56,6 +56,8 @@ public class Attachment extends UUIDEntity {
 
 		GAO_POINT_REDEMPTION_RETURN,
 
+		GAO_CUSTOMER_FOLLOW_UP_REMINDER,
+
 		TEMP_FILE,
 
 		MIRROR

src/main/java/com/imyeyu/api/modules/common/mapper/NotifyMapper.java

@@ -18,6 +18,16 @@ public interface NotifyMapper extends BaseMapper<Notify, String> {
 	/// 原子创建业务提醒
 	int insertIfAbsent(Notify notify);
 
+	/// 按业务查重键查询未删除通知
+	///
+	/// @param bizType 业务类型
+	/// @param bizRemindedType 业务提醒类型
+	/// @param bizRemindedKey 业务提醒查重键
+	/// @return 通知
+	Notify selectByBusinessKey(@Param("bizType") String bizType,
+		@Param("bizRemindedType") String bizRemindedType,
+		@Param("bizRemindedKey") String bizRemindedKey);
+
 	/// 分页查询管理端通知
 	///
 	/// @param userId 管理员用户 ID

src/main/java/com/imyeyu/api/modules/common/service/NotifyDetailService.java

@@ -26,6 +26,12 @@ public interface NotifyDetailService extends BaseService<NotifyDetail, String> {
 	/// @param detailId 通知详情 ID
 	void requeue(String detailId);
 
+	/// 取消尚未生效的通知详情
+	///
+	/// @param detailId 通知详情 ID
+	/// @param reason 取消原因
+	void cancelPending(String detailId, String reason);
+
 	/// 分页查询用户的站内通知
 	///
 	/// @param page 分页参数

src/main/java/com/imyeyu/api/modules/common/service/NotifyService.java

@@ -19,6 +19,14 @@ public interface NotifyService extends BaseService<Notify, String> {
 	/// @param notify 通知
 	void createIfAbsent(Notify notify);
 
+	/// 按业务查重键查询未删除通知
+	///
+	/// @param bizType 业务类型
+	/// @param bizRemindedType 业务提醒类型
+	/// @param bizRemindedKey 业务提醒查重键
+	/// @return 通知
+	Notify getByBusinessKey(String bizType, String bizRemindedType, String bizRemindedKey);
+
 	/// 分页查询当前用户创建的通知
 	///
 	/// @param page 分页参数

src/main/java/com/imyeyu/api/modules/common/service/implement/AttachmentServiceImplement.java

@@ -184,6 +184,7 @@ public class AttachmentServiceImplement extends AbstractEntityService<Attachment
 		try (InputStream inputStream = getInputStreamByMongoId(source.getMongoId())) {
 			target.setInputStream(inputStream);
 			create(target);
+			target.setInputStream(null);
 			return target;
 		} catch (IOException e) {
 			if (target.getMongoId() != null) {

src/main/java/com/imyeyu/api/modules/common/service/implement/AttachmentVariantServiceImplement.java

@@ -57,7 +57,7 @@ public class AttachmentVariantServiceImplement implements AttachmentVariantServi
 	private static final int THUMB_MAX_HEIGHT = 4096;
 	private static final long THUMB_MAX_PIXELS = 16_000_000L;
 	private static final long THUMB_CACHE_TTL = Time.D * 7;
-	private static final long THUMB_LOCK_TTL = Time.M * 10;
+	private static final long THUMB_LOCK_TTL = Time.M;
 	private static final double THUMB_TARGET_SECONDS = 2;
 	private static final int VARIANT_NAME_MAX_LENGTH = 255;
 	private static final String THUMB_OUTPUT_FORMAT = "png";

src/main/java/com/imyeyu/api/modules/common/service/implement/NotifyDetailServiceImplement.java

@@ -108,6 +108,36 @@ public class NotifyDetailServiceImplement extends AbstractEntityService<NotifyDe
 		super.delete(detailId);
 	}
 
+	/// 取消尚未生效的通知详情
+	///
+	/// @param detailId 通知详情 ID
+	/// @param reason 取消原因
+	@Override
+	@Transactional(TimiServerDBConfig.ROLLBACKER)
+	public void cancelPending(String detailId, String reason) {
+		TimiException.required(detailId, "未找到通知详情 ID");
+		NotifyDetail detail = get(detailId);
+		TimiException.required(detail, "未找到通知详情");
+		if (detail.getStatus() == NotifyDetail.Status.CANCEL) {
+			return;
+		}
+
+		long now = Time.now();
+		boolean canCancel = detail.getMsgType() == NotifyDetail.MsgType.INTERNAL
+			? detail.getSendAt() != null && now < detail.getSendAt()
+			: detail.getMsgType() != null && detail.getMsgType().isQueue()
+				&& detail.getStatus() == NotifyDetail.Status.WAITING;
+		if (!canCancel) {
+			return;
+		}
+		if (detail.getMsgType().isQueue()) {
+			detail.getMsgType().getService().destroyQueue(detail);
+		}
+		detail.setStatus(NotifyDetail.Status.CANCEL);
+		detail.setResultDesc(TimiJava.defaultIfEmpty(reason, "通知已取消"));
+		update(detail);
+	}
+
 	/// 重新将通知详情放入消息队列
 	///
 	/// @param detailId 通知详情 ID

src/main/java/com/imyeyu/api/modules/common/service/implement/NotifyServiceImplement.java

@@ -69,6 +69,20 @@ public class NotifyServiceImplement extends AbstractEntityService<Notify, String
 		createDetails(notify);
 	}
 
+	/// 按业务查重键查询未删除通知
+	///
+	/// @param bizType 业务类型
+	/// @param bizRemindedType 业务提醒类型
+	/// @param bizRemindedKey 业务提醒查重键
+	/// @return 通知
+	@Override
+	public Notify getByBusinessKey(String bizType, String bizRemindedType, String bizRemindedKey) {
+		TimiException.required(bizType, "未找到通知业务类型");
+		TimiException.required(bizRemindedType, "未找到通知提醒类型");
+		TimiException.required(bizRemindedKey, "未找到通知查重键");
+		return mapper.selectByBusinessKey(bizType, bizRemindedType, bizRemindedKey);
+	}
+
 	/// 校验并补全通知创建字段
 	///
 	/// @param notify 通知

src/main/java/com/imyeyu/api/modules/gao/bean/GaoPermissionCode.java

@@ -39,6 +39,16 @@ public enum GaoPermissionCode implements BuiltinPermissionCode {
 
 	CUSTOMER_DELETE("CUSTOMER:DELETE", "客户删除", false, false),
 
+	CUSTOMER_FOLLOW_UP_REMINDER_CREATE("CUSTOMER_FOLLOW_UP_REMINDER:CREATE", "客户跟进提醒创建", false, false),
+
+	CUSTOMER_FOLLOW_UP_REMINDER_READ("CUSTOMER_FOLLOW_UP_REMINDER:READ", "客户跟进提醒读取", false, false),
+
+	CUSTOMER_FOLLOW_UP_REMINDER_UPDATE("CUSTOMER_FOLLOW_UP_REMINDER:UPDATE", "客户跟进提醒修改", false, false),
+
+	CUSTOMER_FOLLOW_UP_REMINDER_DELETE("CUSTOMER_FOLLOW_UP_REMINDER:DELETE", "客户跟进提醒删除", false, false),
+
+	CUSTOMER_FOLLOW_UP_REMINDER_COMPLETE("CUSTOMER_FOLLOW_UP_REMINDER:COMPLETE", "客户跟进提醒完成", false, false),
+
 	EVENT_CREATE("EVENT:CREATE", "登记事件创建", false, false),
 
 	EVENT_READ("EVENT:READ", "登记事件读取", false, false),

src/main/java/com/imyeyu/api/modules/gao/controller/GaoCustomerFollowUpReminderController.java

@@ -0,0 +1,182 @@
+package com.imyeyu.api.modules.gao.controller;
+
+import com.fasterxml.jackson.annotation.JsonView;
+import com.imyeyu.api.modules.common.entity.Attachment;
+import com.imyeyu.api.modules.common.service.AttachmentService;
+import com.imyeyu.api.modules.gao.annotation.RequireGaoPermission;
+import com.imyeyu.api.modules.gao.bean.GaoPermissionCode;
+import com.imyeyu.api.modules.gao.entity.GaoCustomer;
+import com.imyeyu.api.modules.gao.entity.GaoCustomerFollowUpReminder;
+import com.imyeyu.api.modules.gao.service.GaoCustomerFollowUpReminderService;
+import com.imyeyu.api.modules.gao.service.GaoCustomerService;
+import com.imyeyu.api.modules.gao.service.GaoStoreScopeService;
+import com.imyeyu.api.modules.gao.vo.GaoCustomerFollowUpReminderPage;
+import com.imyeyu.api.modules.gao.vo.GaoCustomerFollowUpReminderPageResult;
+import com.imyeyu.api.modules.user.entity.User;
+import com.imyeyu.api.modules.user.service.UserService;
+import com.imyeyu.java.bean.timi.TimiException;
+import com.imyeyu.spring.annotation.AOPLog;
+import com.imyeyu.spring.annotation.RequestRateLimit;
+import com.imyeyu.spring.util.ResponseView;
+import lombok.RequiredArgsConstructor;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+
+import java.util.List;
+import java.util.Map;
+
+/// GAO 客户跟进提醒接口
+///
+/// @author Codex
+/// @since 2026-09-17
+@RestController
+@RequiredArgsConstructor
+@RequestMapping("/gao/customer/follow-up-reminder")
+public class GaoCustomerFollowUpReminderController {
+
+	private final GaoCustomerFollowUpReminderService service;
+	private final GaoCustomerService customerService;
+	private final GaoStoreScopeService storeScopeService;
+	private final UserService userService;
+	private final AttachmentService attachmentService;
+
+	/// 分页查询客户跟进提醒
+	///
+	/// @param page 查询条件
+	/// @return 分页结果
+	@AOPLog
+	@RequestRateLimit
+	@RequireGaoPermission(GaoPermissionCode.CUSTOMER_FOLLOW_UP_REMINDER_READ)
+	@PostMapping("/list")
+	@JsonView(ResponseView.Public.class)
+	public GaoCustomerFollowUpReminderPageResult list(@RequestBody GaoCustomerFollowUpReminderPage page) {
+		TimiException.required(page, "未找到分页参数");
+		page.setStoreId(storeScopeService.resolveStoreId(page.getStoreId()));
+		GaoCustomerFollowUpReminderPageResult result = service.pageByQuery(page);
+		fillList(result.getList());
+		return result;
+	}
+
+	/// 查询客户跟进提醒详情
+	///
+	/// @param id 跟进提醒 ID
+	/// @return 跟进提醒
+	@AOPLog
+	@RequestRateLimit
+	@RequireGaoPermission(GaoPermissionCode.CUSTOMER_FOLLOW_UP_REMINDER_READ)
+	@PostMapping("/detail")
+	@JsonView(ResponseView.Public.class)
+	public GaoCustomerFollowUpReminder detail(@RequestParam String id) {
+		GaoCustomerFollowUpReminder reminder = service.get(id);
+		TimiException.required(reminder, "未找到客户跟进提醒");
+		storeScopeService.checkStoreId(reminder.getStoreId());
+		fillDetail(reminder);
+		return reminder;
+	}
+
+	/// 创建客户跟进提醒
+	///
+	/// @param reminder 跟进提醒
+	/// @return 跟进提醒 ID
+	@AOPLog
+	@RequestRateLimit
+	@RequireGaoPermission(GaoPermissionCode.CUSTOMER_FOLLOW_UP_REMINDER_CREATE)
+	@PostMapping("/create")
+	public String create(@RequestBody GaoCustomerFollowUpReminder reminder) {
+		service.create(reminder);
+		return reminder.getId();
+	}
+
+	/// 修改客户跟进提醒
+	///
+	/// @param reminder 跟进提醒
+	@AOPLog
+	@RequestRateLimit
+	@RequireGaoPermission(GaoPermissionCode.CUSTOMER_FOLLOW_UP_REMINDER_UPDATE)
+	@PostMapping("/update")
+	public void update(@RequestBody GaoCustomerFollowUpReminder reminder) {
+		TimiException.required(reminder, "未找到客户跟进提醒");
+		TimiException.required(reminder.getId(), "未找到客户跟进提醒 ID");
+		GaoCustomerFollowUpReminder dbReminder = service.get(reminder.getId());
+		TimiException.required(dbReminder, "未找到客户跟进提醒");
+		storeScopeService.checkStoreId(dbReminder.getStoreId());
+		service.update(reminder);
+	}
+
+	/// 完成客户跟进提醒
+	///
+	/// @param id 跟进提醒 ID
+	@AOPLog
+	@RequestRateLimit
+	@RequireGaoPermission(GaoPermissionCode.CUSTOMER_FOLLOW_UP_REMINDER_COMPLETE)
+	@PostMapping("/complete")
+	public void complete(@RequestParam String id) {
+		GaoCustomerFollowUpReminder reminder = service.get(id);
+		TimiException.required(reminder, "未找到客户跟进提醒");
+		storeScopeService.checkStoreId(reminder.getStoreId());
+		service.complete(id);
+	}
+
+	/// 删除客户跟进提醒
+	///
+	/// @param id 跟进提醒 ID
+	@AOPLog
+	@RequestRateLimit
+	@RequireGaoPermission(GaoPermissionCode.CUSTOMER_FOLLOW_UP_REMINDER_DELETE)
+	@PostMapping("/delete")
+	public void delete(@RequestParam String id) {
+		GaoCustomerFollowUpReminder reminder = service.get(id);
+		TimiException.required(reminder, "未找到客户跟进提醒");
+		storeScopeService.checkStoreId(reminder.getStoreId());
+		service.delete(id);
+	}
+
+	/// 回填列表中的客户、负责人和附件
+	///
+	/// @param reminderList 提醒列表
+	private void fillList(List<GaoCustomerFollowUpReminder> reminderList) {
+		if (reminderList == null || reminderList.isEmpty()) {
+			return;
+		}
+		List<String> customerIdList = reminderList.stream()
+			.map(GaoCustomerFollowUpReminder::getCustomerId)
+			.distinct()
+			.toList();
+		Map<String, GaoCustomer> customerMap = customerService.mapByIdList(customerIdList);
+		Map<String, List<Attachment>> customerAttachmentMap = attachmentService.mapByBizIdList(
+			Attachment.BizType.GAO_CUSTOMER,
+			customerIdList);
+		Map<String, User> userMap = userService.mapByIdList(
+			reminderList.stream().map(GaoCustomerFollowUpReminder::getResponsibleUserId).distinct().toList());
+		Map<String, List<Attachment>> attachmentMap = attachmentService.mapByBizIdList(
+			Attachment.BizType.GAO_CUSTOMER_FOLLOW_UP_REMINDER,
+			reminderList.stream().map(GaoCustomerFollowUpReminder::getId).toList());
+		for (GaoCustomerFollowUpReminder reminder : reminderList) {
+			GaoCustomer customer = customerMap.get(reminder.getCustomerId());
+			if (customer != null) {
+				customer.setAttachmentList(customerAttachmentMap.getOrDefault(customer.getId(), List.of()));
+			}
+			reminder.setCustomer(customer);
+			reminder.setResponsibleUser(userMap.get(reminder.getResponsibleUserId()));
+			reminder.setAttachmentList(attachmentMap.getOrDefault(reminder.getId(), List.of()));
+			reminder.resolveNotifyChannelList();
+		}
+	}
+
+	/// 回填详情中的客户、负责人和附件
+	///
+	/// @param reminder 跟进提醒
+	private void fillDetail(GaoCustomerFollowUpReminder reminder) {
+		GaoCustomer customer = customerService.get(reminder.getCustomerId());
+		customer.setAttachmentList(attachmentService.listByBizId(Attachment.BizType.GAO_CUSTOMER, customer.getId(), GaoCustomer.AttachType.PHOTO.name()));
+		User responsibleUser = userService.get(reminder.getResponsibleUserId());
+		reminder.setCustomer(customer);
+		reminder.setResponsibleUser(responsibleUser);
+		reminder.setAttachmentList(attachmentService.listByBizId(
+			Attachment.BizType.GAO_CUSTOMER_FOLLOW_UP_REMINDER, reminder.getId()));
+		reminder.resolveNotifyChannelList();
+	}
+}

src/main/java/com/imyeyu/api/modules/gao/controller/GaoProductController.java

@@ -149,6 +149,17 @@ public class GaoProductController {
 		productService.disable(id);
 	}
 
+	@AOPLog
+	@RequestRateLimit
+	@RequireGaoPermission(GaoPermissionCode.PRODUCT_UPDATE)
+	@PostMapping("/delete")
+	public void delete(@RequestParam String id) {
+		GaoProduct product = productService.get(id);
+		TimiException.required(product, "not found product");
+		storeScopeService.checkStoreId(product.getStoreId());
+		productService.destroy(id);
+	}
+
 	@AOPLog
 	@RequestRateLimit
 	@RequireGaoPermission(GaoPermissionCode.PRODUCT_READ)
@@ -221,6 +232,21 @@ public class GaoProductController {
 		return spec.getId();
 	}
 
+	@AOPLog
+	@RequestRateLimit
+	@RequireGaoPermission(GaoPermissionCode.PRODUCT_UPDATE)
+	@PostMapping("/spec/update")
+	public void specUpdate(@RequestBody GaoProductSpec request) {
+		TimiException.required(request, "not found product spec");
+		TimiException.required(request.getId(), "not found product spec.id");
+		String productId = specService.getProductIdBySpecId(request.getId());
+		TimiException.required(productId, "产品规格不存在");
+		GaoProduct product = productService.get(productId);
+		TimiException.required(product, "not found product");
+		storeScopeService.checkStoreId(product.getStoreId());
+		specService.updateSpec(request);
+	}
+
 	@AOPLog
 	@RequestRateLimit
 	@RequireGaoPermission(GaoPermissionCode.PRODUCT_UPDATE)
@@ -236,6 +262,21 @@ public class GaoProductController {
 		return value.getId();
 	}
 
+	@AOPLog
+	@RequestRateLimit
+	@RequireGaoPermission(GaoPermissionCode.PRODUCT_UPDATE)
+	@PostMapping("/spec/value/update")
+	public void specValueUpdate(@RequestBody GaoProductSpecValue request) {
+		TimiException.required(request, "not found product spec value");
+		TimiException.required(request.getId(), "not found product spec value.id");
+		String productId = specService.getProductIdBySpecValueId(request.getId());
+		TimiException.required(productId, "产品规格值不存在");
+		GaoProduct product = productService.get(productId);
+		TimiException.required(product, "not found product");
+		storeScopeService.checkStoreId(product.getStoreId());
+		specService.updateValue(request);
+	}
+
 	@AOPLog
 	@RequestRateLimit
 	@RequireGaoPermission(GaoPermissionCode.PRODUCT_READ)

src/main/java/com/imyeyu/api/modules/gao/controller/GaoRoleController.java

@@ -3,8 +3,13 @@ package com.imyeyu.api.modules.gao.controller;
 import com.imyeyu.api.annotation.RequireCorePermission;
 import com.imyeyu.api.bean.CorePermissionCode;
 import com.imyeyu.api.bean.ModuleCode;
+import com.imyeyu.api.modules.gao.entity.GaoStore;
+import com.imyeyu.api.modules.gao.service.GaoStoreService;
+import com.imyeyu.api.modules.user.bean.AuthOwnerType;
 import com.imyeyu.api.modules.user.entity.Role;
 import com.imyeyu.api.modules.user.service.AuthorizationScopeService;
+import com.imyeyu.api.modules.user.service.PermissionService;
+import com.imyeyu.api.modules.user.service.RoleService;
 import com.imyeyu.api.modules.user.service.UserLoginService;
 import com.imyeyu.spring.annotation.AOPLog;
 import com.imyeyu.spring.annotation.RequestRateLimit;
@@ -26,6 +31,9 @@ public class GaoRoleController {
 
 	private final UserLoginService userLoginService;
 	private final AuthorizationScopeService authorizationScopeService;
+	private final GaoStoreService gaoStoreService;
+	private final PermissionService permissionService;
+	private final RoleService roleService;
 
 	@AOPLog
 	@RequestRateLimit
@@ -34,4 +42,40 @@ public class GaoRoleController {
 	public List<Role> availableList() {
 		return authorizationScopeService.listGrantableRole(userLoginService.getRequireLoginUserId(), ModuleCode.GAO);
 	}
+
+	/// 查询登录用户所属门店内可管理的角色
+	///
+	/// @return 门店角色列表
+	@AOPLog
+	@RequestRateLimit
+	@RequireCorePermission(CorePermissionCode.ROLE_READ)
+	@PostMapping("/management/list")
+	public List<Role> managementList() {
+		String loginUserId = userLoginService.getRequireLoginUserId();
+		GaoStore store = gaoStoreService.getByUserId(loginUserId);
+		if (store == null) {
+			return List.of();
+		}
+
+		List<Role> roleList = authorizationScopeService.listManageableRole(loginUserId, ModuleCode.GAO)
+				.stream()
+				.filter(role -> role.getOwnerType() == AuthOwnerType.STORE)
+				.filter(role -> store.getId().equals(role.getOwnerId()))
+				.toList();
+		roleList.forEach(this::fillRoleDetail);
+		return roleList;
+	}
+
+	/// 填充角色详情
+	///
+	/// @param role 角色
+	private void fillRoleDetail(Role role) {
+		role.setPermissionList(permissionService.listByRoleId(role.getId()));
+		role.setAllPermissionList(roleService.listPermissionByRoleId(role.getId()));
+		role.setChildRoleList(roleService.listChildByParentRoleId(role.getId()));
+		if (role.getParentRoleId() != null) {
+			role.setParentRole(roleService.get(role.getParentRoleId()));
+		}
+		role.setDelegationPermissionList(roleService.listDelegationPermissionByRoleId(role.getId()));
+	}
 }

src/main/java/com/imyeyu/api/modules/gao/controller/GaoSalesOrderController.java

@@ -9,6 +9,8 @@ import com.imyeyu.api.modules.gao.service.GaoOrderPaymentService;
 import com.imyeyu.api.modules.gao.service.GaoSalesOrderService;
 import com.imyeyu.api.modules.gao.service.GaoStoreScopeService;
 import com.imyeyu.api.modules.gao.vo.GaoDirectProductOrderCreateRequest;
+import com.imyeyu.api.modules.gao.vo.GaoCustomerProductPage;
+import com.imyeyu.api.modules.gao.vo.GaoCustomerProductCustomerView;
 import com.imyeyu.api.modules.gao.vo.GaoOrderPaymentActionRequest;
 import com.imyeyu.api.modules.gao.vo.GaoOrderPaymentNoRefundRequest;
 import com.imyeyu.api.modules.gao.vo.GaoOrderPaymentReceiveRequest;
@@ -16,6 +18,7 @@ import com.imyeyu.api.modules.gao.vo.GaoOrderPaymentRefundRequest;
 import com.imyeyu.api.modules.gao.vo.GaoOrderPaymentRevokeRequest;
 import com.imyeyu.api.modules.gao.vo.GaoSalesOrderCancelRequest;
 import com.imyeyu.api.modules.gao.vo.GaoSalesOrderPage;
+import com.imyeyu.api.modules.gao.vo.GaoSalesOrderReceivableStatView;
 import com.imyeyu.api.modules.gao.vo.GaoSalesOrderUpdateRequest;
 import com.imyeyu.api.modules.user.service.UserService;
 import com.imyeyu.java.TimiJava;
@@ -54,6 +57,26 @@ public class GaoSalesOrderController {
 		return service.pageByQuery(page);
 	}
 
+	@AOPLog
+	@RequestRateLimit
+	@RequireGaoPermission(GaoPermissionCode.SALES_ORDER_READ)
+	@PostMapping("/summary")
+	public GaoSalesOrderReceivableStatView summary(@RequestBody GaoSalesOrderPage page) {
+		TimiException.required(page, "not found sales order summary page");
+		page.setStoreId(storeScopeService.resolveStoreId(page.getStoreId()));
+		return service.summary(page);
+	}
+
+	@AOPLog
+	@RequestRateLimit
+	@RequireGaoPermission(GaoPermissionCode.SALES_ORDER_READ)
+	@PostMapping("/customer-product/list")
+	public PageResult<GaoCustomerProductCustomerView> customerProductList(@RequestBody GaoCustomerProductPage page) {
+		TimiException.required(page, "not found customer product page");
+		page.setStoreId(storeScopeService.resolveStoreId(page.getStoreId()));
+		return service.pageCustomerProduct(page);
+	}
+
 	@AOPLog
 	@RequestRateLimit
 	@RequireGaoPermission(GaoPermissionCode.SALES_ORDER_READ)

src/main/java/com/imyeyu/api/modules/gao/controller/GaoStoreChartController.java

@@ -2,6 +2,7 @@ package com.imyeyu.api.modules.gao.controller;
 
 import com.imyeyu.api.modules.gao.annotation.RequireGaoPermission;
 import com.imyeyu.api.modules.gao.bean.GaoPermissionCode;
+import com.imyeyu.api.modules.gao.service.GaoPointChartService;
 import com.imyeyu.api.modules.gao.service.GaoStoreChartService;
 import com.imyeyu.api.modules.gao.service.GaoStoreScopeService;
 import com.imyeyu.api.modules.gao.vo.GaoCustomerAgeStatView;
@@ -10,6 +11,8 @@ import com.imyeyu.api.modules.gao.vo.GaoCustomerGenderStatView;
 import com.imyeyu.api.modules.gao.vo.GaoEventRecordCalendarView;
 import com.imyeyu.api.modules.gao.vo.GaoEventRecordDailyStatView;
 import com.imyeyu.api.modules.gao.vo.GaoEventRecordNumberValueDailyStatView;
+import com.imyeyu.api.modules.gao.vo.GaoPointDailyStatView;
+import com.imyeyu.api.modules.gao.vo.GaoPointRedemptionProductRankView;
 import com.imyeyu.api.modules.gao.vo.GaoStoreChartReq;
 import com.imyeyu.java.bean.timi.TimiException;
 import com.imyeyu.spring.annotation.AOPLog;
@@ -33,6 +36,7 @@ import java.util.List;
 public class GaoStoreChartController {
 
 	private final GaoStoreChartService service;
+	private final GaoPointChartService pointChartService;
 	private final GaoStoreScopeService storeScopeService;
 
 	/// 查询客户增长趋势
@@ -96,4 +100,26 @@ public class GaoStoreChartController {
 		req.setStoreId(storeScopeService.resolveStoreId(req.getStoreId()));
 		return service.eventRecordCalendar(req);
 	}
+
+	/// 查询每日积分获得、消耗和差值
+	@AOPLog
+	@RequestRateLimit
+	@RequireGaoPermission(GaoPermissionCode.STAT_READ)
+	@PostMapping("/point/ledger/daily")
+	public List<GaoPointDailyStatView> pointDaily(@RequestBody GaoStoreChartReq req) {
+		TimiException.required(req, "积分图表请求不能为空");
+		req.setStoreId(storeScopeService.resolveStoreId(req.getStoreId()));
+		return pointChartService.dailyTrend(req);
+	}
+
+	/// 查询积分兑换产品排行
+	@AOPLog
+	@RequestRateLimit
+	@RequireGaoPermission(GaoPermissionCode.STAT_READ)
+	@PostMapping("/point/redemption/product/rank")
+	public List<GaoPointRedemptionProductRankView> pointRedemptionProductRank(@RequestBody GaoStoreChartReq req) {
+		TimiException.required(req, "积分兑换排行请求不能为空");
+		req.setStoreId(storeScopeService.resolveStoreId(req.getStoreId()));
+		return pointChartService.redemptionProductRank(req);
+	}
 }

src/main/java/com/imyeyu/api/modules/gao/controller/GaoUserController.java

@@ -102,9 +102,16 @@ public class GaoUserController {
 			List<String> userIdList = result.getList().stream().map(GaoUser::getUserId).toList();
 			Map<String, User> userMap = userService.mapByIdList(userIdList);
 			Map<String, List<Role>> roleMap = userRoleService.mapRoleListByUserIdList(userIdList);
+			Map<String, List<Attachment>> avatarMap = userIdList.isEmpty()
+				? Map.of()
+				: attachmentService.mapByBizIdList(Attachment.BizType.USER, userIdList, User.AttachType.AVATAR.name());
 			for (GaoUser gaoUser : result.getList()) {
-				gaoUser.setUser(userMap.get(gaoUser.getUserId()));
+				User user = userMap.get(gaoUser.getUserId());
-				gaoUser.getUser().setRoleEntityList(roleMap.get(gaoUser.getUserId()));
+				if (user != null) {
+					user.setAttachmentList(avatarMap.getOrDefault(user.getId(), List.of()));
+					user.setRoleEntityList(roleMap.get(gaoUser.getUserId()));
+				}
+				gaoUser.setUser(user);
 			}
 		}
 		return result;

src/main/java/com/imyeyu/api/modules/gao/entity/GaoCustomerFollowUpReminder.java

@@ -0,0 +1,110 @@
+package com.imyeyu.api.modules.gao.entity;
+
+import com.imyeyu.api.modules.common.entity.Attachment;
+import com.imyeyu.api.modules.user.entity.User;
+import com.imyeyu.spring.annotation.table.Transient;
+import com.imyeyu.spring.entity.UUIDEntity;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/// GAO 客户跟进提醒
+///
+/// @author Codex
+/// @since 2026-09-17
+@Data
+@EqualsAndHashCode(callSuper = true)
+public class GaoCustomerFollowUpReminder extends UUIDEntity {
+
+	/// 提醒状态
+	public enum Status {
+
+		/// 待完成
+		PENDING,
+
+		/// 已完成
+		COMPLETED
+	}
+
+	/// 通知渠道
+	public enum NotifyChannel {
+
+		/// 站内通知
+		INTERNAL,
+
+		/// 短信通知
+		SMS
+	}
+
+	/// 门店 ID
+	private String storeId;
+
+	/// 客户 ID
+	private String customerId;
+
+	/// 负责人用户 ID
+	private String responsibleUserId;
+
+	/// 跟进内容，纯文本
+	private String content;
+
+	/// 提醒时间，Unix 毫秒时间戳，精确到分钟
+	private Long remindAt;
+
+	/// 提醒状态
+	private Status status;
+
+	/// true 为发送站内通知
+	private Boolean internalNotifyEnabled;
+
+	/// true 为发送短信通知
+	private Boolean smsNotifyEnabled;
+
+	/// 站内通知详情 ID
+	private String internalNotifyDetailId;
+
+	/// 短信聚合通知详情 ID
+	private String smsNotifyDetailId;
+
+	/// 完成人用户 ID
+	private String completedBy;
+
+	/// 完成时间
+	private Long completedAt;
+
+	/// 创建人用户 ID
+	private String createdBy;
+
+	/// 最后修改人用户 ID
+	private String updatedBy;
+
+	/// 通知渠道列表
+	@Transient
+	private List<NotifyChannel> notifyChannelList;
+
+	/// 客户
+	@Transient
+	private GaoCustomer customer;
+
+	/// 负责人用户
+	@Transient
+	private User responsibleUser;
+
+	/// 附件列表
+	@Transient
+	private List<Attachment> attachmentList;
+
+	/// 根据持久化通知开关生成通知渠道列表
+	public void resolveNotifyChannelList() {
+		List<NotifyChannel> channelList = new ArrayList<>();
+		if (Boolean.TRUE.equals(internalNotifyEnabled)) {
+			channelList.add(NotifyChannel.INTERNAL);
+		}
+		if (Boolean.TRUE.equals(smsNotifyEnabled)) {
+			channelList.add(NotifyChannel.SMS);
+		}
+		notifyChannelList = channelList;
+	}
+}

src/main/java/com/imyeyu/api/modules/gao/entity/GaoProductSku.java

@@ -1,6 +1,7 @@
 package com.imyeyu.api.modules.gao.entity;
 
 import com.imyeyu.api.modules.common.entity.Attachment;
+import com.imyeyu.api.modules.gao.vo.GaoProductSkuBaseUnitMigrationRequest;
 import com.imyeyu.spring.annotation.table.Transient;
 import com.imyeyu.spring.entity.UUIDEntity;
 import lombok.Data;
@@ -77,6 +78,10 @@ public class GaoProductSku extends UUIDEntity {
 	@Transient
 	private List<GaoProductSkuUnit> unitList;
 
+	/// 基础单位迁移请求，仅用于 SKU 更新，不映射数据库列
+	@Transient
+	private GaoProductSkuBaseUnitMigrationRequest baseUnitMigrationRequest;
+
 	/// SKU 附件列表
 	@Transient
 	private List<Attachment> attachmentList;

src/main/java/com/imyeyu/api/modules/gao/mapper/GaoCustomerFollowUpReminderMapper.java

@@ -0,0 +1,53 @@
+package com.imyeyu.api.modules.gao.mapper;
+
+import com.imyeyu.api.modules.gao.entity.GaoCustomerFollowUpReminder;
+import com.imyeyu.api.modules.gao.vo.GaoCustomerFollowUpReminderPage;
+import com.imyeyu.spring.mapper.BaseMapper;
+import org.apache.ibatis.annotations.Param;
+
+import java.util.Collection;
+import java.util.List;
+
+/// GAO 客户跟进提醒 Mapper
+///
+/// @author Codex
+/// @since 2026-09-17
+public interface GaoCustomerFollowUpReminderMapper extends BaseMapper<GaoCustomerFollowUpReminder, String> {
+
+	/// 统计跟进提醒数量
+	///
+	/// @param page 查询条件
+	/// @return 数量
+	long countByQuery(@Param("page") GaoCustomerFollowUpReminderPage page);
+
+	/// 分页查询跟进提醒
+	///
+	/// @param page 查询条件
+	/// @return 提醒列表
+	List<GaoCustomerFollowUpReminder> selectByQuery(@Param("page") GaoCustomerFollowUpReminderPage page);
+
+	/// 查询待创建短信批次的提醒
+	///
+	/// @param beginAt 当天起点
+	/// @param endAt 次日当天起点
+	/// @return 待处理提醒
+	List<GaoCustomerFollowUpReminder> selectPendingSmsByRange(@Param("beginAt") long beginAt, @Param("endAt") long endAt);
+
+	/// 条件完成跟进提醒
+	///
+	/// @param id 提醒 ID
+	/// @param updatedBy 修改人
+	/// @param completedBy 完成人
+	/// @param completedAt 完成时间
+	/// @return 受影响行数
+	int complete(@Param("id") String id, @Param("updatedBy") String updatedBy,
+		@Param("completedBy") String completedBy, @Param("completedAt") long completedAt);
+
+	/// 为仍符合条件的提醒回写短信详情 ID
+	///
+	/// @param idList 提醒 ID 列表
+	/// @param smsNotifyDetailId 短信详情 ID
+	/// @return 受影响行数
+	int bindSmsNotifyDetailId(@Param("idList") Collection<String> idList,
+		@Param("smsNotifyDetailId") String smsNotifyDetailId);
+}

src/main/java/com/imyeyu/api/modules/gao/mapper/GaoPointChartMapper.java

@@ -0,0 +1,20 @@
+package com.imyeyu.api.modules.gao.mapper;
+
+import com.imyeyu.api.modules.gao.vo.GaoPointDailyStatView;
+import com.imyeyu.api.modules.gao.vo.GaoPointRedemptionProductRankView;
+import com.imyeyu.api.modules.gao.vo.GaoStoreChartReq;
+
+import java.util.List;
+
+/// 门店积分图表统计 Mapper
+///
+/// @author Codex
+/// @since 2026-09-23
+public interface GaoPointChartMapper {
+
+	/// 按天汇总积分获得和消耗
+	List<GaoPointDailyStatView> selectDailyTrend(GaoStoreChartReq req);
+
+	/// 按产品汇总兑换积分并取前 10
+	List<GaoPointRedemptionProductRankView> selectRedemptionProductRank(GaoStoreChartReq req);
+}

src/main/java/com/imyeyu/api/modules/gao/mapper/GaoProductEditMapper.java

@@ -0,0 +1,74 @@
+package com.imyeyu.api.modules.gao.mapper;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import org.apache.ibatis.annotations.Param;
+
+import java.math.BigDecimal;
+
+/// 产品编辑、引用检查与单位迁移 Mapper
+public interface GaoProductEditMapper {
+
+	int countProductReferences(@Param("productId") String productId);
+
+	int countSkuReferences(@Param("skuId") String skuId);
+
+	int countUnitReferences(@Param("unitId") String unitId);
+
+	int countMigrationPrecisionLoss(@Param("skuId") String skuId, @Param("targetUnitId") String targetUnitId,
+									@Param("ratio") BigDecimal ratio);
+
+	int updateProductOrderSnapshots(@Param("productId") String productId, @Param("productName") String productName);
+
+	int updateProductFulfillmentSnapshots(@Param("productId") String productId, @Param("productName") String productName);
+
+	int updateProductStockRecordSnapshots(@Param("productId") String productId, @Param("productName") String productName);
+
+	int updateProductPackageSnapshots(@Param("productId") String productId, @Param("productName") String productName);
+
+	int updateProductRedemptionSnapshots(@Param("productId") String productId, @Param("productName") String productName);
+
+	int updateSkuOrderSnapshots(@Param("skuId") String skuId, @Param("skuCode") String skuCode,
+							@Param("skuName") String skuName, @Param("specSummary") String specSummary,
+							@Param("skuSpecSnapshot") JsonNode skuSpecSnapshot);
+
+	int updateSkuFulfillmentSnapshots(@Param("skuId") String skuId, @Param("skuCode") String skuCode,
+									  @Param("skuName") String skuName, @Param("specSummary") String specSummary,
+									  @Param("skuSpecSnapshot") JsonNode skuSpecSnapshot);
+
+	int updateSkuStockRecordSnapshots(@Param("skuId") String skuId, @Param("skuCode") String skuCode,
+									  @Param("skuName") String skuName, @Param("specSummary") String specSummary,
+									  @Param("skuSpecSnapshot") JsonNode skuSpecSnapshot);
+
+	int updateSkuPackageSnapshots(@Param("skuId") String skuId, @Param("skuCode") String skuCode,
+								  @Param("skuName") String skuName, @Param("specSummary") String specSummary);
+
+	int updateSkuRedemptionSnapshots(@Param("skuId") String skuId, @Param("skuCode") String skuCode,
+									 @Param("skuName") String skuName, @Param("skuSpecSnapshot") JsonNode skuSpecSnapshot);
+
+	int updateUnitOrderSnapshots(@Param("unitId") String unitId, @Param("unitName") String unitName);
+
+	int updateUnitFulfillmentSnapshots(@Param("unitId") String unitId, @Param("unitName") String unitName);
+
+	int updateUnitStockRecordSnapshots(@Param("unitId") String unitId, @Param("unitName") String unitName);
+
+	int updateUnitPackageSnapshots(@Param("unitId") String unitId, @Param("unitName") String unitName);
+
+	int updateUnitRedemptionSnapshots(@Param("unitId") String unitId, @Param("unitName") String unitName);
+
+	int scaleSkuMinimumStock(@Param("skuId") String skuId, @Param("ratio") BigDecimal ratio);
+
+	int scaleProductStock(@Param("skuId") String skuId, @Param("ratio") BigDecimal ratio);
+
+	int scaleSalesOrderItems(@Param("skuId") String skuId, @Param("ratio") BigDecimal ratio);
+
+	int scaleFulfillmentItems(@Param("skuId") String skuId, @Param("ratio") BigDecimal ratio);
+
+	int scaleStockRecords(@Param("skuId") String skuId, @Param("ratio") BigDecimal ratio);
+
+	int scalePackageConfigItems(@Param("skuId") String skuId, @Param("ratio") BigDecimal ratio);
+
+	int scalePointRedemptions(@Param("skuId") String skuId, @Param("ratio") BigDecimal ratio);
+
+	int scalePointRedemptionReturns(@Param("skuId") String skuId, @Param("ratio") BigDecimal ratio);
+
+}

src/main/java/com/imyeyu/api/modules/gao/mapper/GaoProductSpecMapper.java

@@ -24,4 +24,7 @@ public interface GaoProductSpecMapper extends BaseMapper<GaoProductSpec, String>
 
 	/// 查询规格项所属产品
 	String selectProductIdBySpecId(@Param("specId") String specId);
+
+	/// 更新规格名称和排序
+	int updateSpec(GaoProductSpec spec);
 }

src/main/java/com/imyeyu/api/modules/gao/mapper/GaoProductSpecValueMapper.java

@@ -18,4 +18,7 @@ public interface GaoProductSpecValueMapper extends BaseMapper<GaoProductSpecValu
 
 	/// 按规格项查询规格值
 	List<GaoProductSpecValue> selectBySpecIdList(@Param("specIdList") Collection<String> specIdList);
+
+	/// 更新规格值名称和排序
+	int updateValue(GaoProductSpecValue value);
 }

src/main/java/com/imyeyu/api/modules/gao/mapper/GaoSalesOrderMapper.java

@@ -1,7 +1,11 @@
 package com.imyeyu.api.modules.gao.mapper;
 
 import com.imyeyu.api.modules.gao.entity.GaoSalesOrder;
+import com.imyeyu.api.modules.gao.vo.GaoCustomerProductPage;
+import com.imyeyu.api.modules.gao.vo.GaoCustomerProductCustomerRow;
+import com.imyeyu.api.modules.gao.vo.GaoCustomerProductView;
 import com.imyeyu.api.modules.gao.vo.GaoSalesOrderPage;
+import com.imyeyu.api.modules.gao.vo.GaoSalesOrderReceivableStatView;
 import com.imyeyu.spring.mapper.BaseMapper;
 import org.apache.ibatis.annotations.Param;
 
@@ -29,6 +33,18 @@ public interface GaoSalesOrderMapper extends BaseMapper<GaoSalesOrder, String> {
 	/// 按条件查询订单
 	List<GaoSalesOrder> selectByQuery(GaoSalesOrderPage page);
 
+	/// 按条件汇总订单金额
+	GaoSalesOrderReceivableStatView selectSummaryByQuery(GaoSalesOrderPage page);
+
+	/// 按条件统计客户产品客户
+	long countCustomerProductCustomerByQuery(GaoCustomerProductPage page);
+
+	/// 按条件查询客户产品客户
+	List<GaoCustomerProductCustomerRow> selectCustomerProductCustomerByQuery(GaoCustomerProductPage page);
+
+	/// 按条件查询客户产品明细
+	List<GaoCustomerProductView> selectCustomerProductByQuery(GaoCustomerProductPage page);
+
 	/// 更新订单付款汇总
 	int updatePayment(@Param("id") String id, @Param("pendingPaidAmount") Long pendingPaidAmount, @Param("paidAmount") Long paidAmount,
 		@Param("paidAt") Long paidAt, @Param("refundedAmount") Long refundedAmount, @Param("paymentStatus") GaoSalesOrder.PaymentStatus paymentStatus,

src/main/java/com/imyeyu/api/modules/gao/service/GaoCustomerFollowUpReminderService.java

@@ -0,0 +1,39 @@
+package com.imyeyu.api.modules.gao.service;
+
+import com.imyeyu.api.modules.gao.entity.GaoCustomerFollowUpReminder;
+import com.imyeyu.api.modules.gao.vo.GaoCustomerFollowUpReminderPage;
+import com.imyeyu.api.modules.gao.vo.GaoCustomerFollowUpReminderPageResult;
+import com.imyeyu.spring.service.BaseService;
+
+/// GAO 客户跟进提醒服务
+///
+/// @author Codex
+/// @since 2026-09-17
+public interface GaoCustomerFollowUpReminderService extends BaseService<GaoCustomerFollowUpReminder, String> {
+
+	/// 分页查询客户跟进提醒
+	///
+	/// @param page 查询条件
+	/// @return 分页结果
+	GaoCustomerFollowUpReminderPageResult pageByQuery(GaoCustomerFollowUpReminderPage page);
+
+	/// 创建客户跟进提醒
+	///
+	/// @param reminder 跟进提醒
+	@Override
+	void create(GaoCustomerFollowUpReminder reminder);
+
+	/// 修改客户跟进提醒
+	///
+	/// @param reminder 跟进提醒
+	@Override
+	void update(GaoCustomerFollowUpReminder reminder);
+
+	/// 完成客户跟进提醒
+	///
+	/// @param id 跟进提醒 ID
+	void complete(String id);
+
+	/// 创建当天的短信聚合批次
+	void createSmsBatch();
+}

src/main/java/com/imyeyu/api/modules/gao/service/GaoPointChartService.java

@@ -0,0 +1,20 @@
+package com.imyeyu.api.modules.gao.service;
+
+import com.imyeyu.api.modules.gao.vo.GaoPointDailyStatView;
+import com.imyeyu.api.modules.gao.vo.GaoPointRedemptionProductRankView;
+import com.imyeyu.api.modules.gao.vo.GaoStoreChartReq;
+
+import java.util.List;
+
+/// 门店积分图表统计服务
+///
+/// @author Codex
+/// @since 2026-09-23
+public interface GaoPointChartService {
+
+	/// 查询每日积分获得、消耗和差值
+	List<GaoPointDailyStatView> dailyTrend(GaoStoreChartReq req);
+
+	/// 查询积分兑换产品排行，按实际扣除积分取前 10
+	List<GaoPointRedemptionProductRankView> redemptionProductRank(GaoStoreChartReq req);
+}

src/main/java/com/imyeyu/api/modules/gao/service/GaoProductSkuService.java

@@ -59,6 +59,9 @@ public interface GaoProductSkuService extends BaseService<GaoProductSku, String>
 	/// @return SKU 规格结构快照；无规格时返回空数组
 	JsonNode getSkuSpecSnapshot(GaoProductSku sku);
 
+	/// 按当前 SKU 规格资料刷新所有历史快照
+	void refreshSpecHistorySnapshots(String productId);
+
 	/// 停用 SKU
 	void disable(String id);
 }

src/main/java/com/imyeyu/api/modules/gao/service/GaoProductSpecService.java

@@ -17,9 +17,21 @@ public interface GaoProductSpecService {
 	/// 查询规格项所属产品 ID
 	String getProductIdBySpecId(String specId);
 
+	/// 查询规格值所属产品 ID
+	String getProductIdBySpecValueId(String specValueId);
+
 	/// 创建规格项
 	void createSpec(GaoProductSpec spec);
 
+	/// 修正规格名称和排序
+	void updateSpec(GaoProductSpec spec);
+
 	/// 创建规格值
 	void createValue(GaoProductSpecValue value);
+
+	/// 修正规格值名称和排序
+	void updateValue(GaoProductSpecValue value);
+
+	/// 删除产品下的规格数据，仅用于产品物理删除
+	void destroyByProductId(String productId);
 }

src/main/java/com/imyeyu/api/modules/gao/service/GaoProductStockService.java

@@ -1,5 +1,6 @@
 package com.imyeyu.api.modules.gao.service;
 
+import com.imyeyu.api.modules.common.entity.Attachment;
 import com.imyeyu.api.modules.gao.entity.GaoProductStock;
 import com.imyeyu.api.modules.gao.entity.GaoProductStockRecord;
 import com.imyeyu.api.modules.gao.vo.GaoProductStockChangeRequest;
@@ -62,6 +63,10 @@ public interface GaoProductStockService {
 	/// 履约出库
 	List<GaoProductStock> outForFulfillment(String storeId, String bizId, List<GaoStockChangeItem> items, String requestNo, String operatorUserId);
 
+	/// 履约出库并复制履约附件到出库流水
+	List<GaoProductStock> outForFulfillment(String storeId, String bizId, List<GaoStockChangeItem> items, String requestNo,
+		String operatorUserId, List<Attachment> attachmentList);
+
 	/// 履约库存冲正入库
 	List<GaoProductStock> revokeForFulfillment(String storeId, String bizId, List<GaoStockChangeItem> items, String requestNo, String operatorUserId);
 

src/main/java/com/imyeyu/api/modules/gao/service/GaoSalesOrderService.java

@@ -3,9 +3,12 @@ package com.imyeyu.api.modules.gao.service;
 import com.imyeyu.api.modules.gao.entity.GaoSalesOrder;
 import com.imyeyu.api.modules.gao.entity.GaoSalesOrderItem;
 import com.imyeyu.api.modules.gao.vo.GaoDirectProductOrderCreateRequest;
+import com.imyeyu.api.modules.gao.vo.GaoCustomerProductPage;
+import com.imyeyu.api.modules.gao.vo.GaoCustomerProductCustomerView;
 import com.imyeyu.api.modules.gao.vo.GaoPackageOrderCreateData;
 import com.imyeyu.api.modules.gao.vo.GaoSalesOrderCancelRequest;
 import com.imyeyu.api.modules.gao.vo.GaoSalesOrderPage;
+import com.imyeyu.api.modules.gao.vo.GaoSalesOrderReceivableStatView;
 import com.imyeyu.api.modules.gao.vo.GaoSalesOrderUpdateRequest;
 import com.imyeyu.spring.bean.PageResult;
 import com.imyeyu.spring.service.BaseService;
@@ -24,6 +27,12 @@ public interface GaoSalesOrderService extends BaseService<GaoSalesOrder, String>
 	/// 按条件分页查询订单
 	PageResult<GaoSalesOrder> pageByQuery(GaoSalesOrderPage page);
 
+	/// 按条件汇总订单金额
+	GaoSalesOrderReceivableStatView summary(GaoSalesOrderPage page);
+
+	/// 按条件分页查询客户产品
+	PageResult<GaoCustomerProductCustomerView> pageCustomerProduct(GaoCustomerProductPage page);
+
 	/// 查询订单详情
 	GaoSalesOrder detail(String id);
 

src/main/java/com/imyeyu/api/modules/gao/service/implement/GaoCustomerFollowUpReminderServiceImplement.java

@@ -0,0 +1,512 @@
+package com.imyeyu.api.modules.gao.service.implement;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.imyeyu.api.config.dbsource.TimiServerDBConfig;
+import com.imyeyu.api.modules.common.entity.Attachment;
+import com.imyeyu.api.modules.common.entity.Notify;
+import com.imyeyu.api.modules.common.entity.NotifyDetail;
+import com.imyeyu.api.modules.common.service.AttachmentService;
+import com.imyeyu.api.modules.common.service.NotifyDetailService;
+import com.imyeyu.api.modules.common.service.NotifyService;
+import com.imyeyu.api.modules.gao.entity.GaoCustomer;
+import com.imyeyu.api.modules.gao.entity.GaoCustomerFollowUpReminder;
+import com.imyeyu.api.modules.gao.entity.GaoUser;
+import com.imyeyu.api.modules.gao.mapper.GaoCustomerFollowUpReminderMapper;
+import com.imyeyu.api.modules.gao.mapper.GaoUserMapper;
+import com.imyeyu.api.modules.gao.service.GaoCustomerFollowUpReminderService;
+import com.imyeyu.api.modules.gao.service.GaoCustomerService;
+import com.imyeyu.api.modules.gao.service.GaoStoreScopeService;
+import com.imyeyu.api.modules.gao.vo.GaoCustomerFollowUpReminderPage;
+import com.imyeyu.api.modules.gao.vo.GaoCustomerFollowUpReminderPageResult;
+import com.imyeyu.api.modules.user.entity.User;
+import com.imyeyu.api.modules.user.service.UserLoginService;
+import com.imyeyu.api.modules.user.service.UserService;
+import com.imyeyu.java.TimiJava;
+import com.imyeyu.java.bean.timi.TimiException;
+import com.imyeyu.spring.mapper.BaseMapper;
+import com.imyeyu.spring.service.AbstractEntityService;
+import com.imyeyu.utils.Time;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.time.Instant;
+import java.time.LocalDate;
+import java.time.LocalTime;
+import java.time.ZoneId;
+import java.time.format.DateTimeFormatter;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+
+/// GAO 客户跟进提醒服务实现
+///
+/// @author Codex
+/// @since 2026-09-17
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class GaoCustomerFollowUpReminderServiceImplement extends AbstractEntityService<GaoCustomerFollowUpReminder, String> implements GaoCustomerFollowUpReminderService {
+
+	private static final String NOTIFY_BIZ_TYPE = "GAO_CUSTOMER_FOLLOW_UP_REMINDER";
+	private static final String INTERNAL_NOTIFY_TYPE = "INTERNAL";
+	private static final String SMS_BATCH_NOTIFY_TYPE = "SMS";
+	private static final String ZONE_ID = "Asia/Shanghai";
+	private static final String SMS_BATCH_KEY_PREFIX = "GAO_CUSTOMER_FOLLOW_UP_SMS";
+	private static final long MINUTE_MILLIS = 60_000L;
+	private static final String SMS_TEMPLATE_ID = "2734293";
+	private static final LocalTime SMS_CUTOFF_TIME = LocalTime.of(8, 0);
+	private static final DateTimeFormatter DAY_FORMATTER = DateTimeFormatter.BASIC_ISO_DATE;
+
+	private final ObjectMapper jackson;
+	private final AttachmentService attachmentService;
+	private final NotifyDetailService notifyDetailService;
+	private final NotifyService notifyService;
+	private final GaoCustomerService customerService;
+	private final GaoStoreScopeService storeScopeService;
+	private final GaoUserMapper gaoUserMapper;
+	private final UserService userService;
+	private final UserLoginService userLoginService;
+
+	private final GaoCustomerFollowUpReminderMapper mapper;
+
+	@Override
+	protected BaseMapper<GaoCustomerFollowUpReminder, String> mapper() {
+		return mapper;
+	}
+
+	/// 分页查询客户跟进提醒
+	///
+	/// @param page 查询条件
+	/// @return 分页结果
+	@Override
+	public GaoCustomerFollowUpReminderPageResult pageByQuery(GaoCustomerFollowUpReminderPage page) {
+		TimiException.required(page, "未找到分页参数");
+		GaoCustomerFollowUpReminderPageResult result = new GaoCustomerFollowUpReminderPageResult();
+		result.setTotal(mapper.countByQuery(page));
+		result.setList(mapper.selectByQuery(page));
+		return result;
+	}
+
+	/// 创建客户跟进提醒
+	///
+	/// @param reminder 跟进提醒
+	@Override
+	@Transactional(TimiServerDBConfig.ROLLBACKER)
+	public void create(GaoCustomerFollowUpReminder reminder) {
+		TimiException.required(reminder, "未找到客户跟进提醒");
+		resolveChannelFlags(reminder);
+		GaoCustomer customer = validateReminder(reminder, null);
+		User responsibleUser = validateResponsibleUser(reminder.getStoreId(), reminder.getResponsibleUserId(),
+			Boolean.TRUE.equals(reminder.getSmsNotifyEnabled()));
+
+		reminder.setStatus(GaoCustomerFollowUpReminder.Status.PENDING);
+		reminder.setCreatedBy(userLoginService.getRequireLoginUserId());
+		reminder.setUpdatedBy(null);
+		reminder.setCompletedBy(null);
+		reminder.setCompletedAt(null);
+		super.create(reminder);
+		attachmentService.updateByBizId(Attachment.BizType.GAO_CUSTOMER_FOLLOW_UP_REMINDER,
+			reminder.getId(), reminder.getAttachmentList());
+		if (Boolean.TRUE.equals(reminder.getInternalNotifyEnabled())) {
+			reminder.setInternalNotifyDetailId(createInternalNotify(reminder, customer, responsibleUser));
+			super.update(reminder);
+		}
+		reminder.resolveNotifyChannelList();
+	}
+
+	/// 修改客户跟进提醒
+	///
+	/// @param reminder 跟进提醒
+	@Override
+	@Transactional(TimiServerDBConfig.ROLLBACKER)
+	public void update(GaoCustomerFollowUpReminder reminder) {
+		TimiException.required(reminder, "未找到客户跟进提醒");
+		TimiException.required(reminder.getId(), "未找到客户跟进提醒 ID");
+		GaoCustomerFollowUpReminder dbReminder = get(reminder.getId());
+		TimiException.required(dbReminder, "未找到客户跟进提醒");
+		TimiException.requiredTrue(dbReminder.getStatus() == GaoCustomerFollowUpReminder.Status.PENDING,
+			"已完成的客户跟进提醒不能修改");
+		resolveChannelFlags(reminder);
+		GaoCustomer customer = validateReminder(reminder, dbReminder);
+		User responsibleUser = validateResponsibleUser(reminder.getStoreId(), reminder.getResponsibleUserId(),
+			Boolean.TRUE.equals(reminder.getSmsNotifyEnabled()));
+		checkGeneratedSmsMutation(dbReminder, reminder);
+
+		boolean oldInternalEnabled = Boolean.TRUE.equals(dbReminder.getInternalNotifyEnabled());
+		dbReminder.setCustomerId(reminder.getCustomerId());
+		dbReminder.setStoreId(reminder.getStoreId());
+		dbReminder.setResponsibleUserId(reminder.getResponsibleUserId());
+		dbReminder.setContent(reminder.getContent());
+		dbReminder.setRemindAt(reminder.getRemindAt());
+		dbReminder.setInternalNotifyEnabled(reminder.getInternalNotifyEnabled());
+		dbReminder.setSmsNotifyEnabled(reminder.getSmsNotifyEnabled());
+		dbReminder.setUpdatedBy(userLoginService.getRequireLoginUserId());
+
+		syncInternalNotify(dbReminder, customer, responsibleUser, oldInternalEnabled);
+		super.update(dbReminder);
+		attachmentService.updateByBizId(Attachment.BizType.GAO_CUSTOMER_FOLLOW_UP_REMINDER,
+			dbReminder.getId(), reminder.getAttachmentList());
+		dbReminder.resolveNotifyChannelList();
+	}
+
+	/// 完成客户跟进提醒
+	///
+	/// @param id 跟进提醒 ID
+	@Override
+	@Transactional(TimiServerDBConfig.ROLLBACKER)
+	public void complete(String id) {
+		TimiException.required(id, "未找到客户跟进提醒 ID");
+		GaoCustomerFollowUpReminder reminder = get(id);
+		TimiException.required(reminder, "未找到客户跟进提醒");
+		storeScopeService.checkStoreId(reminder.getStoreId());
+		TimiException.requiredTrue(reminder.getStatus() == GaoCustomerFollowUpReminder.Status.PENDING,
+			"客户跟进提醒已经完成");
+		long now = Time.now();
+		String loginUserId = userLoginService.getRequireLoginUserId();
+		int affected = mapper.complete(id, loginUserId, loginUserId, now);
+		TimiException.requiredTrue(0 < affected, "客户跟进提醒状态已发生变化");
+		cancelInternalNotify(reminder, "跟进提醒已完成");
+	}
+
+	/// 删除客户跟进提醒
+	///
+	/// @param id 跟进提醒 ID
+	@Override
+	@Transactional(TimiServerDBConfig.ROLLBACKER)
+	public void delete(String id) {
+		TimiException.required(id, "未找到客户跟进提醒 ID");
+		GaoCustomerFollowUpReminder reminder = get(id);
+		TimiException.required(reminder, "未找到客户跟进提醒");
+		storeScopeService.checkStoreId(reminder.getStoreId());
+		cancelInternalNotify(reminder, "跟进提醒已删除");
+		attachmentService.deleteByBizId(Attachment.BizType.GAO_CUSTOMER_FOLLOW_UP_REMINDER, id);
+		super.delete(id);
+	}
+
+	/// 创建当天的短信聚合批次
+	@Override
+	@Transactional(TimiServerDBConfig.ROLLBACKER)
+	public void createSmsBatch() {
+		ZoneId zoneId = ZoneId.of(ZONE_ID);
+		LocalDate today = LocalDate.now(zoneId);
+		long beginAt = today.atStartOfDay(zoneId).toInstant().toEpochMilli();
+		long endAt = today.plusDays(1).atStartOfDay(zoneId).toInstant().toEpochMilli();
+		List<GaoCustomerFollowUpReminder> reminderList = mapper.selectPendingSmsByRange(beginAt, endAt);
+		if (reminderList.isEmpty()) {
+			return;
+		}
+
+		Map<String, User> userMap = userService.mapByIdList(reminderList.stream()
+			.map(GaoCustomerFollowUpReminder::getResponsibleUserId).distinct().toList());
+		Map<String, GaoCustomer> customerMap = customerService.mapByIdList(reminderList.stream()
+			.map(GaoCustomerFollowUpReminder::getCustomerId).distinct().toList());
+		Map<SmsBatchGroup, List<GaoCustomerFollowUpReminder>> groupMap = new LinkedHashMap<>();
+		for (GaoCustomerFollowUpReminder reminder : reminderList) {
+			User user = userMap.get(reminder.getResponsibleUserId());
+			String phoneNo = user == null ? null : user.getPhoneNo();
+			boolean validPhone = user != null && user.isPhoneNoVerified() && user.isValidPhone();
+			SmsBatchGroup group = new SmsBatchGroup(reminder.getStoreId(), reminder.getResponsibleUserId(), phoneNo, validPhone);
+			groupMap.computeIfAbsent(group, ignored -> new ArrayList<>()).add(reminder);
+		}
+
+		for (Map.Entry<SmsBatchGroup, List<GaoCustomerFollowUpReminder>> entry : groupMap.entrySet()) {
+			createSmsBatch(entry.getKey(), entry.getValue(), customerMap, today, endAt - 1, SMS_TEMPLATE_ID);
+		}
+	}
+
+	/// 校验提醒基础字段和客户门店范围
+	///
+	/// @param reminder 跟进提醒
+	/// @param dbReminder 数据库提醒，创建时为空
+	/// @return 客户
+	private GaoCustomer validateReminder(GaoCustomerFollowUpReminder reminder,
+		GaoCustomerFollowUpReminder dbReminder) {
+		TimiException.required(reminder.getCustomerId(), "未找到客户 ID");
+		TimiException.required(reminder.getResponsibleUserId(), "未找到负责人用户 ID");
+		TimiException.required(reminder.getContent(), "未找到跟进内容");
+		TimiException.requiredTrue(!reminder.getContent().isBlank(), "跟进内容不能为空");
+		validateRemindAt(reminder.getRemindAt());
+		GaoCustomer customer = customerService.get(reminder.getCustomerId());
+		TimiException.required(customer, "未找到客户");
+		storeScopeService.checkStoreId(customer.getStoreId());
+		if (TimiJava.isNotEmpty(reminder.getStoreId())) {
+			TimiException.requiredTrue(customer.getStoreId().equals(reminder.getStoreId()), "客户和提醒门店不一致");
+		}
+		if (dbReminder != null && dbReminder.getStoreId() != null) {
+			TimiException.requiredTrue(dbReminder.getStoreId().equals(customer.getStoreId()), "客户不能跨门店修改");
+		}
+		reminder.setStoreId(customer.getStoreId());
+		if (Boolean.TRUE.equals(reminder.getSmsNotifyEnabled())
+			&& (dbReminder == null || TimiJava.isEmpty(dbReminder.getSmsNotifyDetailId()))) {
+			validateSmsDate(reminder.getRemindAt());
+		}
+		return customer;
+	}
+
+	/// 校验负责人属于当前门店并处于启用状态
+	///
+	/// @param storeId 门店 ID
+	/// @param userId 用户 ID
+	/// @param smsEnabled true 为需要校验短信手机号
+	/// @return 核心用户
+	private User validateResponsibleUser(String storeId, String userId, boolean smsEnabled) {
+		GaoUser example = new GaoUser();
+		example.setStoreId(storeId);
+		example.setUserId(userId);
+		example.setEnabled(true);
+		TimiException.required(gaoUserMapper.selectByExample(example), "负责人不是当前门店启用中的 GAO 用户");
+		User user = userService.get(userId);
+		TimiException.required(user, "未找到负责人用户");
+		if (smsEnabled) {
+			TimiException.requiredTrue(user.isPhoneNoVerified() && user.isValidPhone(), "负责人没有有效已验证手机号");
+		}
+		return user;
+	}
+
+	/// 校验提醒时间
+	///
+	/// @param remindAt 提醒时间
+	private void validateRemindAt(Long remindAt) {
+		TimiException.required(remindAt, "未找到提醒时间");
+		TimiException.requiredTrue(0 == remindAt % MINUTE_MILLIS, "提醒时间必须精确到分钟");
+		TimiException.requiredTrue(Time.now() < remindAt, "提醒时间不能早于当前时间");
+	}
+
+	/// 校验短信当天八点截止规则
+	///
+	/// @param remindAt 提醒时间
+	private void validateSmsDate(long remindAt) {
+		ZoneId zoneId = ZoneId.of(ZONE_ID);
+		var now = Instant.ofEpochMilli(Time.now()).atZone(zoneId);
+		var remindTime = Instant.ofEpochMilli(remindAt).atZone(zoneId);
+		TimiException.requiredTrue(!now.toLocalDate().equals(remindTime.toLocalDate())
+			|| now.toLocalTime().isBefore(SMS_CUTOFF_TIME), "当天八点后不能选择当天短信通知");
+	}
+
+	/// 根据请求渠道解析持久化开关
+	///
+	/// @param reminder 跟进提醒
+	private void resolveChannelFlags(GaoCustomerFollowUpReminder reminder) {
+		List<GaoCustomerFollowUpReminder.NotifyChannel> channelList = reminder.getNotifyChannelList();
+		reminder.setInternalNotifyEnabled(channelList != null && channelList.contains(GaoCustomerFollowUpReminder.NotifyChannel.INTERNAL));
+		reminder.setSmsNotifyEnabled(channelList != null && channelList.contains(GaoCustomerFollowUpReminder.NotifyChannel.SMS));
+	}
+
+	/// 校验短信批次生成后的不可变字段
+	///
+	/// @param dbReminder 数据库提醒
+	/// @param request 请求提醒
+	private void checkGeneratedSmsMutation(GaoCustomerFollowUpReminder dbReminder,
+		GaoCustomerFollowUpReminder request) {
+		if (TimiJava.isEmpty(dbReminder.getSmsNotifyDetailId())) {
+			return;
+		}
+		TimiException.requiredTrue(Objects.equals(dbReminder.getCustomerId(), request.getCustomerId()),
+			"短信批次已生成后不能修改客户");
+		TimiException.requiredTrue(Objects.equals(dbReminder.getResponsibleUserId(), request.getResponsibleUserId()),
+			"短信批次已生成后不能修改负责人");
+		TimiException.requiredTrue(Objects.equals(dbReminder.getSmsNotifyEnabled(), request.getSmsNotifyEnabled()),
+			"短信批次已生成后不能修改短信通知配置");
+		TimiException.requiredTrue(sameLocalDate(dbReminder.getRemindAt(), request.getRemindAt()),
+			"短信批次已生成后不能修改提醒日期");
+	}
+
+	/// 判断两个时间是否属于同一业务日期
+	///
+	/// @param first 第一个时间
+	/// @param second 第二个时间
+	/// @return true 为同一天
+	private boolean sameLocalDate(Long first, Long second) {
+		if (first == null || second == null) {
+			return false;
+		}
+		ZoneId zoneId = ZoneId.of(ZONE_ID);
+		return Instant.ofEpochMilli(first).atZone(zoneId).toLocalDate()
+			.equals(Instant.ofEpochMilli(second).atZone(zoneId).toLocalDate());
+	}
+
+	/// 同步站内通知
+	///
+	/// @param reminder 数据库提醒
+	/// @param customer 客户
+	/// @param responsibleUser 负责人
+	/// @param oldInternalEnabled 修改前站内通知开关
+	private void syncInternalNotify(GaoCustomerFollowUpReminder reminder, GaoCustomer customer,
+		User responsibleUser, boolean oldInternalEnabled) {
+		boolean enabled = Boolean.TRUE.equals(reminder.getInternalNotifyEnabled());
+		if (!enabled) {
+			cancelInternalNotify(reminder, "站内通知已取消");
+			return;
+		}
+		NotifyDetail detail = TimiJava.isEmpty(reminder.getInternalNotifyDetailId())
+			? null : notifyDetailService.get(reminder.getInternalNotifyDetailId());
+		if (!oldInternalEnabled || detail == null || detail.getStatus() == NotifyDetail.Status.CANCEL) {
+			reminder.setInternalNotifyDetailId(createInternalNotify(reminder, customer, responsibleUser));
+			return;
+		}
+		if (detail.getMsgType() == NotifyDetail.MsgType.INTERNAL
+			&& detail.getSendAt() != null && Time.now() < detail.getSendAt()
+			&& detail.getStatus() == NotifyDetail.Status.WAITING) {
+			detail.setContent(buildInternalContent(customer, reminder));
+			detail.setSendAt(reminder.getRemindAt());
+			notifyDetailService.update(detail);
+		}
+	}
+
+	/// 创建站内通知
+	///
+	/// @param reminder 跟进提醒
+	/// @param customer 客户
+	/// @param responsibleUser 负责人
+	/// @return 通知详情 ID
+	private String createInternalNotify(GaoCustomerFollowUpReminder reminder, GaoCustomer customer,
+		User responsibleUser) {
+		NotifyDetail detail = new NotifyDetail();
+		detail.setMsgType(NotifyDetail.MsgType.INTERNAL);
+		detail.setSubject("客户跟进提醒");
+		detail.setContent(buildInternalContent(customer, reminder));
+		detail.setContentType(NotifyDetail.ContentType.TEXT);
+		detail.setSendFrom(userLoginService.getRequireLoginUserId());
+		detail.setSendTo(responsibleUser.getId());
+		detail.setSendAt(reminder.getRemindAt());
+		detail.setTimeoutAt(reminder.getRemindAt() + Time.D);
+
+		Notify oldNotify = null;
+		if (TimiJava.isNotEmpty(reminder.getInternalNotifyDetailId())) {
+			NotifyDetail oldDetail = notifyDetailService.get(reminder.getInternalNotifyDetailId());
+			if (oldDetail != null) {
+				oldNotify = notifyService.get(oldDetail.getNotifyId());
+			}
+		}
+		if (oldNotify == null) {
+			oldNotify = notifyService.getByBusinessKey(NOTIFY_BIZ_TYPE, INTERNAL_NOTIFY_TYPE, reminder.getId());
+		}
+		if (oldNotify == null) {
+			Notify notify = new Notify();
+			notify.setBizType(NOTIFY_BIZ_TYPE);
+			notify.setBizRemindedType(INTERNAL_NOTIFY_TYPE);
+			notify.setBizRemindedKey(reminder.getId());
+			notify.setCreatedBy(userLoginService.getRequireLoginUserId());
+			notify.setDetailList(List.of(detail));
+			notifyService.create(notify);
+		} else {
+			detail.setNotifyId(oldNotify.getId());
+			notifyDetailService.create(detail);
+		}
+		return detail.getId();
+	}
+
+	/// 构建站内通知正文
+	///
+	/// @param customer 客户
+	/// @param reminder 跟进提醒
+	/// @return 通知正文
+	private String buildInternalContent(GaoCustomer customer, GaoCustomerFollowUpReminder reminder) {
+		String content = reminder.getContent();
+		String summary = content.length() <= 100 ? content : content.substring(0, 100) + "...";
+		return "客户「%s」跟进提醒：%s\n提醒 ID：%s".formatted(customer.getName(), summary, reminder.getId());
+	}
+
+	/// 取消尚未生效的站内通知
+	///
+	/// @param reminder 跟进提醒
+	/// @param reason 取消原因
+	private void cancelInternalNotify(GaoCustomerFollowUpReminder reminder, String reason) {
+		if (TimiJava.isNotEmpty(reminder.getInternalNotifyDetailId())) {
+			notifyDetailService.cancelPending(reminder.getInternalNotifyDetailId(), reason);
+		}
+	}
+
+	/// 创建一个短信聚合通知并回写提醒
+	///
+	/// @param group 聚合分组
+	/// @param reminderList 分组提醒
+	/// @param customerMap 客户映射
+	/// @param today 目标日期
+	/// @param timeoutAt 当天结束时间
+	/// @param templateId 短信模板 ID
+	private void createSmsBatch(SmsBatchGroup group, List<GaoCustomerFollowUpReminder> reminderList,
+		Map<String, GaoCustomer> customerMap, LocalDate today, long timeoutAt, String templateId) {
+		String key = "%s:%s:%s:%s".formatted(SMS_BATCH_KEY_PREFIX, group.storeId(), group.responsibleUserId(),
+			today.format(DAY_FORMATTER));
+		Notify notify = notifyService.getByBusinessKey(NOTIFY_BIZ_TYPE, SMS_BATCH_NOTIFY_TYPE, key);
+		if (notify == null) {
+			Notify newNotify = new Notify();
+			newNotify.setBizType(NOTIFY_BIZ_TYPE);
+			newNotify.setBizRemindedType(SMS_BATCH_NOTIFY_TYPE);
+			newNotify.setBizRemindedKey(key);
+			newNotify.setDetailList(List.of(buildSmsDetail(group, reminderList, customerMap, timeoutAt, templateId)));
+			notifyService.createIfAbsent(newNotify);
+			notify = notifyService.getByBusinessKey(NOTIFY_BIZ_TYPE, SMS_BATCH_NOTIFY_TYPE, key);
+		}
+		TimiException.required(notify, "创建客户跟进提醒短信批次失败");
+		NotifyDetail smsDetail = notifyDetailService.listByNotifyId(notify.getId()).stream()
+			.filter(item -> item.getMsgType() == NotifyDetail.MsgType.SMS)
+			.findFirst().orElse(null);
+		if (smsDetail == null) {
+			smsDetail = buildSmsDetail(group, reminderList, customerMap, timeoutAt, templateId);
+			smsDetail.setNotifyId(notify.getId());
+			notifyDetailService.create(smsDetail);
+		}
+		if (!group.validPhone() && smsDetail.getStatus() == NotifyDetail.Status.WAITING) {
+			smsDetail.getMsgType().getService().destroyQueue(smsDetail);
+			smsDetail.setStatus(NotifyDetail.Status.FAIL);
+			smsDetail.setResultDesc("负责人当前没有有效已验证手机号");
+			notifyDetailService.update(smsDetail);
+		}
+		Collection<String> reminderIdList = reminderList.stream().map(GaoCustomerFollowUpReminder::getId).toList();
+		mapper.bindSmsNotifyDetailId(reminderIdList, smsDetail.getId());
+	}
+
+	/// 构建短信详情
+	///
+	/// @param group 聚合分组
+	/// @param reminderList 分组提醒
+	/// @param customerMap 客户映射
+	/// @param timeoutAt 超时时间
+	/// @param templateId 模板 ID
+	/// @return 短信详情
+	private NotifyDetail buildSmsDetail(SmsBatchGroup group, List<GaoCustomerFollowUpReminder> reminderList,
+		Map<String, GaoCustomer> customerMap, long timeoutAt, String templateId) {
+		String customerNames = formatCustomerNames(reminderList, customerMap);
+		NotifyDetail detail = new NotifyDetail();
+		detail.setMsgType(NotifyDetail.MsgType.SMS);
+		detail.setTemplateId(templateId);
+		detail.setContent("客户跟进提醒：请及时跟进客户%s。".formatted(customerNames));
+		detail.setContentType(NotifyDetail.ContentType.TEXT);
+		detail.setArgs(jackson.valueToTree(List.of(customerNames)));
+		detail.setSendTo(group.phoneNo());
+		detail.setSendAt(Time.now());
+		detail.setTimeoutAt(timeoutAt);
+		return detail;
+	}
+
+	/// 格式化短信中的客户名称
+	///
+	/// @param reminderList 提醒列表
+	/// @param customerMap 客户映射
+	/// @return 客户名称摘要
+	private String formatCustomerNames(List<GaoCustomerFollowUpReminder> reminderList,
+		Map<String, GaoCustomer> customerMap) {
+		Map<String, String> nameMap = new LinkedHashMap<>();
+		for (GaoCustomerFollowUpReminder reminder : reminderList) {
+			GaoCustomer customer = customerMap.get(reminder.getCustomerId());
+			String name = customer == null ? null : customer.getName();
+			nameMap.putIfAbsent(reminder.getCustomerId(), TimiJava.isEmpty(name) ? "未知客户" : name.trim());
+		}
+		List<String> nameList = new ArrayList<>(nameMap.values());
+		if (nameList.size() <= 2) {
+			return String.join("、", nameList);
+		}
+		return "%s、%s等 %d 位".formatted(nameList.get(0), nameList.get(1), nameList.size());
+	}
+
+	/// 短信聚合分组
+	private record SmsBatchGroup(String storeId, String responsibleUserId, String phoneNo, boolean validPhone) {
+	}
+}

src/main/java/com/imyeyu/api/modules/gao/service/implement/GaoOrderFulfillmentServiceImplement.java

@@ -261,8 +261,10 @@ public class GaoOrderFulfillmentServiceImplement extends AbstractEntityService<G
 		applySkuSpecSnapshots(stockItems, fulfillmentItemList);
 		String verifierUserId = userLoginService.getRequireLoginUserId();
 		if (!stockItems.isEmpty()) {
+			List<Attachment> attachmentList = attachmentService.listByBizId(
+				Attachment.BizType.GAO_ORDER_FULFILLMENT, fulfillment.getId());
 			productStockService.outForFulfillment(order.getStoreId(), fulfillment.getId(), stockItems,
-				stockRequestNo(fulfillment, "OUT"), verifierUserId);
+				stockRequestNo(fulfillment, "OUT"), verifierUserId, attachmentList);
 		}
 		TimiException.requiredTrue(1 == mapper.updateStatus(fulfillment.getId(), GaoOrderFulfillment.Status.VERIFIED,
 			verifierUserId, Time.now(), request.getReason()), "履约状态已变化");

src/main/java/com/imyeyu/api/modules/gao/service/implement/GaoOrderReminderServiceImplement.java

@@ -4,6 +4,7 @@ import com.fasterxml.jackson.databind.ObjectMapper;
 import com.imyeyu.api.modules.common.entity.Notify;
 import com.imyeyu.api.modules.common.entity.NotifyDetail;
 import com.imyeyu.api.modules.common.service.NotifyService;
+import com.imyeyu.api.modules.gao.entity.GaoSalesOrder;
 import com.imyeyu.api.modules.gao.entity.GaoUser;
 import com.imyeyu.api.modules.gao.mapper.GaoOrderReminderMapper;
 import com.imyeyu.api.modules.gao.mapper.GaoUserMapper;
@@ -12,15 +13,21 @@ import com.imyeyu.api.modules.gao.vo.GaoOrderReminderCustomer;
 import com.imyeyu.api.modules.user.entity.User;
 import com.imyeyu.api.modules.user.service.UserService;
 import com.imyeyu.utils.Time;
+import freemarker.template.Configuration;
+import freemarker.template.Template;
+import freemarker.template.TemplateException;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Service;
 
+import java.io.IOException;
+import java.io.StringWriter;
+import java.math.BigDecimal;
 import java.time.LocalDate;
 import java.time.ZoneId;
 import java.util.ArrayList;
-import java.util.LinkedHashSet;
 import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
@@ -38,57 +45,96 @@ public class GaoOrderReminderServiceImplement implements GaoOrderReminderService
 	private static final String NOTIFY_BIZ_TYPE = "GAO_ORDER_REMINDER";
 	private static final String SMS_TEMPLATE_ID = "2725097";
 	private static final String ZONE_ID = "Asia/Shanghai";
+	private static final String INTERNAL_TEMPLATE_NAME = "GaoOrderReminder.ftl";
+	private static final int MAX_SMS_CUSTOMER_NAME_COUNT = 6;
+	private static final int MAX_SMS_CUSTOMER_COUNT = 99;
 
 	private final GaoOrderReminderMapper mapper;
 	private final GaoUserMapper gaoUserMapper;
 	private final UserService userService;
 	private final NotifyService notifyService;
 	private final ObjectMapper jackson;
+	private final Configuration freemarkerConfiguration;
 
+	/// 发送订单收款提醒
 	@Override
 	public void sendOrderReceiveReminder() {
 		send(mapper.selectOrderReceiveCustomers(), ReminderType.ORDER_RECEIVE);
 	}
 
+	/// 发送收款和履约核销提醒
 	@Override
 	public void sendVerifyReminder() {
-		Map<String, Map<String, GaoOrderReminderCustomer>> storeCustomerMap = new LinkedHashMap<>();
+		Map<String, Map<String, ReminderEntry>> storeEntryMap = new LinkedHashMap<>();
-		Map<String, Set<String>> storeActionMap = new LinkedHashMap<>();
+		mergeCustomers(storeEntryMap, mapper.selectReceiveVerifyCustomers(), "核销收款");
-		mergeCustomers(storeCustomerMap, storeActionMap, mapper.selectReceiveVerifyCustomers(), "核销收款");
+		mergeCustomers(storeEntryMap, mapper.selectFulfillmentVerifyCustomers(), "核销履约");
-		mergeCustomers(storeCustomerMap, storeActionMap, mapper.selectFulfillmentVerifyCustomers(), "核销履约");
+		sendStoreReminders(storeEntryMap, ReminderType.VERIFY.name());
-		for (Map.Entry<String, Map<String, GaoOrderReminderCustomer>> entry : storeCustomerMap.entrySet()) {
-			String action = String.join("、", storeActionMap.get(entry.getKey()));
-			sendStoreReminder(entry.getKey(), new ArrayList<>(entry.getValue().values()), ReminderType.VERIFY.name(), action);
-		}
-	}
-
-	private void mergeCustomers(Map<String, Map<String, GaoOrderReminderCustomer>> storeCustomerMap,
-		Map<String, Set<String>> storeActionMap, List<GaoOrderReminderCustomer> customerList, String action) {
-		if (customerList == null || customerList.isEmpty()) {
-			return;
-		}
-		for (GaoOrderReminderCustomer customer : customerList) {
-			storeCustomerMap.computeIfAbsent(customer.getStoreId(), key -> new LinkedHashMap<>())
-				.putIfAbsent(customer.getCustomerId(), customer);
-			storeActionMap.computeIfAbsent(customer.getStoreId(), key -> new LinkedHashSet<>()).add(action);
-		}
 	}
 
+	/// 按提醒类型发送订单提醒
+	///
+	/// @param customerList 订单提醒列表
+	/// @param reminderType 提醒类型
 	private void send(List<GaoOrderReminderCustomer> customerList, ReminderType reminderType) {
 		if (customerList == null || customerList.isEmpty()) {
 			return;
 		}
-		Map<String, List<GaoOrderReminderCustomer>> storeCustomerMap = customerList.stream()
+		Map<String, Map<String, ReminderEntry>> storeEntryMap = new LinkedHashMap<>();
-			.collect(Collectors.groupingBy(GaoOrderReminderCustomer::getStoreId, LinkedHashMap::new, Collectors.toList()));
+		mergeCustomers(storeEntryMap, customerList, reminderType.label);
-		for (Map.Entry<String, List<GaoOrderReminderCustomer>> entry : storeCustomerMap.entrySet()) {
+		sendStoreReminders(storeEntryMap, reminderType.name());
-			sendStoreReminder(entry.getKey(), entry.getValue(), reminderType.name(), reminderType.label);
+	}
+
+	/// 合并同一门店下同一订单的多个提醒事项
+	///
+	/// @param storeEntryMap 门店提醒映射
+	/// @param customerList 订单提醒列表
+	/// @param action 待处理事项
+	private void mergeCustomers(Map<String, Map<String, ReminderEntry>> storeEntryMap,
+		List<GaoOrderReminderCustomer> customerList, String action) {
+		if (customerList == null || customerList.isEmpty()) {
+			return;
+		}
+		for (GaoOrderReminderCustomer customer : customerList) {
+			if (customer == null || isBlank(customer.getStoreId()) || isBlank(customer.getOrderId())) {
+				log.warn("GAO 订单提醒跳过无效订单数据: storeId[{}], customerId[{}], orderId[{}]",
+					customer == null ? null : customer.getStoreId(),
+					customer == null ? null : customer.getCustomerId(),
+					customer == null ? null : customer.getOrderId());
+				continue;
+			}
+			String entryKey = "%s:%s".formatted(customer.getCustomerId(), customer.getOrderId());
+			Map<String, ReminderEntry> entryMap = storeEntryMap.computeIfAbsent(customer.getStoreId(),
+				key -> new LinkedHashMap<>());
+			ReminderEntry entry = entryMap.computeIfAbsent(entryKey,
+				key -> new ReminderEntry(customer, new LinkedHashSet<>()));
+			entry.actionSet().add(action);
 		}
 	}
 
-	private void sendStoreReminder(String storeId, List<GaoOrderReminderCustomer> customerList, String reminderType,
+	/// 按门店发送提醒
-		String action) {
+	///
-		String customerNames = formatCustomerNames(customerList);
+	/// @param storeEntryMap 门店提醒映射
-		String content = "您的客户 %s 的订单需要 %s，请留意订单状态。".formatted(customerNames, action);
+	/// @param reminderType 提醒类型
+	private void sendStoreReminders(Map<String, Map<String, ReminderEntry>> storeEntryMap, String reminderType) {
+		for (Map.Entry<String, Map<String, ReminderEntry>> entry : storeEntryMap.entrySet()) {
+			sendStoreReminder(entry.getKey(), new ArrayList<>(entry.getValue().values()), reminderType);
+		}
+	}
+
+	/// 向门店店长发送订单提醒
+	///
+	/// @param storeId 门店 ID
+	/// @param entryList 订单提醒列表
+	/// @param reminderType 提醒类型
+	private void sendStoreReminder(String storeId, List<ReminderEntry> entryList, String reminderType) {
+		String customerNames = formatCustomerNames(entryList);
+		String action = entryList.stream()
+			.flatMap(entry -> entry.actionSet().stream())
+			.distinct()
+			.collect(Collectors.joining("、"));
+		String smsContent = "您的客户 %s 的订单需要 %s，请留意订单状态。".formatted(customerNames, action);
+		String internalContent = buildInternalContent(entryList);
+
 		List<GaoUser> managerList = gaoUserMapper.selectEnabledStoreManagers(storeId);
 		if (managerList == null || managerList.isEmpty()) {
 			log.warn("GAO 订单提醒未找到启用中的店长: storeId[{}], reminderType[{}]", storeId, reminderType);
@@ -103,35 +149,50 @@ public class GaoOrderReminderServiceImplement implements GaoOrderReminderService
 					log.warn("GAO 订单提醒跳过不存在的店长用户: storeId[{}], userId[{}]", storeId, manager.getUserId());
 					continue;
 				}
-				String remindedKey = "%s:%s:%s:%s".formatted(LocalDate.now(ZoneId.of(ZONE_ID)), storeId, manager.getUserId(), reminderType);
+				String remindedKey = "%s:%s:%s:%s".formatted(LocalDate.now(ZoneId.of(ZONE_ID)), storeId,
+					manager.getUserId(), reminderType);
 				long sendAt = Time.now();
 				Notify notify = new Notify();
 				notify.setBizType(NOTIFY_BIZ_TYPE);
 				notify.setBizRemindedType(reminderType);
 				notify.setBizRemindedKey(remindedKey);
 				notify.setDetailList(List.of(
-					createInternalDetail(manager.getUserId(), content, sendAt),
+					createInternalDetail(manager.getUserId(), internalContent, sendAt),
-					createSmsDetail(user.getPhoneNo(), customerNames, action, content, sendAt)
+					createSmsDetail(user.getPhoneNo(), customerNames, action, smsContent, sendAt)
 				));
 				notifyService.createIfAbsent(notify);
 			} catch (Exception e) {
-				log.error("GAO 订单提醒发送失败: storeId[{}], userId[{}], reminderType[{}]", storeId, manager.getUserId(), reminderType, e);
+				log.error("GAO 订单提醒发送失败: storeId[{}], userId[{}], reminderType[{}]", storeId,
+					manager.getUserId(), reminderType, e);
 			}
 		}
 	}
 
+	/// 创建站内通知详情
+	///
+	/// @param userId 接收用户 ID
+	/// @param content Tiptap HTML 正文
+	/// @param sendAt 发送时间
+	/// @return 通知详情
 	private NotifyDetail createInternalDetail(String userId, String content, long sendAt) {
 		NotifyDetail detail = new NotifyDetail();
 		detail.setMsgType(NotifyDetail.MsgType.INTERNAL);
-		detail.setTemplateId(SMS_TEMPLATE_ID);
 		detail.setSubject("订单状态提醒");
 		detail.setContent(content);
-		detail.setContentType(NotifyDetail.ContentType.TEXT);
+		detail.setContentType(NotifyDetail.ContentType.TIP_TAP);
 		detail.setSendTo(userId);
 		detail.setSendAt(sendAt);
 		return detail;
 	}
 
+	/// 创建短信通知详情
+	///
+	/// @param phoneNo 手机号
+	/// @param customerNames 客户名称摘要
+	/// @param action 待处理事项
+	/// @param content 短信正文
+	/// @param sendAt 发送时间
+	/// @return 通知详情
 	private NotifyDetail createSmsDetail(String phoneNo, String customerNames, String action, String content, long sendAt) {
 		NotifyDetail detail = new NotifyDetail();
 		detail.setMsgType(NotifyDetail.MsgType.SMS);
@@ -143,15 +204,159 @@ public class GaoOrderReminderServiceImplement implements GaoOrderReminderService
 		return detail;
 	}
 
-	private String formatCustomerNames(List<GaoOrderReminderCustomer> customerList) {
+	/// 使用 FreeMarker HTML 模板构建站内通知正文
-		List<String> nameList = customerList.stream()
+	///
-			.map(GaoOrderReminderCustomer::getCustomerName)
+	/// @param entryList 订单提醒列表
-			.map(name -> name == null || name.isBlank() ? "未知客户" : name.trim())
+	/// @return HTML 正文
-			.toList();
+	private String buildInternalContent(List<ReminderEntry> entryList) {
-		if (customerList.size() <= 2) {
+		Map<String, Object> model = new LinkedHashMap<>();
-			return String.join("、", nameList);
+		List<Map<String, Object>> customerModelList = new ArrayList<>();
+		Map<String, List<ReminderEntry>> customerEntryMap = entryList.stream()
+			.collect(Collectors.groupingBy(entry -> "%s:%s".formatted(entry.order().getCustomerId(), entry.order().getCustomerName()),
+				LinkedHashMap::new, Collectors.toList()));
+		for (List<ReminderEntry> customerEntryList : customerEntryMap.values()) {
+			GaoOrderReminderCustomer firstOrder = customerEntryList.getFirst().order();
+			Map<String, Object> customerModel = new LinkedHashMap<>();
+			customerModel.put("name", displayCustomerName(firstOrder.getCustomerName()));
+			customerModel.put("orderList", customerEntryList.stream()
+				.map(this::buildOrderTemplateModel)
+				.toList());
+			customerModelList.add(customerModel);
 		}
-		return "%s、%s等 %d 位".formatted(nameList.getFirst(), nameList.get(1), customerList.size());
+		model.put("customerList", customerModelList);
+		try {
+			Template template = freemarkerConfiguration.getTemplate(INTERNAL_TEMPLATE_NAME);
+			StringWriter writer = new StringWriter();
+			template.process(model, writer);
+			return writer.toString();
+		} catch (IOException | TemplateException e) {
+			throw new IllegalStateException("渲染 GAO 订单提醒站内信模板失败", e);
+		}
+	}
+
+	/// 构建 FreeMarker 订单模型
+	///
+	/// @param entry 订单提醒
+	/// @return 订单模板模型
+	private Map<String, Object> buildOrderTemplateModel(ReminderEntry entry) {
+		GaoOrderReminderCustomer order = entry.order();
+		Map<String, Object> orderModel = new LinkedHashMap<>();
+		orderModel.put("orderId", order.getOrderId());
+		orderModel.put("orderNo", textOrDefault(order.getOrderNo(), "未知订单"));
+		orderModel.put("orderStatus", orderStatusLabel(order.getOrderStatus()));
+		orderModel.put("paymentStatus", paymentStatusLabel(order.getPaymentStatus()));
+		orderModel.put("amountSummary", "成交 %s，已收 %s，待核销收款 %d 笔共 %s，未收 %s"
+			.formatted(formatMoney(order.getSaleAmount()), formatMoney(order.getPaidAmount()),
+				safeLong(order.getPendingReceiveCount()), formatMoney(receiveAmount(order)), formatMoney(order.getUnpaidAmount())));
+		orderModel.put("fulfillmentSummary", "待核销履约 %d 单，涉及 %d 项明细"
+			.formatted(safeLong(order.getPendingFulfillmentCount()), safeLong(order.getPendingFulfillmentItemCount())));
+		return orderModel;
+	}
+
+	/// 格式化短信中的客户名称
+	///
+	/// @param entryList 订单提醒列表
+	/// @return 客户名称摘要
+	private String formatCustomerNames(List<ReminderEntry> entryList) {
+		Map<String, String> nameMap = new LinkedHashMap<>();
+		for (ReminderEntry entry : entryList) {
+			GaoOrderReminderCustomer order = entry.order();
+			nameMap.putIfAbsent(order.getCustomerId(), displayCustomerName(order.getCustomerName()));
+		}
+		List<String> nameList = new ArrayList<>(nameMap.values());
+		int customerCount = nameList.size();
+		int displayCount = Math.min(customerCount, MAX_SMS_CUSTOMER_NAME_COUNT);
+		String customerNames = String.join("、", nameList.subList(0, displayCount));
+		if (MAX_SMS_CUSTOMER_NAME_COUNT < customerCount) {
+			String customerCountText = MAX_SMS_CUSTOMER_COUNT < customerCount
+				? "%d+".formatted(MAX_SMS_CUSTOMER_COUNT) : String.valueOf(customerCount);
+			return "%s等 %s 位客户".formatted(customerNames, customerCountText);
+		}
+		return customerNames;
+	}
+
+	/// 获取待核销收款金额
+	///
+	/// @param order 订单提醒
+	/// @return 待核销收款金额，单位分
+	private long receiveAmount(GaoOrderReminderCustomer order) {
+		return order.getPendingReceiveAmount() == null
+			? safeLong(order.getPendingPaidAmount()) : order.getPendingReceiveAmount();
+	}
+
+	/// 格式化金额
+	///
+	/// @param cents 金额，单位分
+	/// @return 金额文本
+	private String formatMoney(Long cents) {
+		return "¥" + BigDecimal.valueOf(safeLong(cents), 2).setScale(2).toPlainString();
+	}
+
+	/// 获取订单状态显示文本
+	///
+	/// @param status 订单状态
+	/// @return 显示文本
+	private String orderStatusLabel(GaoSalesOrder.Status status) {
+		if (status == null) {
+			return "未知";
+		}
+		return switch (status) {
+			case ACTIVE -> "进行中";
+			case FULFILLED -> "已全部履约";
+			case CANCELLED -> "已取消";
+		};
+	}
+
+	/// 获取付款状态显示文本
+	///
+	/// @param status 付款状态
+	/// @return 显示文本
+	private String paymentStatusLabel(GaoSalesOrder.PaymentStatus status) {
+		if (status == null) {
+			return "未知";
+		}
+		return switch (status) {
+			case UNPAID -> "未付款";
+			case PARTIALLY_PAID -> "部分付款";
+			case PAID -> "已付清";
+		};
+	}
+
+	/// 获取客户显示名称
+	///
+	/// @param name 客户名称
+	/// @return 客户显示名称
+	private String displayCustomerName(String name) {
+		return textOrDefault(name == null ? null : name.trim(), "未知客户");
+	}
+
+	/// 获取非空文本
+	///
+	/// @param value 原文本
+	/// @param defaultValue 默认文本
+	/// @return 非空文本
+	private String textOrDefault(String value, String defaultValue) {
+		return isBlank(value) ? defaultValue : value;
+	}
+
+	/// 判断文本为空
+	///
+	/// @param value 文本
+	/// @return true 为文本为空
+	private boolean isBlank(String value) {
+		return value == null || value.isBlank();
+	}
+
+	/// 获取安全长整数
+	///
+	/// @param value 原值
+	/// @return 非空数值
+	private long safeLong(Long value) {
+		return value == null ? 0L : value;
+	}
+
+	/// 订单提醒条目
+	private record ReminderEntry(GaoOrderReminderCustomer order, Set<String> actionSet) {
 	}
 
 	private enum ReminderType {

src/main/java/com/imyeyu/api/modules/gao/service/implement/GaoPointChartServiceImplement.java

@@ -0,0 +1,43 @@
+package com.imyeyu.api.modules.gao.service.implement;
+
+import com.imyeyu.api.modules.gao.mapper.GaoPointChartMapper;
+import com.imyeyu.api.modules.gao.service.GaoPointChartService;
+import com.imyeyu.api.modules.gao.vo.GaoPointDailyStatView;
+import com.imyeyu.api.modules.gao.vo.GaoPointRedemptionProductRankView;
+import com.imyeyu.api.modules.gao.vo.GaoStoreChartReq;
+import com.imyeyu.java.bean.timi.TimiException;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+
+/// 门店积分图表统计服务实现
+///
+/// @author Codex
+/// @since 2026-09-23
+@Service
+@RequiredArgsConstructor
+public class GaoPointChartServiceImplement implements GaoPointChartService {
+
+	private final GaoPointChartMapper mapper;
+
+	@Override
+	public List<GaoPointDailyStatView> dailyTrend(GaoStoreChartReq req) {
+		checkRangeReq(req);
+		return mapper.selectDailyTrend(req);
+	}
+
+	@Override
+	public List<GaoPointRedemptionProductRankView> redemptionProductRank(GaoStoreChartReq req) {
+		checkRangeReq(req);
+		return mapper.selectRedemptionProductRank(req);
+	}
+
+	private void checkRangeReq(GaoStoreChartReq req) {
+		TimiException.required(req, "积分图表请求不能为空");
+		TimiException.required(req.getStoreId(), "积分图表门店不能为空");
+		TimiException.required(req.getBeginAt(), "积分图表开始时间不能为空");
+		TimiException.required(req.getEndAt(), "积分图表结束时间不能为空");
+		TimiException.requiredTrue(req.getBeginAt() <= req.getEndAt(), "积分图表结束时间早于开始时间");
+	}
+}

src/main/java/com/imyeyu/api/modules/gao/service/implement/GaoProductServiceImplement.java

@@ -9,7 +9,9 @@ import com.imyeyu.api.modules.gao.entity.GaoProductSpec;
 import com.imyeyu.api.modules.gao.entity.GaoProductSpecValue;
 import com.imyeyu.api.modules.gao.entity.GaoProductSku;
 import com.imyeyu.api.modules.gao.entity.GaoProductStock;
+import com.imyeyu.api.modules.gao.entity.GaoProductSkuUnit;
 import com.imyeyu.api.modules.gao.mapper.GaoProductMapper;
+import com.imyeyu.api.modules.gao.mapper.GaoProductEditMapper;
 import com.imyeyu.api.modules.gao.mapper.GaoProductStockMapper;
 import com.imyeyu.api.modules.gao.service.GaoProductCategoryService;
 import com.imyeyu.api.modules.gao.service.GaoProductService;
@@ -17,6 +19,7 @@ import com.imyeyu.api.modules.gao.service.GaoProductSkuService;
 import com.imyeyu.api.modules.gao.service.GaoProductSpecService;
 import com.imyeyu.api.modules.gao.vo.GaoProductPage;
 import com.imyeyu.api.modules.system.audit.AuditOperation;
+import com.imyeyu.api.modules.system.audit.OperationAuditContext;
 import com.imyeyu.api.modules.system.audit.OperationAudit;
 import com.imyeyu.api.modules.user.service.UserLoginService;
 import com.imyeyu.api.util.PinyinUtil;
@@ -38,6 +41,7 @@ import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
+import java.util.Objects;
 import java.util.Set;
 import java.util.stream.Collectors;
 
@@ -50,6 +54,7 @@ import java.util.stream.Collectors;
 public class GaoProductServiceImplement extends AbstractEntityService<GaoProduct, String> implements GaoProductService {
 
 	private final GaoProductMapper mapper;
+	private final GaoProductEditMapper editMapper;
 	private final GaoProductStockMapper stockMapper;
 	private final AttachmentService attachmentService;
 	private final ObjectProvider<GaoProductCategoryService> categoryServiceProvider;
@@ -111,7 +116,7 @@ public class GaoProductServiceImplement extends AbstractEntityService<GaoProduct
 		super.create(product);
 		Map<String, String> specValueIdMap = saveSpecs(product, product.getSpecList());
 		normalizeSkuSpecValueIds(product.getSkuList(), specValueIdMap);
-		saveSkus(product, product.getSkuList());
+		saveSkus(product, product.getSkuList(), true);
 		attachmentService.updateByBizId(Attachment.BizType.GAO_PRODUCT, product.getId(), product.getAttachmentList());
 	}
 
@@ -123,6 +128,23 @@ public class GaoProductServiceImplement extends AbstractEntityService<GaoProduct
 		TimiException.required(request.getId(), "not found product.id");
 		GaoProduct product = get(request.getId());
 		TimiException.required(product, "not found product");
+		product = mapper.selectForUpdate(product.getId());
+		TimiException.required(product, "not found product");
+		String oldName = product.getName();
+		String storeId = product.getStoreId();
+		List<GaoProductSku> existingSkuList = skuServiceProvider.getObject().listByProductId(product.getId());
+		boolean hasHistory = editMapper.countProductReferences(product.getId()) > 0
+			|| existingSkuList.stream()
+				.anyMatch(item -> editMapper.countSkuReferences(item.getId()) > 0
+					|| stockMapper.selectByStoreIdAndSkuIdList(storeId, List.of(item.getId())).stream()
+						.anyMatch(stock -> isNonZero(stock.getOnHandQuantity()) || isNonZero(stock.getReservedQuantity())));
+		if (hasHistory && isHistoricalCorrectionOnly(product, request, existingSkuList)) {
+			OperationAuditContext.skipSuccessAudit();
+		}
+		if (hasHistory && (request.getProductType() != null && request.getProductType() != product.getProductType()
+			|| request.getStockEnabled() != null && !request.getStockEnabled().equals(product.getStockEnabled()))) {
+			throw new TimiException(TimiCode.ERROR, "产品已有历史业务记录，不能修改产品类型或库存管理属性");
+		}
 		if (request.getProductType() == GaoProduct.ProductType.SERVICE && product.getProductType() != GaoProduct.ProductType.SERVICE) {
 			verifyNoReservedStock(product);
 		}
@@ -138,13 +160,128 @@ public class GaoProductServiceImplement extends AbstractEntityService<GaoProduct
 		prepare(product, product.getId());
 		super.update(product);
 		if (request.getSkuList() != null) {
-			saveSkus(product, request.getSkuList());
+			saveSkus(product, request.getSkuList(), false);
+		}
+		if (!oldName.equals(product.getName())) {
+			editMapper.updateProductOrderSnapshots(product.getId(), product.getName());
+			editMapper.updateProductFulfillmentSnapshots(product.getId(), product.getName());
+			editMapper.updateProductStockRecordSnapshots(product.getId(), product.getName());
+			editMapper.updateProductPackageSnapshots(product.getId(), product.getName());
+			editMapper.updateProductRedemptionSnapshots(product.getId(), product.getName());
 		}
 		if (request.getAttachmentList() != null) {
 			attachmentService.updateByBizId(Attachment.BizType.GAO_PRODUCT, product.getId(), request.getAttachmentList());
 		}
 	}
 
+	private boolean isHistoricalCorrectionOnly(GaoProduct current, GaoProduct request, List<GaoProductSku> currentSkuList) {
+		if (!Objects.equals(current.getCategoryId(), request.getCategoryId())
+			|| TimiJava.defaultIfNull(request.getProductType(), current.getProductType()) != current.getProductType()
+			|| !Objects.equals(TimiJava.defaultIfNull(request.getStockEnabled(), current.getStockEnabled()), current.getStockEnabled())
+			|| TimiJava.defaultIfNull(request.getStatus(), current.getStatus()) != current.getStatus()
+			|| !Objects.equals(TimiJava.defaultIfNull(request.getSort(), current.getSort()), current.getSort())
+			|| !sameText(current.getRemark(), request.getRemark())) {
+			return false;
+		}
+		if (request.getAttachmentList() != null && !sameAttachmentList(
+			attachmentService.listByBizId(Attachment.BizType.GAO_PRODUCT, current.getId()), request.getAttachmentList())) {
+			return false;
+		}
+		if (request.getSkuList() == null) {
+			return true;
+		}
+		if (request.getSkuList().size() != currentSkuList.size()) {
+			return false;
+		}
+		Map<String, GaoProductSku> currentById = currentSkuList.stream()
+			.collect(Collectors.toMap(GaoProductSku::getId, item -> item));
+		Set<String> requestedIdSet = new HashSet<>();
+		for (GaoProductSku requested : request.getSkuList()) {
+			GaoProductSku existing = requested.getId() == null ? null : currentById.get(requested.getId());
+			if (existing == null || !requestedIdSet.add(requested.getId())
+				|| !isHistoricalSkuCorrectionOnly(existing, requested)) {
+				return false;
+			}
+		}
+		return true;
+	}
+
+	private boolean isHistoricalSkuCorrectionOnly(GaoProductSku current, GaoProductSku request) {
+		if (!Objects.equals(normalizeText(current.getBarcode()), normalizeText(request.getBarcode()))
+			|| !Objects.equals(TimiJava.defaultIfNull(request.getStockEnabled(), current.getStockEnabled()), current.getStockEnabled())
+			|| !Objects.equals(TimiJava.defaultIfNull(request.getAllowDecimalQuantity(), current.getAllowDecimalQuantity()), current.getAllowDecimalQuantity())
+			|| !Objects.equals(current.getMinStockQuantity(), request.getMinStockQuantity())
+			|| TimiJava.defaultIfNull(request.getStatus(), current.getStatus()) != current.getStatus()
+			|| !Objects.equals(TimiJava.defaultIfNull(request.getSort(), current.getSort()), current.getSort())
+			|| !sameText(current.getRemark(), request.getRemark())
+			|| request.getBaseUnitMigrationRequest() != null
+			|| request.getAttachmentList() != null && !sameAttachmentList(current.getAttachmentList(), request.getAttachmentList())) {
+			return false;
+		}
+		List<String> currentSpecValueIdList = current.getSpecValueIdList();
+		List<String> requestSpecValueIdList = request.getSpecValueIdList();
+		if (requestSpecValueIdList != null && !new HashSet<>(currentSpecValueIdList).equals(new HashSet<>(requestSpecValueIdList))) {
+			return false;
+		}
+		return request.getUnitList() == null || isHistoricalUnitNameCorrectionOnly(current.getUnitList(), request.getUnitList());
+	}
+
+	private boolean isHistoricalUnitNameCorrectionOnly(List<GaoProductSkuUnit> currentList, List<GaoProductSkuUnit> requestList) {
+		if (requestList.size() != currentList.size()) {
+			return false;
+		}
+		Map<String, GaoProductSkuUnit> currentById = currentList.stream()
+			.collect(Collectors.toMap(GaoProductSkuUnit::getId, item -> item));
+		Set<String> requestedIdSet = new HashSet<>();
+		for (GaoProductSkuUnit requested : requestList) {
+			GaoProductSkuUnit existing = requested.getId() == null ? null : currentById.get(requested.getId());
+			if (existing == null || !requestedIdSet.add(requested.getId())
+				|| !Objects.equals(existing.getBaseQuantityPerUnit(), requested.getBaseQuantityPerUnit())
+				|| !Objects.equals(existing.getSalePrice(), requested.getSalePrice())
+				|| !Objects.equals(existing.getIsBase(), requested.getIsBase())
+				|| !Objects.equals(existing.getAllowPurchase(), requested.getAllowPurchase())
+				|| !Objects.equals(existing.getAllowSale(), requested.getAllowSale())
+				|| !Objects.equals(existing.getSort(), requested.getSort())) {
+				return false;
+			}
+		}
+		return true;
+	}
+
+	private boolean sameAttachmentList(List<Attachment> currentList, List<Attachment> requestList) {
+		if (currentList == null || requestList == null || currentList.size() != requestList.size()) {
+			return false;
+		}
+		for (int index = 0; index < currentList.size(); index++) {
+			Attachment current = currentList.get(index);
+			Attachment requested = requestList.get(index);
+			if (!Objects.equals(current.getId(), requested.getId())
+				|| !Objects.equals(current.getBizType(), requested.getBizType())
+				|| !Objects.equals(current.getBizId(), requested.getBizId())
+				|| !Objects.equals(current.getAttachType(), requested.getAttachType())
+				|| !Objects.equals(current.getMongoId(), requested.getMongoId())
+				|| !Objects.equals(current.getTitle(), requested.getTitle())
+				|| !Objects.equals(current.getName(), requested.getName())
+				|| !Objects.equals(current.getMimeType(), requested.getMimeType())
+				|| !Objects.equals(current.getMetadata(), requested.getMetadata())
+				|| !Objects.equals(current.getSize(), requested.getSize())
+				|| !Objects.equals(current.getMd5(), requested.getMd5())
+				|| !Objects.equals(current.getIsDestroyed(), requested.getIsDestroyed())
+				|| !Objects.equals(current.getDestroyAt(), requested.getDestroyAt())) {
+				return false;
+			}
+		}
+		return true;
+	}
+
+	private boolean sameText(String current, String request) {
+		return Objects.equals(normalizeText(current), normalizeText(request));
+	}
+
+	private String normalizeText(String value) {
+		return value == null ? null : value.trim();
+	}
+
 	private void verifyNoReservedStock(GaoProduct product) {
 		List<String> skuIdList = skuServiceProvider.getObject().listByProductId(product.getId()).stream()
 			.map(GaoProductSku::getId)
@@ -158,6 +295,10 @@ public class GaoProductServiceImplement extends AbstractEntityService<GaoProduct
 		TimiException.requiredTrue(!hasReservedStock, "当前产品存在预占库存，不能切换为服务产品，请先完成或取消相关订单");
 	}
 
+	private boolean isNonZero(BigDecimal value) {
+		return value != null && BigDecimal.ZERO.compareTo(value) != 0;
+	}
+
 	@OperationAudit(AuditOperation.GAO_PRODUCT_DISABLE)
 	@Transactional(TimiServerDBConfig.ROLLBACKER)
 	@Override
@@ -177,8 +318,17 @@ public class GaoProductServiceImplement extends AbstractEntityService<GaoProduct
 	}
 
 	@Override
+	@Transactional(TimiServerDBConfig.ROLLBACKER)
 	public void destroy(String id) {
-		throw new TimiException(TimiCode.ERROR, "已建立产品库的产品不允许物理删除");
+		GaoProduct product = mapper.selectForUpdate(id);
+		TimiException.required(product, "not found product");
+		TimiException.requiredTrue(editMapper.countProductReferences(id) == 0, "产品存在历史业务记录，不能物理移除");
+		for (GaoProductSku sku : skuServiceProvider.getObject().listByProductId(id)) {
+			skuServiceProvider.getObject().destroy(sku.getId());
+		}
+		specServiceProvider.getObject().destroyByProductId(id);
+		attachmentService.updateByBizId(Attachment.BizType.GAO_PRODUCT, id, List.of());
+		super.destroy(id);
 	}
 
 	private void prepare(GaoProduct product, String excludeId) {
@@ -201,18 +351,35 @@ public class GaoProductServiceImplement extends AbstractEntityService<GaoProduct
 		product.setUpdatedBy(userLoginService.getRequireLoginUserId());
 	}
 
-	private void saveSkus(GaoProduct product, List<com.imyeyu.api.modules.gao.entity.GaoProductSku> skuList) {
+	private void saveSkus(GaoProduct product, List<com.imyeyu.api.modules.gao.entity.GaoProductSku> skuList, boolean createDefault) {
 		List<com.imyeyu.api.modules.gao.entity.GaoProductSku> sourceList = skuList;
-		if (sourceList == null || sourceList.isEmpty()) {
+		if ((sourceList == null || sourceList.isEmpty()) && createDefault) {
 			com.imyeyu.api.modules.gao.entity.GaoProductSku sku = new com.imyeyu.api.modules.gao.entity.GaoProductSku();
 			sku.setProductId(product.getId()); sku.setCode(product.getCode()); sku.setName(product.getName());
 			com.imyeyu.api.modules.gao.entity.GaoProductSkuUnit unit = new com.imyeyu.api.modules.gao.entity.GaoProductSkuUnit();
 			unit.setName("件"); unit.setIsBase(true); unit.setBaseQuantityPerUnit(BigDecimal.ONE);
 			sku.setUnitList(List.of(unit)); sourceList = List.of(sku);
+		} else if (sourceList == null) {
+			sourceList = List.of();
 		}
+		List<com.imyeyu.api.modules.gao.entity.GaoProductSku> existingList = skuServiceProvider.getObject().listByProductId(product.getId());
+		Map<String, com.imyeyu.api.modules.gao.entity.GaoProductSku> existingById = existingList.stream()
+			.collect(Collectors.toMap(com.imyeyu.api.modules.gao.entity.GaoProductSku::getId, item -> item));
+		Set<String> retainedIdSet = new HashSet<>();
 		for (com.imyeyu.api.modules.gao.entity.GaoProductSku source : sourceList) {
 			source.setProductId(product.getId());
-			if (source.getId() == null) skuServiceProvider.getObject().create(source); else skuServiceProvider.getObject().update(source);
+			if (source.getId() == null) {
+				skuServiceProvider.getObject().create(source);
+			} else {
+				TimiException.required(existingById.get(source.getId()), "SKU 不存在或不属于当前产品");
+				retainedIdSet.add(source.getId());
+				skuServiceProvider.getObject().update(source);
+			}
+		}
+		for (com.imyeyu.api.modules.gao.entity.GaoProductSku existing : existingList) {
+			if (!retainedIdSet.contains(existing.getId())) {
+				skuServiceProvider.getObject().destroy(existing.getId());
+			}
 		}
 	}
 

src/main/java/com/imyeyu/api/modules/gao/service/implement/GaoProductSkuServiceImplement.java

@@ -11,16 +11,22 @@ import com.imyeyu.api.modules.gao.entity.GaoProduct;
 import com.imyeyu.api.modules.gao.entity.GaoProductSku;
 import com.imyeyu.api.modules.gao.entity.GaoProductSkuSpecValue;
 import com.imyeyu.api.modules.gao.entity.GaoProductSkuUnit;
+import com.imyeyu.api.modules.gao.entity.GaoProductStock;
 import com.imyeyu.api.modules.gao.entity.GaoProductSpec;
 import com.imyeyu.api.modules.gao.entity.GaoProductSpecValue;
 import com.imyeyu.api.modules.gao.mapper.GaoProductSkuMapper;
+import com.imyeyu.api.modules.gao.mapper.GaoProductEditMapper;
+import com.imyeyu.api.modules.gao.mapper.GaoProductStockMapper;
 import com.imyeyu.api.modules.gao.mapper.GaoProductSkuSpecValueMapper;
 import com.imyeyu.api.modules.gao.mapper.GaoProductSkuUnitMapper;
 import com.imyeyu.api.modules.gao.mapper.GaoProductSpecMapper;
 import com.imyeyu.api.modules.gao.mapper.GaoProductSpecValueMapper;
 import com.imyeyu.api.modules.gao.service.GaoProductService;
 import com.imyeyu.api.modules.gao.service.GaoProductSkuService;
+import com.imyeyu.api.modules.gao.vo.GaoProductSkuBaseUnitMigrationRequest;
 import com.imyeyu.api.modules.gao.vo.GaoProductSkuUnitSelection;
+import com.imyeyu.api.modules.system.entity.Logger;
+import com.imyeyu.api.modules.system.service.LoggerService;
 import com.imyeyu.api.modules.user.service.UserLoginService;
 import com.imyeyu.java.TimiJava;
 import com.imyeyu.java.bean.timi.TimiCode;
@@ -55,11 +61,14 @@ public class GaoProductSkuServiceImplement extends AbstractEntityService<GaoProd
 	private static final BigDecimal ONE = BigDecimal.ONE;
 
 	private final GaoProductSkuMapper mapper;
+	private final GaoProductEditMapper editMapper;
+	private final GaoProductStockMapper stockMapper;
 	private final GaoProductSkuUnitMapper unitMapper;
 	private final GaoProductSkuSpecValueMapper skuSpecValueMapper;
 	private final GaoProductSpecMapper specMapper;
 	private final GaoProductSpecValueMapper valueMapper;
 	private final AttachmentService attachmentService;
+	private final LoggerService loggerService;
 	private final ObjectProvider<GaoProductService> productServiceProvider;
 	private final UserLoginService userLoginService;
 
@@ -190,6 +199,19 @@ public class GaoProductSkuServiceImplement extends AbstractEntityService<GaoProd
 		return result;
 	}
 
+	@Transactional(TimiServerDBConfig.ROLLBACKER)
+	@Override
+	public void refreshSpecHistorySnapshots(String productId) {
+		TimiException.required(productId, "not found productId");
+		for (GaoProductSku sku : mapper.selectByProductId(productId)) {
+			JsonNode snapshot = getSkuSpecSnapshot(sku);
+			editMapper.updateSkuOrderSnapshots(sku.getId(), sku.getCode(), sku.getName(), sku.getSpecSummary(), snapshot);
+			editMapper.updateSkuFulfillmentSnapshots(sku.getId(), sku.getCode(), sku.getName(), sku.getSpecSummary(), snapshot);
+			editMapper.updateSkuStockRecordSnapshots(sku.getId(), sku.getCode(), sku.getName(), sku.getSpecSummary(), snapshot);
+			editMapper.updateSkuRedemptionSnapshots(sku.getId(), sku.getCode(), sku.getName(), snapshot);
+		}
+	}
+
 	@Transactional(TimiServerDBConfig.ROLLBACKER)
 	@Override
 	public void create(GaoProductSku sku) {
@@ -205,8 +227,32 @@ public class GaoProductSkuServiceImplement extends AbstractEntityService<GaoProd
 	public void update(GaoProductSku request) {
 		TimiException.required(request, "not found product sku");
 		TimiException.required(request.getId(), "not found product sku.id");
-		GaoProductSku sku = get(request.getId());
+		GaoProductSku sku = mapper.selectForUpdate(request.getId());
 		TimiException.required(sku, "not found product sku");
+		List<GaoProductSkuUnit> existingUnitList = unitMapper.selectBySkuId(sku.getId());
+		int referenceCount = editMapper.countSkuReferences(sku.getId());
+		List<String> existingSpecValueIds = currentSpecValueIds(sku.getId());
+		if (referenceCount > 0 && request.getSpecValueIdList() != null
+			&& !new HashSet<>(existingSpecValueIds).equals(new HashSet<>(request.getSpecValueIdList()))) {
+			throw new TimiException(TimiCode.ERROR, "SKU 已有历史业务记录，不能更换规格组合；请新建 SKU");
+		}
+		if (referenceCount > 0 && request.getStockEnabled() != null && !request.getStockEnabled().equals(sku.getStockEnabled())) {
+			throw new TimiException(TimiCode.ERROR, "SKU 已有历史业务记录，不能修改库存管理属性");
+		}
+		GaoProductSkuUnit oldBaseUnit = existingUnitList.stream().filter(unit -> Boolean.TRUE.equals(unit.getIsBase())).findFirst().orElseThrow();
+		List<GaoProductSkuUnit> requestedUnitList = request.getUnitList() == null ? existingUnitList : request.getUnitList();
+		GaoProductSkuUnit requestedBaseUnit = requestedUnitList.stream().filter(unit -> Boolean.TRUE.equals(unit.getIsBase())).findFirst().orElse(null);
+		boolean baseUnitChanged = requestedBaseUnit == null || !oldBaseUnit.getId().equals(requestedBaseUnit.getId());
+		GaoProductSkuBaseUnitMigrationRequest migrationRequest = request.getBaseUnitMigrationRequest();
+		BigDecimal migrationRatio = null;
+		if (baseUnitChanged) {
+			migrationRatio = validateBaseUnitMigration(oldBaseUnit, requestedBaseUnit, migrationRequest, sku.getId());
+		} else if (migrationRequest != null) {
+			throw new TimiException(TimiCode.ERROR, "新旧基础单位相同，不需要提交基础单位迁移比例");
+		}
+		if (request.getUnitList() != null && !baseUnitChanged) {
+			validateUnitConversionUnchanged(request.getUnitList(), existingUnitList);
+		}
 		sku.setCode(TimiJava.defaultIfNull(request.getCode(), sku.getCode()));
 		sku.setBarcode(request.getBarcode());
 		sku.setName(TimiJava.defaultIfNull(request.getName(), sku.getName()));
@@ -218,18 +264,49 @@ public class GaoProductSkuServiceImplement extends AbstractEntityService<GaoProd
 		sku.setSort(TimiJava.defaultIfNull(request.getSort(), sku.getSort()));
 		sku.setRemark(request.getRemark());
 		sku.setSpecValueIdList(request.getSpecValueIdList() == null ? currentSpecValueIds(sku.getId()) : request.getSpecValueIdList());
-		sku.setUnitList(request.getUnitList() == null ? unitMapper.selectBySkuId(sku.getId()) : request.getUnitList());
+		sku.setUnitList(requestedUnitList);
+		if (migrationRatio != null) {
+			applyBaseUnitMigration(sku, oldBaseUnit, requestedBaseUnit, existingUnitList, migrationRequest, migrationRatio);
+			stockMapper.selectForUpdate(sku.getStoreId(), sku.getId());
+			if (editMapper.countMigrationPrecisionLoss(sku.getId(), requestedBaseUnit.getId(), migrationRatio) > 0) {
+				throw new TimiException(TimiCode.ERROR, "基础单位迁移会产生超出字段精度的数量，未执行任何变更");
+			}
+			editMapper.scaleSkuMinimumStock(sku.getId(), migrationRatio);
+			editMapper.scaleProductStock(sku.getId(), migrationRatio);
+			editMapper.scaleSalesOrderItems(sku.getId(), migrationRatio);
+			editMapper.scaleFulfillmentItems(sku.getId(), migrationRatio);
+			editMapper.scaleStockRecords(sku.getId(), migrationRatio);
+			editMapper.scalePackageConfigItems(sku.getId(), migrationRatio);
+			editMapper.scalePointRedemptions(sku.getId(), migrationRatio);
+			editMapper.scalePointRedemptionReturns(sku.getId(), migrationRatio);
+		}
 		prepare(sku, sku.getId());
 		super.update(sku);
 		if (request.getSpecValueIdList() != null) {
 			saveSpecValues(sku.getId(), sku.getSpecValueIdList());
 		}
 		if (request.getUnitList() != null) {
-			saveUnits(sku.getId(), sku.getUnitList(), unitMapper.selectBySkuId(sku.getId()));
+			saveUnits(sku.getId(), sku.getUnitList(), existingUnitList);
 		}
 		if (request.getAttachmentList() != null) {
 			attachmentService.updateByBizId(Attachment.BizType.GAO_PRODUCT_SKU, sku.getId(), request.getAttachmentList());
 		}
+		JsonNode skuSpecSnapshot = getSkuSpecSnapshot(sku);
+		editMapper.updateSkuOrderSnapshots(sku.getId(), sku.getCode(), sku.getName(), sku.getSpecSummary(), skuSpecSnapshot);
+		editMapper.updateSkuFulfillmentSnapshots(sku.getId(), sku.getCode(), sku.getName(), sku.getSpecSummary(), skuSpecSnapshot);
+		editMapper.updateSkuStockRecordSnapshots(sku.getId(), sku.getCode(), sku.getName(), sku.getSpecSummary(), skuSpecSnapshot);
+		editMapper.updateSkuPackageSnapshots(sku.getId(), sku.getCode(), sku.getName(), sku.getSpecSummary());
+		editMapper.updateSkuRedemptionSnapshots(sku.getId(), sku.getCode(), sku.getName(), skuSpecSnapshot);
+		if (migrationRatio != null) {
+			GaoProductSkuUnit migratedTarget = unitMapper.selectBySkuId(sku.getId()).stream()
+				.filter(unit -> unit.getIsBase() && unit.getName().equals(requestedBaseUnit.getName().trim()))
+				.findFirst().orElseThrow();
+			Logger migrationLog = new Logger(Logger.Module.GAO, Logger.Level.INFO, "GAO_PRODUCT_SKU_BASE_UNIT_MIGRATION");
+			migrationLog.setContent("skuId=%s;oldBaseUnitId=%s;oldBaseUnitName=%s;newBaseUnitId=%s;newBaseUnitName=%s;oldToNewBaseRatio=%s".formatted(
+				sku.getId(), oldBaseUnit.getId(), oldBaseUnit.getName(), migratedTarget.getId(), migratedTarget.getName(), migrationRatio.toPlainString()));
+			migrationLog.setResult(sku.getId());
+			loggerService.createSync(migrationLog);
+		}
 	}
 
 	@Transactional(TimiServerDBConfig.ROLLBACKER)
@@ -249,8 +326,24 @@ public class GaoProductSkuServiceImplement extends AbstractEntityService<GaoProd
 	}
 
 	@Override
+	@Transactional(TimiServerDBConfig.ROLLBACKER)
 	public void destroy(String id) {
-		throw new TimiException(TimiCode.ERROR, "已建立 SKU 的产品不允许物理删除");
+		GaoProductSku sku = mapper.selectForUpdate(id);
+		TimiException.required(sku, "not found product sku");
+		TimiException.requiredTrue(editMapper.countSkuReferences(id) == 0, "SKU 存在历史业务记录，不能物理移除");
+		List<GaoProductStock> stockList = stockMapper.selectByStoreIdAndSkuIdList(sku.getStoreId(), List.of(id));
+		TimiException.requiredTrue(stockList.stream().allMatch(stock -> isZero(stock.getOnHandQuantity()) && isZero(stock.getReservedQuantity())),
+			"SKU 存在库存或预占库存，不能物理移除");
+		for (GaoProductSkuUnit unit : unitMapper.selectBySkuId(id)) {
+			TimiException.requiredTrue(editMapper.countUnitReferences(unit.getId()) == 0, "SKU 单位存在历史业务引用，不能物理移除 SKU");
+			unitMapper.destroy(unit.getId());
+		}
+		skuSpecValueMapper.deleteBySkuId(id);
+		for (GaoProductStock stock : stockList) {
+			stockMapper.destroy(stock.getId());
+		}
+		attachmentService.updateByBizId(Attachment.BizType.GAO_PRODUCT_SKU, id, List.of());
+		super.destroy(id);
 	}
 
 	private void prepare(GaoProductSku sku, String excludeId) {
@@ -326,6 +419,7 @@ public class GaoProductSkuServiceImplement extends AbstractEntityService<GaoProd
 			unit.setBaseQuantityPerUnit(TimiJava.defaultIfNull(source.getBaseQuantityPerUnit(), ONE));
 			TimiException.requiredTrue(0 < unit.getBaseQuantityPerUnit().signum(), "基础单位数量系数必须大于 0");
 			TimiException.requiredTrue(6 >= unit.getBaseQuantityPerUnit().scale(), "基础单位数量系数最多保留六位小数");
+			TimiException.requiredTrue(12 >= unit.getBaseQuantityPerUnit().precision() - unit.getBaseQuantityPerUnit().scale(), "基础单位数量系数超出最大值");
 			if (source.getSalePrice() != null) {
 				TimiException.requiredTrue(0 <= source.getSalePrice(), "单位建议售价不能为负数");
 			}
@@ -345,6 +439,69 @@ public class GaoProductSkuServiceImplement extends AbstractEntityService<GaoProd
 		return result;
 	}
 
+	private BigDecimal validateBaseUnitMigration(GaoProductSkuUnit oldBaseUnit, GaoProductSkuUnit newBaseUnit,
+												 GaoProductSkuBaseUnitMigrationRequest request, String skuId) {
+		TimiException.required(request, "切换基础单位时必须提交新旧基础单位换算比例");
+		TimiException.required(newBaseUnit, "SKU 必须指定新的基础单位");
+		TimiException.requiredTrue(newBaseUnit.getIsBase(), "迁移目标必须是新的基础单位");
+		TimiException.required(newBaseUnit.getName(), "新基础单位名称不能为空");
+		boolean targetMatches = request.getTargetUnitId() != null && !request.getTargetUnitId().isBlank()
+			? request.getTargetUnitId().equals(newBaseUnit.getId())
+			: request.getTargetUnitName() != null && request.getTargetUnitName().trim().equals(newBaseUnit.getName().trim());
+		TimiException.requiredTrue(targetMatches, "基础单位迁移目标与 SKU 单位列表不一致");
+		BigDecimal ratio = request.getOldToNewBaseRatio();
+		TimiException.required(ratio, "基础单位迁移比例不能为空");
+		TimiException.requiredTrue(0 < ratio.signum(), "基础单位迁移比例必须大于 0");
+		TimiException.requiredTrue(6 >= ratio.scale(), "基础单位迁移比例最多保留六位小数");
+		TimiException.requiredTrue(12 >= ratio.precision() - ratio.scale(), "基础单位迁移比例超出最大值");
+		return ratio;
+	}
+
+	private void applyBaseUnitMigration(GaoProductSku sku, GaoProductSkuUnit oldBaseUnit,
+										 GaoProductSkuUnit newBaseUnit, List<GaoProductSkuUnit> existingUnitList,
+										 GaoProductSkuBaseUnitMigrationRequest request, BigDecimal ratio) {
+		Map<String, GaoProductSkuUnit> existingById = existingUnitList.stream()
+			.collect(Collectors.toMap(GaoProductSkuUnit::getId, item -> item));
+		for (GaoProductSkuUnit unit : sku.getUnitList()) {
+			boolean target = newBaseUnit.getId() != null
+				? newBaseUnit.getId().equals(unit.getId())
+				: newBaseUnit.getName().trim().equals(unit.getName().trim());
+			if (target) {
+				unit.setBaseQuantityPerUnit(ONE);
+				continue;
+			}
+			GaoProductSkuUnit existing = unit.getId() == null ? null : existingById.get(unit.getId());
+			BigDecimal oldFactor = existing == null
+				? TimiJava.defaultIfNull(unit.getBaseQuantityPerUnit(), ONE)
+				: existing.getBaseQuantityPerUnit();
+			BigDecimal newFactor = oldFactor.multiply(ratio).stripTrailingZeros();
+			TimiException.requiredTrue(6 >= Math.max(newFactor.scale(), 0), "单位换算系数迁移后超过六位小数，请调整换算比例");
+			unit.setBaseQuantityPerUnit(newFactor);
+		}
+		if (sku.getMinStockQuantity() != null) {
+			BigDecimal migratedMinimumStock = sku.getMinStockQuantity().multiply(ratio).stripTrailingZeros();
+			TimiException.requiredTrue(3 >= Math.max(migratedMinimumStock.scale(), 0), "最低库存迁移后超过三位小数，请调整换算比例");
+			sku.setMinStockQuantity(migratedMinimumStock);
+		}
+	}
+
+	private void validateUnitConversionUnchanged(List<GaoProductSkuUnit> requestedUnitList,
+												 List<GaoProductSkuUnit> existingUnitList) {
+		Map<String, GaoProductSkuUnit> existingById = existingUnitList.stream()
+			.collect(Collectors.toMap(GaoProductSkuUnit::getId, item -> item));
+		for (GaoProductSkuUnit requested : requestedUnitList) {
+			GaoProductSkuUnit existing = requested.getId() == null ? null : existingById.get(requested.getId());
+			BigDecimal requestedFactor = TimiJava.defaultIfNull(requested.getBaseQuantityPerUnit(), ONE);
+			if (existing != null && existing.getBaseQuantityPerUnit().compareTo(requestedFactor) != 0) {
+				throw new TimiException(TimiCode.ERROR, "已保存单位的换算系数不能直接修改；切换基础单位时请提交迁移比例");
+			}
+		}
+	}
+
+	private boolean isZero(BigDecimal value) {
+		return value == null || BigDecimal.ZERO.compareTo(value) == 0;
+	}
+
 	private void saveUnits(String skuId, List<GaoProductSkuUnit> unitList, List<GaoProductSkuUnit> existingUnitList) {
 		Map<String, GaoProductSkuUnit> existingById = existingUnitList.stream().collect(Collectors.toMap(GaoProductSkuUnit::getId, item -> item));
 		Set<String> retainedIdSet = new HashSet<>();
@@ -368,10 +525,21 @@ public class GaoProductSkuServiceImplement extends AbstractEntityService<GaoProd
 			} else {
 				retainedIdSet.add(existing.getId());
 				TimiException.requiredTrue(1 == unitMapper.updateUnit(unit), "SKU 单位更新失败");
+				if (!existing.getName().equals(unit.getName())) {
+					editMapper.updateUnitOrderSnapshots(existing.getId(), unit.getName());
+					editMapper.updateUnitFulfillmentSnapshots(existing.getId(), unit.getName());
+					editMapper.updateUnitStockRecordSnapshots(existing.getId(), unit.getName());
+					editMapper.updateUnitPackageSnapshots(existing.getId(), unit.getName());
+					editMapper.updateUnitRedemptionSnapshots(existing.getId(), unit.getName());
+				}
+			}
+		}
+		for (GaoProductSkuUnit existing : existingUnitList) {
+			if (!retainedIdSet.contains(existing.getId())) {
+				TimiException.requiredTrue(editMapper.countUnitReferences(existing.getId()) == 0, "SKU 单位存在历史业务引用，不能物理移除");
+				unitMapper.destroy(existing.getId());
 			}
 		}
-		TimiException.requiredTrue(existingUnitList.stream().allMatch(existing -> retainedIdSet.contains(existing.getId())),
-			"已保存的 SKU 单位不能删除，请关闭允许销售和允许采购");
 	}
 
 	private void saveSpecValues(String skuId, List<String> specValueIdList) {

src/main/java/com/imyeyu/api/modules/gao/service/implement/GaoProductSpecServiceImplement.java

@@ -1,5 +1,6 @@
 package com.imyeyu.api.modules.gao.service.implement;
 
+import com.imyeyu.api.config.dbsource.TimiServerDBConfig;
 import com.imyeyu.api.modules.gao.entity.GaoProduct;
 import com.imyeyu.api.modules.gao.entity.GaoProductSpec;
 import com.imyeyu.api.modules.gao.entity.GaoProductSpecValue;
@@ -7,10 +8,13 @@ import com.imyeyu.api.modules.gao.mapper.GaoProductSpecMapper;
 import com.imyeyu.api.modules.gao.mapper.GaoProductSpecValueMapper;
 import com.imyeyu.api.modules.gao.service.GaoProductService;
 import com.imyeyu.api.modules.gao.service.GaoProductSpecService;
+import com.imyeyu.api.modules.gao.service.GaoProductSkuService;
 import com.imyeyu.java.TimiJava;
 import com.imyeyu.java.bean.timi.TimiException;
 import lombok.RequiredArgsConstructor;
+import org.springframework.beans.factory.ObjectProvider;
 import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
 
 import java.util.List;
 import java.util.Map;
@@ -27,6 +31,7 @@ public class GaoProductSpecServiceImplement implements GaoProductSpecService {
 	private final GaoProductSpecMapper specMapper;
 	private final GaoProductSpecValueMapper valueMapper;
 	private final GaoProductService productService;
+	private final ObjectProvider<GaoProductSkuService> skuServiceProvider;
 
 	@Override
 	public List<GaoProductSpec> listByProductId(String productId) {
@@ -41,6 +46,12 @@ public class GaoProductSpecServiceImplement implements GaoProductSpecService {
 		return specMapper.selectProductIdBySpecId(specId);
 	}
 
+	@Override
+	public String getProductIdBySpecValueId(String specValueId) {
+		GaoProductSpecValue value = valueMapper.selectById(specValueId);
+		return value == null ? null : specMapper.selectProductIdBySpecId(value.getSpecId());
+	}
+
 	@Override
 	public void createSpec(GaoProductSpec spec) {
 		TimiException.required(spec, "not found product spec");
@@ -51,6 +62,28 @@ public class GaoProductSpecServiceImplement implements GaoProductSpecService {
 		specMapper.insert(spec);
 	}
 
+	@Transactional(TimiServerDBConfig.ROLLBACKER)
+	@Override
+	public void updateSpec(GaoProductSpec request) {
+		TimiException.required(request, "not found product spec");
+		TimiException.required(request.getId(), "not found product spec.id");
+		String productId = specMapper.selectProductIdBySpecId(request.getId());
+		TimiException.required(productId, "产品规格不存在");
+		GaoProductSpec existing = specMapper.selectByProductId(productId).stream()
+			.filter(item -> item.getId().equals(request.getId())).findFirst().orElseThrow();
+		String name = requiredText(request.getName(), "规格名称不能为空");
+		Integer sort = TimiJava.defaultIfNull(request.getSort(), existing.getSort());
+		if (existing.getName().equals(name) && existing.getSort().equals(sort)) {
+			return;
+		}
+		GaoProductSpec spec = new GaoProductSpec();
+		spec.setId(request.getId());
+		spec.setName(name);
+		spec.setSort(sort);
+		TimiException.requiredTrue(1 == specMapper.updateSpec(spec), "产品规格更新失败");
+		skuServiceProvider.getObject().refreshSpecHistorySnapshots(productId);
+	}
+
 	@Override
 	public void createValue(GaoProductSpecValue value) {
 		TimiException.required(value, "not found product spec value");
@@ -61,5 +94,40 @@ public class GaoProductSpecServiceImplement implements GaoProductSpecService {
 		valueMapper.insert(value);
 	}
 
+	@Transactional(TimiServerDBConfig.ROLLBACKER)
+	@Override
+	public void updateValue(GaoProductSpecValue request) {
+		TimiException.required(request, "not found product spec value");
+		TimiException.required(request.getId(), "not found product spec value.id");
+		GaoProductSpecValue existing = valueMapper.selectById(request.getId());
+		TimiException.required(existing, "产品规格值不存在");
+		String productId = specMapper.selectProductIdBySpecId(existing.getSpecId());
+		TimiException.required(productId, "产品规格不存在");
+		String name = requiredText(request.getName(), "规格值名称不能为空");
+		Integer sort = TimiJava.defaultIfNull(request.getSort(), existing.getSort());
+		if (existing.getName().equals(name) && existing.getSort().equals(sort)) {
+			return;
+		}
+		GaoProductSpecValue value = new GaoProductSpecValue();
+		value.setId(existing.getId());
+		value.setSpecId(existing.getSpecId());
+		value.setName(name);
+		value.setSort(sort);
+		TimiException.requiredTrue(1 == valueMapper.updateValue(value), "产品规格值更新失败");
+		skuServiceProvider.getObject().refreshSpecHistorySnapshots(productId);
+	}
+
+	@Override
+	public void destroyByProductId(String productId) {
+		List<GaoProductSpec> specList = specMapper.selectByProductId(productId);
+		List<String> specIdList = specList.stream().map(GaoProductSpec::getId).toList();
+		for (GaoProductSpecValue value : valueMapper.selectBySpecIdList(specIdList)) {
+			valueMapper.destroy(value.getId());
+		}
+		for (GaoProductSpec spec : specList) {
+			specMapper.destroy(spec.getId());
+		}
+	}
+
 	private String requiredText(String value, String message) { TimiException.required(value, message); String result = value.trim(); TimiException.requiredTrue(!result.isEmpty(), message); return result; }
 }

src/main/java/com/imyeyu/api/modules/gao/service/implement/GaoProductStockRecordServiceImplement.java

@@ -12,6 +12,7 @@ import com.imyeyu.api.modules.gao.service.GaoProductStockRecordService;
 import com.imyeyu.api.modules.gao.vo.GaoProductStockRecordPage;
 import com.imyeyu.api.modules.user.entity.User;
 import com.imyeyu.api.modules.user.service.UserService;
+import com.imyeyu.java.TimiJava;
 import com.imyeyu.java.bean.timi.TimiCode;
 import com.imyeyu.java.bean.timi.TimiException;
 import com.imyeyu.spring.bean.PageResult;
@@ -166,7 +167,11 @@ public class GaoProductStockRecordServiceImplement extends AbstractEntityService
 				operator.setAttachmentList(userAvatarMap.getOrDefault(operator.getId(), List.of()));
 			}
 			record.setOperator(operator);
-			GaoCustomer customer = customerMap.get(getCustomerId(record, fulfillmentMap));
+			String customerId = getCustomerId(record, fulfillmentMap);
+			if (TimiJava.isEmpty(customerId)) {
+				continue;
+			}
+			GaoCustomer customer = customerMap.get(customerId);
 			if (customer != null) {
 				customer.setAttachmentList(customerPhotoMap.getOrDefault(customer.getId(), List.of()));
 			}

src/main/java/com/imyeyu/api/modules/gao/service/implement/GaoProductStockServiceImplement.java

@@ -232,6 +232,14 @@ public class GaoProductStockServiceImplement implements GaoProductStockService {
 		return executeInternal(storeId, bizId, items, requestNo, operatorUserId, GaoProductStockRecord.OperationType.ORDER_OUT, null);
 	}
 
+	@Override
+	@Transactional(TimiServerDBConfig.ROLLBACKER)
+	public List<GaoProductStock> outForFulfillment(String storeId, String bizId, List<GaoStockChangeItem> items, String requestNo,
+		String operatorUserId, List<Attachment> attachmentList) {
+		return executeInternal(storeId, bizId, items, requestNo, operatorUserId,
+			GaoProductStockRecord.OperationType.ORDER_OUT, null, null, attachmentList);
+	}
+
 	@Override
 	@Transactional(TimiServerDBConfig.ROLLBACKER)
 	public List<GaoProductStock> revokeForFulfillment(String storeId, String bizId, List<GaoStockChangeItem> items, String requestNo, String operatorUserId) {
@@ -445,7 +453,11 @@ public class GaoProductStockServiceImplement implements GaoProductStockService {
 			record.setOperatorUserId(operatorUserId);
 			record.setOccurredAt(TimiJava.defaultIfNull(occurredAt, Time.now()));
 			record.setRemark(remark);
-			recordService.createOperationRecord(record, attachmentList);
+			recordService.createOperationRecord(record,
+				operationType == GaoProductStockRecord.OperationType.ORDER_OUT ? null : attachmentList);
+			if (operationType == GaoProductStockRecord.OperationType.ORDER_OUT) {
+				copyAttachments(record.getId(), attachmentList);
+			}
 			stock.setOnHandQuantity(onHandAfter);
 			stock.setReservedQuantity(reservedAfter);
 			stock.setUpdatedBy(operatorUserId);
@@ -455,6 +467,23 @@ public class GaoProductStockServiceImplement implements GaoProductStockService {
 		return result;
 	}
 
+	/// 复制履约附件到出库流水
+	///
+	/// @param recordId 出库流水 ID
+	/// @param sourceAttachmentList 履约附件
+	private void copyAttachments(String recordId, List<Attachment> sourceAttachmentList) {
+		for (Attachment source : TimiJava.safeIterable(sourceAttachmentList)) {
+			if (source == null) {
+				continue;
+			}
+			TimiException.required(source.getId(), "履约附件 ID 不能为空");
+			Attachment copy = attachmentService.clone(source.getId());
+			copy.setBizType(Attachment.BizType.GAO_STOCK_RECORD);
+			copy.setBizId(recordId);
+			attachmentService.update(copy);
+		}
+	}
+
 	private GaoProductStock lockOrCreateStock(String storeId, String skuId) {
 		GaoProductStock stock = stockMapper.selectForUpdate(storeId, skuId);
 		if (stock != null) {

src/main/java/com/imyeyu/api/modules/gao/service/implement/GaoSalesOrderServiceImplement.java

@@ -30,10 +30,16 @@ import com.imyeyu.api.modules.gao.service.GaoStoreScopeService;
 import com.imyeyu.api.modules.gao.service.GaoStoreService;
 import com.imyeyu.api.modules.gao.vo.GaoDirectProductOrderCreateRequest;
 import com.imyeyu.api.modules.gao.vo.GaoPackageOrderCreateData;
+import com.imyeyu.api.modules.gao.vo.GaoCustomerProductCustomerRow;
+import com.imyeyu.api.modules.gao.vo.GaoCustomerProductCustomerView;
+import com.imyeyu.api.modules.gao.vo.GaoCustomerProductPage;
+import com.imyeyu.api.modules.gao.vo.GaoCustomerProductSummaryView;
+import com.imyeyu.api.modules.gao.vo.GaoCustomerProductView;
 import com.imyeyu.api.modules.gao.vo.GaoProductSkuUnitSelection;
 import com.imyeyu.api.modules.gao.vo.GaoSalesOrderCancelRequest;
 import com.imyeyu.api.modules.gao.vo.GaoSalesOrderItemRequest;
 import com.imyeyu.api.modules.gao.vo.GaoSalesOrderPage;
+import com.imyeyu.api.modules.gao.vo.GaoSalesOrderReceivableStatView;
 import com.imyeyu.api.modules.gao.vo.GaoSalesOrderUpdateRequest;
 import com.imyeyu.api.modules.system.audit.AuditOperation;
 import com.imyeyu.api.modules.system.audit.OperationAudit;
@@ -59,6 +65,7 @@ import java.util.Collection;
 import java.util.Comparator;
 import java.util.HashMap;
 import java.util.HashSet;
+import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
@@ -111,6 +118,80 @@ public class GaoSalesOrderServiceImplement extends AbstractEntityService<GaoSale
 		return result;
 	}
 
+	@Override
+	public GaoSalesOrderReceivableStatView summary(GaoSalesOrderPage page) {
+		TimiException.required(page, "not found sales order summary page");
+		return mapper.selectSummaryByQuery(page);
+	}
+
+	@Override
+	public PageResult<GaoCustomerProductCustomerView> pageCustomerProduct(GaoCustomerProductPage page) {
+		TimiException.required(page, "not found customer product page");
+		PageResult<GaoCustomerProductCustomerView> result = new PageResult<>();
+		result.setTotal(mapper.countCustomerProductCustomerByQuery(page));
+		List<GaoCustomerProductCustomerRow> customerRows = mapper.selectCustomerProductCustomerByQuery(page);
+		if (customerRows.isEmpty()) {
+			result.setList(List.of());
+			return result;
+		}
+
+		List<String> customerIdList = customerRows.stream().map(GaoCustomerProductCustomerRow::getCustomerId).toList();
+		page.setCustomerIdList(customerIdList);
+		List<GaoCustomerProductView> itemList = mapper.selectCustomerProductByQuery(page);
+		Map<String, GaoCustomerProductCustomerView> customerMap = new LinkedHashMap<>();
+		Map<String, Map<String, GaoCustomerProductSummaryView>> purchasedProductMap = new HashMap<>();
+		Map<String, Map<String, GaoCustomerProductSummaryView>> availableProductMap = new HashMap<>();
+		for (GaoCustomerProductCustomerRow row : customerRows) {
+			GaoCustomerProductCustomerView customerView = new GaoCustomerProductCustomerView();
+			GaoCustomer customer = new GaoCustomer();
+			customer.setId(row.getCustomerId());
+			customer.setCode(row.getCustomerCode());
+			customer.setName(row.getCustomerName());
+			customerView.setCustomer(customer);
+			customerView.setOrderCount(row.getOrderCount());
+			customerView.setPurchasedProducts(new ArrayList<>());
+			customerView.setAvailableProducts(new ArrayList<>());
+			customerMap.put(row.getCustomerId(), customerView);
+		}
+		for (GaoCustomerProductView item : itemList) {
+			if (!customerMap.containsKey(item.getCustomerId())) {
+				continue;
+			}
+			mergeCustomerProduct(purchasedProductMap, item, item.getBaseQuantity());
+			if (decimal(item.getAvailableBaseQuantity()).compareTo(ZERO) > 0) {
+				mergeCustomerProduct(availableProductMap, item, item.getAvailableBaseQuantity());
+			}
+		}
+		for (GaoCustomerProductCustomerRow row : customerRows) {
+			GaoCustomerProductCustomerView customerView = customerMap.get(row.getCustomerId());
+			customerView.setPurchasedProducts(new ArrayList<>(purchasedProductMap.getOrDefault(row.getCustomerId(), Map.of()).values()));
+			customerView.setAvailableProducts(new ArrayList<>(availableProductMap.getOrDefault(row.getCustomerId(), Map.of()).values()));
+		}
+		result.setList(new ArrayList<>(customerMap.values()));
+		return result;
+	}
+
+	private void mergeCustomerProduct(Map<String, Map<String, GaoCustomerProductSummaryView>> productMap,
+		GaoCustomerProductView item, BigDecimal quantity) {
+		String customerId = item.getCustomerId();
+		String productName = item.getProductNameSnapshot() == null ? "未命名产品" : item.getProductNameSnapshot();
+		String unit = item.getBaseUnitName() == null ? item.getUnitSnapshot() : item.getBaseUnitName();
+		unit = unit == null ? "基础单位" : unit;
+		String productKey = (item.getProductIdSnapshot() == null ? productName : item.getProductIdSnapshot()) + "::" + unit;
+		Map<String, GaoCustomerProductSummaryView> customerProducts = productMap.computeIfAbsent(customerId, key -> new LinkedHashMap<>());
+		GaoCustomerProductSummaryView product = customerProducts.get(productKey);
+		if (product == null) {
+			product = new GaoCustomerProductSummaryView();
+			product.setProductIdSnapshot(item.getProductIdSnapshot());
+			product.setProductName(productName);
+			product.setQuantity(decimal(quantity));
+			product.setUnit(unit);
+			customerProducts.put(productKey, product);
+			return;
+		}
+		product.setQuantity(decimal(product.getQuantity()).add(decimal(quantity)));
+	}
+
 	@Override
 	public GaoSalesOrder detail(String id) {
 		GaoSalesOrder order = get(id);

src/main/java/com/imyeyu/api/modules/gao/task/GaoCustomerFollowUpReminderTask.java

@@ -0,0 +1,31 @@
+package com.imyeyu.api.modules.gao.task;
+
+import com.imyeyu.api.modules.gao.service.GaoCustomerFollowUpReminderService;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.scheduling.annotation.Scheduled;
+import org.springframework.stereotype.Service;
+
+/// GAO 客户跟进提醒定时任务
+///
+/// @author Codex
+/// @since 2026-09-17
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class GaoCustomerFollowUpReminderTask {
+
+	private static final String ZONE_ID = "Asia/Shanghai";
+
+	private final GaoCustomerFollowUpReminderService service;
+
+	/// 每天八点开始创建当天短信批次，并在当天每分钟重试未完成的批次
+	@Scheduled(cron = "0 * 8-23 * * ?", zone = ZONE_ID)
+	public void createSmsBatch() {
+		try {
+			service.createSmsBatch();
+		} catch (Exception e) {
+			log.error("GAO 客户跟进提醒短信批次创建失败", e);
+		}
+	}
+}

src/main/java/com/imyeyu/api/modules/gao/vo/GaoCustomerFollowUpReminderPage.java

@@ -0,0 +1,33 @@
+package com.imyeyu.api.modules.gao.vo;
+
+import com.imyeyu.api.modules.gao.entity.GaoCustomerFollowUpReminder;
+import com.imyeyu.java.bean.BasePage;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+/// GAO 客户跟进提醒分页查询请求
+///
+/// @author Codex
+/// @since 2026-09-17
+@Data
+@EqualsAndHashCode(callSuper = true)
+public class GaoCustomerFollowUpReminderPage extends BasePage {
+
+	/// 门店 ID
+	private String storeId;
+
+	/// 客户 ID
+	private String customerId;
+
+	/// 负责人用户 ID
+	private String responsibleUserId;
+
+	/// 提醒状态
+	private GaoCustomerFollowUpReminder.Status status;
+
+	/// 提醒时间起点，包含
+	private Long beginRemindAt;
+
+	/// 提醒时间终点，包含
+	private Long endRemindAt;
+}

src/main/java/com/imyeyu/api/modules/gao/vo/GaoCustomerFollowUpReminderPageResult.java

@@ -0,0 +1,13 @@
+package com.imyeyu.api.modules.gao.vo;
+
+import com.imyeyu.api.modules.gao.entity.GaoCustomerFollowUpReminder;
+import com.imyeyu.spring.bean.PageResult;
+import lombok.EqualsAndHashCode;
+
+/// GAO 客户跟进提醒分页查询结果
+///
+/// @author Codex
+/// @since 2026-09-17
+@EqualsAndHashCode(callSuper = true)
+public class GaoCustomerFollowUpReminderPageResult extends PageResult<GaoCustomerFollowUpReminder> {
+}

src/main/java/com/imyeyu/api/modules/gao/vo/GaoCustomerProductCustomerRow.java

@@ -0,0 +1,23 @@
+package com.imyeyu.api.modules.gao.vo;
+
+import lombok.Data;
+
+/// GAO 客户产品客户分页行
+///
+/// @author Codex
+/// @since 2026-09-18
+@Data
+public class GaoCustomerProductCustomerRow {
+
+	/// 客户 ID
+	private String customerId;
+
+	/// 客户编码
+	private String customerCode;
+
+	/// 客户姓名
+	private String customerName;
+
+	/// 相关订单数
+	private Long orderCount;
+}

src/main/java/com/imyeyu/api/modules/gao/vo/GaoCustomerProductCustomerView.java

@@ -0,0 +1,26 @@
+package com.imyeyu.api.modules.gao.vo;
+
+import com.imyeyu.api.modules.gao.entity.GaoCustomer;
+import lombok.Data;
+
+import java.util.List;
+
+/// GAO 客户产品客户视图
+///
+/// @author Codex
+/// @since 2026-09-18
+@Data
+public class GaoCustomerProductCustomerView {
+
+	/// 客户
+	private GaoCustomer customer;
+
+	/// 相关订单数
+	private Long orderCount;
+
+	/// 已购买产品
+	private List<GaoCustomerProductSummaryView> purchasedProducts;
+
+	/// 当前可履约产品
+	private List<GaoCustomerProductSummaryView> availableProducts;
+}

src/main/java/com/imyeyu/api/modules/gao/vo/GaoCustomerProductPage.java

@@ -0,0 +1,32 @@
+package com.imyeyu.api.modules.gao.vo;
+
+import com.imyeyu.api.modules.gao.entity.GaoSalesOrderItem;
+import com.imyeyu.java.bean.BasePage;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+import java.util.List;
+
+/// GAO 客户产品分页请求
+///
+/// @author Codex
+/// @since 2026-09-18
+@Data
+@EqualsAndHashCode(callSuper = true)
+public class GaoCustomerProductPage extends BasePage {
+
+	/// 门店 ID
+	private String storeId;
+
+	/// 客户 ID
+	private String customerId;
+
+	/// 客户、订单或产品关键词
+	private String keyword;
+
+	/// 产品来源
+	private GaoSalesOrderItem.ItemType itemType;
+
+	/// 内部批量查询客户 ID
+	private List<String> customerIdList;
+}

src/main/java/com/imyeyu/api/modules/gao/vo/GaoCustomerProductSummaryView.java

@@ -0,0 +1,25 @@
+package com.imyeyu.api.modules.gao.vo;
+
+import lombok.Data;
+
+import java.math.BigDecimal;
+
+/// GAO 客户产品汇总视图
+///
+/// @author Codex
+/// @since 2026-09-18
+@Data
+public class GaoCustomerProductSummaryView {
+
+	/// 产品 ID 快照
+	private String productIdSnapshot;
+
+	/// 产品名称
+	private String productName;
+
+	/// 产品数量，使用基础单位
+	private BigDecimal quantity;
+
+	/// 基础单位名称
+	private String unit;
+}

src/main/java/com/imyeyu/api/modules/gao/vo/GaoCustomerProductView.java

@@ -0,0 +1,98 @@
+package com.imyeyu.api.modules.gao.vo;
+
+import com.imyeyu.api.modules.gao.entity.GaoSalesOrder;
+import com.imyeyu.api.modules.gao.entity.GaoSalesOrderItem;
+import lombok.Data;
+
+import java.math.BigDecimal;
+
+/// GAO 客户产品明细视图
+///
+/// 每一行对应一个订单明细，数量使用基础单位，便于汇总客户产品。
+///
+/// @author Codex
+/// @since 2026-09-18
+@Data
+public class GaoCustomerProductView {
+
+	/// 订单明细 ID
+	private String id;
+
+	/// 销售订单 ID
+	private String salesOrderId;
+
+	/// 客户 ID
+	private String customerId;
+
+	/// 客户编码
+	private String customerCode;
+
+	/// 客户姓名
+	private String customerName;
+
+	/// 订单号
+	private String orderNo;
+
+	/// 订单类型
+	private GaoSalesOrder.OrderType orderType;
+
+	/// 订单状态
+	private GaoSalesOrder.Status orderStatus;
+
+	/// 下单时间
+	private Long purchasedAt;
+
+	/// 订单项类型
+	private GaoSalesOrderItem.ItemType itemType;
+
+	/// 是否赠送权益
+	private Boolean gifted;
+
+	/// SKU ID
+	private String skuId;
+
+	/// SKU 单位 ID
+	private String skuUnitId;
+
+	/// 产品名称快照
+	private String productNameSnapshot;
+
+	/// 产品 ID 快照
+	private String productIdSnapshot;
+
+	/// SKU 编码快照
+	private String skuCodeSnapshot;
+
+	/// SKU 名称快照
+	private String skuNameSnapshot;
+
+	/// 规格摘要快照
+	private String specSummarySnapshot;
+
+	/// 单位快照
+	private String unitSnapshot;
+
+	/// 当前基础单位名称
+	private String baseUnitName;
+
+	/// 基础单位数量系数快照
+	private BigDecimal baseQuantityPerUnitSnapshot;
+
+	/// 购买数量
+	private BigDecimal quantity;
+
+	/// 购买基础单位数量
+	private BigDecimal baseQuantity;
+
+	/// 待履约基础单位数量
+	private BigDecimal reservedBaseQuantity;
+
+	/// 已履约基础单位数量
+	private BigDecimal fulfilledBaseQuantity;
+
+	/// 剩余权益基础单位数量
+	private BigDecimal remainingBaseQuantity;
+
+	/// 当前可立即履约基础单位数量
+	private BigDecimal availableBaseQuantity;
+}

src/main/java/com/imyeyu/api/modules/gao/vo/GaoOrderFulfillmentPage.java

@@ -5,6 +5,8 @@ import com.imyeyu.java.bean.BasePage;
 import lombok.Data;
 import lombok.EqualsAndHashCode;
 
+import java.util.List;
+
 /// GAO 统一履约分页查询请求
 ///
 /// @author Codex
@@ -22,6 +24,9 @@ public class GaoOrderFulfillmentPage extends BasePage {
 	/// 客户 ID
 	private String customerId;
 
+	/// SKU ID 列表，任一 SKU 命中即匹配
+	private List<String> skuIdList;
+
 	/// 履约状态
 	private GaoOrderFulfillment.Status status;
 

src/main/java/com/imyeyu/api/modules/gao/vo/GaoOrderReminderCustomer.java

@@ -1,5 +1,6 @@
 package com.imyeyu.api.modules.gao.vo;
 
+import com.imyeyu.api.modules.gao.entity.GaoSalesOrder;
 import lombok.Data;
 
 /// GAO 订单提醒客户
@@ -17,4 +18,40 @@ public class GaoOrderReminderCustomer {
 
 	/// 客户名称
 	private String customerName;
+
+	/// 订单 ID
+	private String orderId;
+
+	/// 订单号
+	private String orderNo;
+
+	/// 订单状态
+	private GaoSalesOrder.Status orderStatus;
+
+	/// 付款状态
+	private GaoSalesOrder.PaymentStatus paymentStatus;
+
+	/// 成交金额，单位分
+	private Long saleAmount;
+
+	/// 待核销收款，单位分
+	private Long pendingPaidAmount;
+
+	/// 已收金额，单位分
+	private Long paidAmount;
+
+	/// 未收金额，单位分
+	private Long unpaidAmount;
+
+	/// 待核销收款笔数
+	private Long pendingReceiveCount;
+
+	/// 待核销收款金额，单位分
+	private Long pendingReceiveAmount;
+
+	/// 待核销履约单数量
+	private Long pendingFulfillmentCount;
+
+	/// 待核销履约明细数量
+	private Long pendingFulfillmentItemCount;
 }

src/main/java/com/imyeyu/api/modules/gao/vo/GaoPointDailyStatView.java

@@ -0,0 +1,23 @@
+package com.imyeyu.api.modules.gao.vo;
+
+import lombok.Data;
+
+/// 每日积分获得与消耗统计
+///
+/// @author Codex
+/// @since 2026-09-23
+@Data
+public class GaoPointDailyStatView {
+
+	/// 日期值，格式为 yyyyMMdd
+	private Integer dateValue;
+
+	/// 每日获得积分
+	private Long earnedPoints;
+
+	/// 每日消耗积分，以正数返回
+	private Long consumedPoints;
+
+	/// 获得积分减消耗积分
+	private Long netChangePoints;
+}

src/main/java/com/imyeyu/api/modules/gao/vo/GaoPointRedemptionProductRankView.java

@@ -0,0 +1,23 @@
+package com.imyeyu.api.modules.gao.vo;
+
+import lombok.Data;
+
+/// 积分兑换产品排行统计
+///
+/// @author Codex
+/// @since 2026-09-23
+@Data
+public class GaoPointRedemptionProductRankView {
+
+	/// 产品 ID
+	private String productId;
+
+	/// 产品名称
+	private String productName;
+
+	/// 兑换单数
+	private Long redemptionCount;
+
+	/// 实际扣除积分合计，不扣除退回积分
+	private Long pointCost;
+}

src/main/java/com/imyeyu/api/modules/gao/vo/GaoProductSkuBaseUnitMigrationRequest.java

@@ -0,0 +1,19 @@
+package com.imyeyu.api.modules.gao.vo;
+
+import lombok.Data;
+
+import java.math.BigDecimal;
+
+/// SKU 基础单位迁移请求
+@Data
+public class GaoProductSkuBaseUnitMigrationRequest {
+
+	/// 新基础单位 ID；切换到本次新增单位时允许为空
+	private String targetUnitId;
+
+	/// 新基础单位名称；按 ID 定位失败时用于匹配本次提交的新单位
+	private String targetUnitName;
+
+	/// 1 个旧基础单位等于的新基础单位数量
+	private BigDecimal oldToNewBaseRatio;
+}

src/main/java/com/imyeyu/api/modules/gao/vo/GaoProductStockProductView.java

@@ -32,6 +32,9 @@ public class GaoProductStockProductView {
 	/// 可库存 SKU 数量
 	private Long skuCount;
 
+	/// 产品仅有一个可库存 SKU 时的 SKU ID
+	private String skuId;
+
 	/// 库存数量，使用基础单位
 	private BigDecimal onHandQuantity;
 

src/main/java/com/imyeyu/api/modules/gao/vo/GaoProductStockRecordPage.java

@@ -19,6 +19,9 @@ public class GaoProductStockRecordPage extends BasePage {
 	/// 产品 ID
 	private String productId;
 
+	/// SKU ID
+	private String skuId;
+
 	/// 产品名称、拼音或编码关键词
 	private String keyword;
 

src/main/java/com/imyeyu/api/modules/gao/vo/GaoSalesOrderPage.java

@@ -5,6 +5,8 @@ import com.imyeyu.java.bean.BasePage;
 import lombok.Data;
 import lombok.EqualsAndHashCode;
 
+import java.util.List;
+
 /// GAO 销售订单分页请求
 ///
 /// @author Codex
@@ -19,18 +21,33 @@ public class GaoSalesOrderPage extends BasePage {
 	/// 客户 ID
 	private String customerId;
 
+	/// 套餐配置 ID
+	private String packageConfigId;
+
 	/// 订单类型
 	private GaoSalesOrder.OrderType orderType;
 
+	/// 订单类型列表
+	private List<GaoSalesOrder.OrderType> orderTypeList;
+
 	/// 订单状态
 	private GaoSalesOrder.Status status;
 
+	/// 订单状态列表
+	private List<GaoSalesOrder.Status> statusList;
+
 	/// 付款状态
 	private GaoSalesOrder.PaymentStatus paymentStatus;
 
+	/// 付款状态列表
+	private List<GaoSalesOrder.PaymentStatus> paymentStatusList;
+
 	/// 退款状态
 	private GaoSalesOrder.RefundStatus refundStatus;
 
+	/// 退款状态列表
+	private List<GaoSalesOrder.RefundStatus> refundStatusList;
+
 	/// true 为筛选可收款且未付清订单
 	private Boolean pendingReceive;
 

src/main/java/com/imyeyu/api/modules/system/audit/OperationAuditAspect.java

@@ -42,12 +42,15 @@ public class OperationAuditAspect {
 		Logger logger = new Logger(operation.getModule(), operation.name());
 		logger.setContent(payloadSerializer.serializeArguments(arguments));
 		long startNanos = System.nanoTime();
+		boolean previousAuditState = OperationAuditContext.begin();
 		try {
 			Object result = joinPoint.proceed();
 			logger.setLevel(Logger.Level.INFO);
 			logger.setResult(payloadSerializer.serializeResult(result, arguments));
 			logger.setDuration(duration(startNanos));
+			if (!OperationAuditContext.isSuccessAuditSkipped()) {
 				record(logger);
+			}
 			return result;
 		} catch (TimiException e) {
 			logger.setLevel(Logger.Level.WARN);
@@ -62,6 +65,8 @@ public class OperationAuditAspect {
 			log.error("业务操作失败: {}", operation.name(), e);
 			record(logger);
 			throw e;
+		} finally {
+			OperationAuditContext.end(previousAuditState);
 		}
 	}
 

src/main/java/com/imyeyu/api/modules/system/audit/OperationAuditContext.java

@@ -0,0 +1,45 @@
+package com.imyeyu.api.modules.system.audit;
+
+/// 当前线程中的操作审计上下文
+///
+/// @author Codex
+/// @since 2026-09-30
+public final class OperationAuditContext {
+
+	private static final ThreadLocal<Boolean> SKIP_SUCCESS_AUDIT = ThreadLocal.withInitial(() -> false);
+
+	private OperationAuditContext() {
+	}
+
+	/// 开始一次审计操作并返回外层状态
+	///
+	/// @return 外层是否跳过成功审计
+	public static boolean begin() {
+		boolean previous = SKIP_SUCCESS_AUDIT.get();
+		SKIP_SUCCESS_AUDIT.set(false);
+		return previous;
+	}
+
+	/// 跳过当前操作的成功审计
+	public static void skipSuccessAudit() {
+		SKIP_SUCCESS_AUDIT.set(true);
+	}
+
+	/// 判断当前操作是否跳过成功审计
+	///
+	/// @return 是否跳过
+	public static boolean isSuccessAuditSkipped() {
+		return SKIP_SUCCESS_AUDIT.get();
+	}
+
+	/// 恢复外层审计状态
+	///
+	/// @param previous 外层是否跳过成功审计
+	public static void end(boolean previous) {
+		if (previous) {
+			SKIP_SUCCESS_AUDIT.set(true);
+		} else {
+			SKIP_SUCCESS_AUDIT.remove();
+		}
+	}
+}

src/main/java/com/imyeyu/api/util/JavaCV.java

@@ -16,10 +16,18 @@ import java.io.InputStream;
 /// @since 2025-10-23 17:05
 public class JavaCV {
 
+	/// 单次跳转分片上限
+	///
+	/// 任何真实文件的当前位置加该值都不会溢出 long
+	private static final long SKIP_PIECE = 1L << 40;
+
 	/// 从视频流顺序解码并提取指定时间附近的一帧 PNG 图片
 	///
 	/// 不执行时间定位，避免为了取实时缩略图而把整个视频复制到临时文件
 	///
+	/// moov 原子位于文件尾部的视频（非 faststart）仍会触发 FFmpeg 回调 AVSEEK_SIZE 探测文件大小，
+	/// 依赖底层流的 skip/reset 语义正确，因此必须配合 `SkipSafeInputStream` 规避 GridFS 的溢出缺陷
+	///
 	/// @param stream        视频输入流
 	/// @param targetSeconds 目标时间，单位为秒
 	/// @return PNG 图片字节流
@@ -27,7 +35,7 @@ public class JavaCV {
 	public static ByteArrayOutputStream captureThumbnail(InputStream stream, double targetSeconds) throws Exception {
 		long targetMicros = toMicros(targetSeconds);
 		ByteArrayOutputStream firstFrame = new ByteArrayOutputStream();
-		try (FFmpegFrameGrabber grabber = new FFmpegFrameGrabber(stream)) {
+		try (FFmpegFrameGrabber grabber = new FFmpegFrameGrabber(new SkipSafeInputStream(stream))) {
 			grabber.start();
 			try (Java2DFrameConverter converter = new Java2DFrameConverter()) {
 				Frame frame;
@@ -61,4 +69,73 @@ public class JavaCV {
 		}
 		return new ByteArrayOutputStream();
 	}
+
+	/// 分片跳转流包装
+	///
+	/// GridFSDownloadStreamImpl 的 skip 以 `currentPosition + n` 计算目标位置且不防护 long 溢出，
+	/// 当 javacv 的 SeekCallback 以 `skip(Long.MAX_VALUE)` 探测流结尾时，位于流末尾的第二次调用
+	/// 会因溢出落入正常分支，返回未实际跳过的 `Long.MAX_VALUE` 并污染内部位置，
+	/// 导致 `avformat_open_input` 在 `while (true)` 内 100% CPU 死循环
+	///
+	/// 此包装将大额跳转拆分为不超过 {@link #SKIP_PIECE} 的分片，保证每次调用的目标位置不溢出
+	private static class SkipSafeInputStream extends InputStream {
+
+		private final InputStream stream;
+
+		private SkipSafeInputStream(InputStream stream) {
+			this.stream = stream;
+		}
+
+		@Override
+		public int read() throws IOException {
+			return stream.read();
+		}
+
+		@Override
+		public int read(byte[] b, int off, int len) throws IOException {
+			return stream.read(b, off, len);
+		}
+
+		@Override
+		public long skip(long n) throws IOException {
+			if (n <= 0) {
+				return 0;
+			}
+			long total = 0;
+			while (0 < n) {
+				long skipped = stream.skip(Math.min(n, SKIP_PIECE));
+				if (skipped <= 0) {
+					break;
+				}
+				total += skipped;
+				n -= skipped;
+			}
+			return total;
+		}
+
+		@Override
+		public int available() throws IOException {
+			return stream.available();
+		}
+
+		@Override
+		public void close() throws IOException {
+			stream.close();
+		}
+
+		@Override
+		public synchronized void mark(int readlimit) {
+			stream.mark(readlimit);
+		}
+
+		@Override
+		public synchronized void reset() throws IOException {
+			stream.reset();
+		}
+
+		@Override
+		public boolean markSupported() {
+			return stream.markSupported();
+		}
+	}
 }

src/main/resources/db/migration/timiserver/V80__create_gao_customer_follow_up_reminder_tables.sql

@@ -0,0 +1,26 @@
+CREATE TABLE `gao_customer_follow_up_reminder` (
+	`id` VARCHAR(36) NOT NULL,
+	`store_id` VARCHAR(36) NOT NULL COMMENT '门店 ID',
+	`customer_id` VARCHAR(36) NOT NULL COMMENT '客户 ID',
+	`responsible_user_id` VARCHAR(36) NOT NULL COMMENT '负责人用户 ID',
+	`content` TEXT NOT NULL COMMENT '跟进内容，纯文本',
+	`remind_at` BIGINT NOT NULL COMMENT '提醒时间，Unix 毫秒时间戳',
+	`status` VARCHAR(32) NOT NULL COMMENT 'PENDING 待完成，COMPLETED 已完成',
+	`internal_notify_enabled` TINYINT(1) NOT NULL DEFAULT 0 COMMENT 'true 为发送站内通知',
+	`sms_notify_enabled` TINYINT(1) NOT NULL DEFAULT 0 COMMENT 'true 为发送短信通知',
+	`internal_notify_detail_id` VARCHAR(36) NULL COMMENT '站内通知详情 ID',
+	`sms_notify_detail_id` VARCHAR(36) NULL COMMENT '短信聚合通知详情 ID，可被多条提醒共享',
+	`completed_by` VARCHAR(36) NULL COMMENT '完成人用户 ID',
+	`completed_at` BIGINT NULL COMMENT '完成时间',
+	`created_by` VARCHAR(36) NOT NULL COMMENT '创建人用户 ID',
+	`updated_by` VARCHAR(36) NULL COMMENT '最后修改人用户 ID',
+	`created_at` BIGINT NOT NULL,
+	`updated_at` BIGINT NULL,
+	`deleted_at` BIGINT NULL,
+	PRIMARY KEY (`id`),
+	KEY `idx_gao_customer_follow_up_reminder_customer_time` (`store_id`, `customer_id`, `deleted_at`, `remind_at`),
+	KEY `idx_gao_customer_follow_up_reminder_responsible_time` (`store_id`, `responsible_user_id`, `status`, `deleted_at`, `remind_at`),
+	KEY `idx_gao_customer_follow_up_reminder_sms_batch` (`store_id`, `sms_notify_enabled`, `status`, `deleted_at`, `remind_at`, `sms_notify_detail_id`),
+	KEY `idx_gao_customer_follow_up_reminder_internal_detail` (`internal_notify_detail_id`),
+	KEY `idx_gao_customer_follow_up_reminder_sms_detail` (`sms_notify_detail_id`)
+) COMMENT='GAO 客户跟进提醒';

src/main/resources/mapper/timi-server/common/NotifyMapper.xml

@@ -26,6 +26,17 @@
 		ON DUPLICATE KEY UPDATE `id` = `id`
 	</insert>
 
+	<select id="selectByBusinessKey" resultType="com.imyeyu.api.modules.common.entity.Notify">
+		SELECT *
+		FROM `notify`
+		WHERE `biz_type` = #{bizType}
+			AND `biz_reminded_type` = #{bizRemindedType}
+			AND `biz_reminded_key` = #{bizRemindedKey}
+			AND `deleted_at` IS NULL
+		ORDER BY `created_at` DESC, `id` DESC
+		LIMIT 1
+	</select>
+
 	<select id="selectManagementPage" resultType="com.imyeyu.api.modules.common.vo.NotifyManagementItem">
 		SELECT
 			n.`id`,

src/main/resources/mapper/timi-server/gao/GaoCustomerFollowUpReminderMapper.xml

@@ -0,0 +1,78 @@
+<?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.imyeyu.api.modules.gao.mapper.GaoCustomerFollowUpReminderMapper">
+	<sql id="queryWhere">
+		`r`.`deleted_at` IS NULL
+		<if test="page.storeId != null and page.storeId != ''">
+			AND `r`.`store_id` = #{page.storeId}
+		</if>
+		<if test="page.customerId != null and page.customerId != ''">
+			AND `r`.`customer_id` = #{page.customerId}
+		</if>
+		<if test="page.responsibleUserId != null and page.responsibleUserId != ''">
+			AND `r`.`responsible_user_id` = #{page.responsibleUserId}
+		</if>
+		<if test="page.status != null">
+			AND `r`.`status` = #{page.status}
+		</if>
+		<if test="page.beginRemindAt != null">
+			AND `r`.`remind_at` &gt;= #{page.beginRemindAt}
+		</if>
+		<if test="page.endRemindAt != null">
+			AND `r`.`remind_at` &lt;= #{page.endRemindAt}
+		</if>
+	</sql>
+
+	<select id="countByQuery" resultType="long">
+		SELECT COUNT(1)
+		FROM `gao_customer_follow_up_reminder` `r`
+		WHERE <include refid="queryWhere"/>
+	</select>
+
+	<select id="selectByQuery" resultType="com.imyeyu.api.modules.gao.entity.GaoCustomerFollowUpReminder">
+		SELECT `r`.*
+		FROM `gao_customer_follow_up_reminder` `r`
+		WHERE <include refid="queryWhere"/>
+		ORDER BY `r`.`remind_at` ASC, `r`.`created_at` ASC, `r`.`id` ASC
+		LIMIT #{page.offset}, #{page.limit}
+	</select>
+
+	<select id="selectPendingSmsByRange" resultType="com.imyeyu.api.modules.gao.entity.GaoCustomerFollowUpReminder">
+		SELECT *
+		FROM `gao_customer_follow_up_reminder`
+		WHERE `status` = 'PENDING'
+			AND `deleted_at` IS NULL
+			AND `sms_notify_enabled` = 1
+			AND `sms_notify_detail_id` IS NULL
+			AND `remind_at` &gt;= #{beginAt}
+			AND `remind_at` &lt; #{endAt}
+		ORDER BY `store_id`, `responsible_user_id`, `remind_at`, `created_at`, `id`
+		FOR UPDATE
+	</select>
+
+	<update id="complete">
+		UPDATE `gao_customer_follow_up_reminder`
+		SET `status` = 'COMPLETED',
+			`updated_by` = #{updatedBy},
+			`completed_by` = #{completedBy},
+			`completed_at` = #{completedAt},
+			`updated_at` = #{completedAt}
+		WHERE `id` = #{id}
+			AND `status` = 'PENDING'
+			AND `deleted_at` IS NULL
+	</update>
+
+	<update id="bindSmsNotifyDetailId">
+		UPDATE `gao_customer_follow_up_reminder`
+		SET `sms_notify_detail_id` = #{smsNotifyDetailId},
+			`updated_at` = FLOOR(UNIX_TIMESTAMP(NOW(3)) * 1000)
+		WHERE `id` IN
+		<foreach collection="idList" item="id" separator="," open="(" close=")">
+			#{id}
+		</foreach>
+			AND `status` = 'PENDING'
+			AND `deleted_at` IS NULL
+			AND `sms_notify_enabled` = 1
+			AND `sms_notify_detail_id` IS NULL
+	</update>
+</mapper>

src/main/resources/mapper/timi-server/gao/GaoOrderFulfillmentMapper.xml

@@ -39,6 +39,14 @@
 		<if test="storeId != null and storeId != ''">AND `store_id` = #{storeId}</if>
 		<if test="salesOrderId != null and salesOrderId != ''">AND `sales_order_id` = #{salesOrderId}</if>
 		<if test="customerId != null and customerId != ''">AND `customer_id` = #{customerId}</if>
+		<if test="skuIdList != null and skuIdList.size() > 0">
+			AND EXISTS (
+				SELECT 1 FROM `gao_order_fulfillment_item` fulfillment_item
+				WHERE fulfillment_item.`fulfillment_id` = `gao_order_fulfillment`.`id`
+				AND fulfillment_item.`sku_id` IN
+				<foreach collection="skuIdList" item="skuId" open="(" separator="," close=")">#{skuId}</foreach>
+			)
+		</if>
 		<if test="status != null">AND `status` = #{status}</if>
 		<if test="beginAt != null">AND `delivered_at` &gt;= #{beginAt}</if>
 		<if test="endAt != null">AND `delivered_at` &lt;= #{endAt}</if>

src/main/resources/mapper/timi-server/gao/GaoOrderReminderMapper.xml

@@ -1,44 +1,90 @@
 <?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.imyeyu.api.modules.gao.mapper.GaoOrderReminderMapper">
-	<select id="selectOrderReceiveCustomers" resultType="com.imyeyu.api.modules.gao.vo.GaoOrderReminderCustomer">
+	<sql id="orderReminderSelect">
 		SELECT
 			o.`store_id` AS `storeId`,
 			o.`customer_id` AS `customerId`,
-			c.`name` AS `customerName`
+			c.`name` AS `customerName`,
-		FROM `gao_sales_order` o
+			o.`id` AS `orderId`,
-		INNER JOIN `gao_customer` c ON c.`id` = o.`customer_id` AND c.`deleted_at` IS NULL
+			o.`order_no` AS `orderNo`,
-		WHERE o.`deleted_at` IS NULL
+			o.`status` AS `orderStatus`,
-			AND o.`status` IN ('ACTIVE', 'FULFILLED')
+			o.`payment_status` AS `paymentStatus`,
-			AND o.`payment_status` IN ('UNPAID', 'PARTIALLY_PAID')
+			o.`sale_amount` AS `saleAmount`,
-		GROUP BY o.`store_id`, o.`customer_id`, c.`name`
+			o.`pending_paid_amount` AS `pendingPaidAmount`,
-		ORDER BY o.`store_id`, c.`name`, o.`customer_id`
+			o.`paid_amount` AS `paidAmount`,
-	</select>
+			GREATEST(o.`sale_amount` - o.`paid_amount`, 0) AS `unpaidAmount`,
+			COALESCE(fr.`pending_receive_count`, 0) AS `pendingReceiveCount`,
+			COALESCE(fr.`pending_receive_amount`, 0) AS `pendingReceiveAmount`,
+			COALESCE(ff.`pending_fulfillment_count`, 0) AS `pendingFulfillmentCount`,
+			COALESCE(ff.`pending_fulfillment_item_count`, 0) AS `pendingFulfillmentItemCount`
+	</sql>
 
-	<select id="selectReceiveVerifyCustomers" resultType="com.imyeyu.api.modules.gao.vo.GaoOrderReminderCustomer">
+	<sql id="orderReminderJoins">
+		INNER JOIN `gao_customer` c ON c.`id` = o.`customer_id` AND c.`deleted_at` IS NULL
+		LEFT JOIN (
 			SELECT
-			f.`store_id` AS `storeId`,
+				f.`store_id`,
-			f.`customer_id` AS `customerId`,
+				f.`biz_id`,
-			c.`name` AS `customerName`
+				COUNT(1) AS `pending_receive_count`,
+				COALESCE(SUM(f.`amount`), 0) AS `pending_receive_amount`
 			FROM `gao_fund_record` f
-		INNER JOIN `gao_customer` c ON c.`id` = f.`customer_id` AND c.`deleted_at` IS NULL
 			WHERE f.`deleted_at` IS NULL
 				AND f.`biz_type` = 'SALES_ORDER'
 				AND f.`operation_type` = 'RECEIVE'
 				AND f.`status` = 'PENDING'
-		GROUP BY f.`store_id`, f.`customer_id`, c.`name`
+			GROUP BY f.`store_id`, f.`biz_id`
-		ORDER BY f.`store_id`, c.`name`, f.`customer_id`
+		) fr ON fr.`store_id` = o.`store_id` AND fr.`biz_id` = o.`id`
+		LEFT JOIN (
+			SELECT
+				f.`store_id`,
+				f.`sales_order_id`,
+				COUNT(DISTINCT f.`id`) AS `pending_fulfillment_count`,
+				COUNT(fi.`id`) AS `pending_fulfillment_item_count`
+			FROM `gao_order_fulfillment` f
+			LEFT JOIN `gao_order_fulfillment_item` fi ON fi.`fulfillment_id` = f.`id`
+			WHERE f.`status` = 'PENDING'
+			GROUP BY f.`store_id`, f.`sales_order_id`
+		) ff ON ff.`store_id` = o.`store_id` AND ff.`sales_order_id` = o.`id`
+	</sql>
+
+	<select id="selectOrderReceiveCustomers" resultType="com.imyeyu.api.modules.gao.vo.GaoOrderReminderCustomer">
+		<include refid="orderReminderSelect"/>
+		FROM `gao_sales_order` o
+		<include refid="orderReminderJoins"/>
+		WHERE o.`deleted_at` IS NULL
+			AND o.`status` IN ('ACTIVE', 'FULFILLED')
+			AND o.`payment_status` IN ('UNPAID', 'PARTIALLY_PAID')
+		ORDER BY o.`store_id`, c.`name`, o.`customer_id`, o.`purchased_at`, o.`order_no`
+	</select>
+
+	<select id="selectReceiveVerifyCustomers" resultType="com.imyeyu.api.modules.gao.vo.GaoOrderReminderCustomer">
+		<include refid="orderReminderSelect"/>
+		FROM `gao_sales_order` o
+		<include refid="orderReminderJoins"/>
+		INNER JOIN (
+			SELECT DISTINCT f.`store_id`, f.`biz_id`
+			FROM `gao_fund_record` f
+			WHERE f.`deleted_at` IS NULL
+				AND f.`biz_type` = 'SALES_ORDER'
+				AND f.`operation_type` = 'RECEIVE'
+				AND f.`status` = 'PENDING'
+		) pendingReceive ON pendingReceive.`store_id` = o.`store_id` AND pendingReceive.`biz_id` = o.`id`
+		WHERE o.`deleted_at` IS NULL
+		ORDER BY o.`store_id`, c.`name`, o.`customer_id`, o.`purchased_at`, o.`order_no`
 	</select>
 
 	<select id="selectFulfillmentVerifyCustomers" resultType="com.imyeyu.api.modules.gao.vo.GaoOrderReminderCustomer">
-		SELECT
+		<include refid="orderReminderSelect"/>
-			f.`store_id` AS `storeId`,
+		FROM `gao_sales_order` o
-			f.`customer_id` AS `customerId`,
+		<include refid="orderReminderJoins"/>
-			c.`name` AS `customerName`
+		INNER JOIN (
+			SELECT DISTINCT f.`store_id`, f.`sales_order_id`
 			FROM `gao_order_fulfillment` f
-		INNER JOIN `gao_customer` c ON c.`id` = f.`customer_id` AND c.`deleted_at` IS NULL
 			WHERE f.`status` = 'PENDING'
-		GROUP BY f.`store_id`, f.`customer_id`, c.`name`
+		) pendingFulfillment ON pendingFulfillment.`store_id` = o.`store_id`
-		ORDER BY f.`store_id`, c.`name`, f.`customer_id`
+			AND pendingFulfillment.`sales_order_id` = o.`id`
+		WHERE o.`deleted_at` IS NULL
+		ORDER BY o.`store_id`, c.`name`, o.`customer_id`, o.`purchased_at`, o.`order_no`
 	</select>
 </mapper>

src/main/resources/mapper/timi-server/gao/GaoPointChartMapper.xml

@@ -0,0 +1,36 @@
+<?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.imyeyu.api.modules.gao.mapper.GaoPointChartMapper">
+	<select id="selectDailyTrend" resultType="com.imyeyu.api.modules.gao.vo.GaoPointDailyStatView">
+		SELECT
+			CAST(DATE_FORMAT(FROM_UNIXTIME(l.`occurred_at` / 1000), '%Y%m%d') AS UNSIGNED) AS `dateValue`,
+			COALESCE(SUM(CASE WHEN l.`change_type` = 'EARN' THEN l.`point_delta` ELSE 0 END), 0) AS `earnedPoints`,
+			COALESCE(SUM(CASE WHEN l.`change_type` = 'CONSUME' THEN -l.`point_delta` ELSE 0 END), 0) AS `consumedPoints`,
+			COALESCE(SUM(l.`point_delta`), 0) AS `netChangePoints`
+		FROM `gao_point_ledger` l
+		WHERE l.`deleted_at` IS NULL
+			AND l.`store_id` = #{storeId}
+			AND l.`occurred_at` &gt;= #{beginAt}
+			AND l.`occurred_at` &lt;= #{endAt}
+			AND l.`change_type` IN ('EARN', 'CONSUME')
+		GROUP BY DATE_FORMAT(FROM_UNIXTIME(l.`occurred_at` / 1000), '%Y%m%d')
+		ORDER BY `dateValue` ASC
+	</select>
+
+	<select id="selectRedemptionProductRank" resultType="com.imyeyu.api.modules.gao.vo.GaoPointRedemptionProductRankView">
+		SELECT
+			r.`product_id_snapshot` AS `productId`,
+			COALESCE(MAX(NULLIF(r.`product_name_snapshot`, '')), '未命名产品') AS `productName`,
+			COUNT(1) AS `redemptionCount`,
+			COALESCE(SUM(r.`actual_point_cost`), 0) AS `pointCost`
+		FROM `gao_point_redemption` r
+		WHERE r.`deleted_at` IS NULL
+			AND r.`store_id` = #{storeId}
+			AND r.`product_id_snapshot` IS NOT NULL
+			AND r.`redeemed_at` &gt;= #{beginAt}
+			AND r.`redeemed_at` &lt;= #{endAt}
+		GROUP BY r.`product_id_snapshot`
+		ORDER BY `pointCost` DESC, `redemptionCount` DESC, `productName` ASC, `productId` ASC
+		LIMIT 10
+	</select>
+</mapper>

src/main/resources/mapper/timi-server/gao/GaoProductEditMapper.xml

@@ -0,0 +1,107 @@
+<?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.imyeyu.api.modules.gao.mapper.GaoProductEditMapper">
+	<select id="countProductReferences" resultType="int">
+		SELECT
+			(SELECT COUNT(*) FROM `gao_sales_order_item` WHERE `product_id_snapshot` = #{productId}) +
+			(SELECT COUNT(*) FROM `gao_order_fulfillment_item` WHERE `product_id_snapshot` = #{productId}) +
+			(SELECT COUNT(*) FROM `gao_product_stock_record` WHERE `product_id_snapshot` = #{productId}) +
+			(SELECT COUNT(*) FROM `gao_package_config_item` WHERE `product_id_snapshot` = #{productId}) +
+			(SELECT COUNT(*) FROM `gao_point_redemption` WHERE `product_id_snapshot` = #{productId})
+	</select>
+	<select id="countSkuReferences" resultType="int">
+		SELECT
+			(SELECT COUNT(*) FROM `gao_sales_order_item` WHERE `sku_id` = #{skuId}) +
+			(SELECT COUNT(*) FROM `gao_order_fulfillment_item` WHERE `sku_id` = #{skuId}) +
+			(SELECT COUNT(*) FROM `gao_product_stock_record` WHERE `sku_id` = #{skuId}) +
+			(SELECT COUNT(*) FROM `gao_package_config_item` WHERE `sku_id` = #{skuId}) +
+			(SELECT COUNT(*) FROM `gao_point_redeem_sku` WHERE `sku_id` = #{skuId}) +
+			(SELECT COUNT(*) FROM `gao_point_redemption` WHERE `sku_id_snapshot` = #{skuId})
+	</select>
+	<select id="countUnitReferences" resultType="int">
+		SELECT
+			(SELECT COUNT(*) FROM `gao_sales_order_item` WHERE `sku_unit_id` = #{unitId}) +
+			(SELECT COUNT(*) FROM `gao_order_fulfillment_item` WHERE `sku_unit_id` = #{unitId}) +
+			(SELECT COUNT(*) FROM `gao_product_stock_record` WHERE `sku_unit_id` = #{unitId}) +
+			(SELECT COUNT(*) FROM `gao_package_config_item` WHERE `sku_unit_id` = #{unitId}) +
+			(SELECT COUNT(*) FROM `gao_point_redeem_sku` WHERE `sku_unit_id` = #{unitId}) +
+			(SELECT COUNT(*) FROM `gao_point_redemption` WHERE `sku_unit_id_snapshot` = #{unitId})
+	</select>
+	<select id="countMigrationPrecisionLoss" resultType="int">
+		SELECT COUNT(*) FROM (
+			SELECT 1 FROM `gao_product_sku` WHERE `id` = #{skuId} AND `min_stock_quantity` IS NOT NULL
+				AND (`min_stock_quantity` * #{ratio} &lt;&gt; ROUND(`min_stock_quantity` * #{ratio}, 3) OR ABS(`min_stock_quantity` * #{ratio}) &gt; 999999999999999.999)
+			UNION ALL SELECT 1 FROM `gao_product_stock` WHERE `sku_id` = #{skuId}
+				AND (`on_hand_quantity` * #{ratio} &lt;&gt; ROUND(`on_hand_quantity` * #{ratio}, 3) OR ABS(`on_hand_quantity` * #{ratio}) &gt; 999999999999999.999
+				OR `reserved_quantity` * #{ratio} &lt;&gt; ROUND(`reserved_quantity` * #{ratio}, 3) OR ABS(`reserved_quantity` * #{ratio}) &gt; 999999999999999.999)
+			UNION ALL SELECT 1 FROM `gao_sales_order_item` WHERE `sku_id` = #{skuId}
+				AND (`base_quantity` * #{ratio} &lt;&gt; ROUND(`base_quantity` * #{ratio}, 3) OR ABS(`base_quantity` * #{ratio}) &gt; 999999999999999.999
+				OR `reserved_base_quantity` * #{ratio} &lt;&gt; ROUND(`reserved_base_quantity` * #{ratio}, 3) OR ABS(`reserved_base_quantity` * #{ratio}) &gt; 999999999999999.999
+				OR `fulfilled_base_quantity` * #{ratio} &lt;&gt; ROUND(`fulfilled_base_quantity` * #{ratio}, 3) OR ABS(`fulfilled_base_quantity` * #{ratio}) &gt; 999999999999999.999)
+			UNION ALL SELECT 1 FROM `gao_order_fulfillment_item` WHERE `sku_id` = #{skuId}
+				AND (`base_quantity` * #{ratio} &lt;&gt; ROUND(`base_quantity` * #{ratio}, 3) OR ABS(`base_quantity` * #{ratio}) &gt; 999999999999999.999
+				OR `reserved_base_before` * #{ratio} &lt;&gt; ROUND(`reserved_base_before` * #{ratio}, 3) OR ABS(`reserved_base_before` * #{ratio}) &gt; 999999999999999.999
+				OR `reserved_base_after` * #{ratio} &lt;&gt; ROUND(`reserved_base_after` * #{ratio}, 3) OR ABS(`reserved_base_after` * #{ratio}) &gt; 999999999999999.999
+				OR `fulfilled_base_before` * #{ratio} &lt;&gt; ROUND(`fulfilled_base_before` * #{ratio}, 3) OR ABS(`fulfilled_base_before` * #{ratio}) &gt; 999999999999999.999
+				OR `fulfilled_base_after` * #{ratio} &lt;&gt; ROUND(`fulfilled_base_after` * #{ratio}, 3) OR ABS(`fulfilled_base_after` * #{ratio}) &gt; 999999999999999.999)
+			UNION ALL SELECT 1 FROM `gao_product_stock_record` WHERE `sku_id` = #{skuId}
+				AND (`base_quantity` * #{ratio} &lt;&gt; ROUND(`base_quantity` * #{ratio}, 3) OR ABS(`base_quantity` * #{ratio}) &gt; 999999999999999.999
+				OR `on_hand_delta` * #{ratio} &lt;&gt; ROUND(`on_hand_delta` * #{ratio}, 3) OR ABS(`on_hand_delta` * #{ratio}) &gt; 999999999999999.999
+				OR `reserved_delta` * #{ratio} &lt;&gt; ROUND(`reserved_delta` * #{ratio}, 3) OR ABS(`reserved_delta` * #{ratio}) &gt; 999999999999999.999
+				OR `on_hand_before` * #{ratio} &lt;&gt; ROUND(`on_hand_before` * #{ratio}, 3) OR ABS(`on_hand_before` * #{ratio}) &gt; 999999999999999.999
+				OR `on_hand_after` * #{ratio} &lt;&gt; ROUND(`on_hand_after` * #{ratio}, 3) OR ABS(`on_hand_after` * #{ratio}) &gt; 999999999999999.999
+				OR `reserved_before` * #{ratio} &lt;&gt; ROUND(`reserved_before` * #{ratio}, 3) OR ABS(`reserved_before` * #{ratio}) &gt; 999999999999999.999
+				OR `reserved_after` * #{ratio} &lt;&gt; ROUND(`reserved_after` * #{ratio}, 3) OR ABS(`reserved_after` * #{ratio}) &gt; 999999999999999.999)
+			UNION ALL SELECT 1 FROM `gao_point_redemption` WHERE `sku_id_snapshot` = #{skuId}
+				AND (`base_quantity` * #{ratio} &lt;&gt; ROUND(`base_quantity` * #{ratio}, 3) OR ABS(`base_quantity` * #{ratio}) &gt; 999999999999999.999)
+			UNION ALL SELECT 1 FROM `gao_point_redemption_return` r
+				JOIN `gao_point_redemption` d ON d.`id` = r.`redemption_id`
+				WHERE d.`sku_id_snapshot` = #{skuId}
+				AND (r.`base_quantity` * #{ratio} &lt;&gt; ROUND(r.`base_quantity` * #{ratio}, 3) OR ABS(r.`base_quantity` * #{ratio}) &gt; 999999999999999.999)
+			UNION ALL SELECT 1 FROM `gao_product_sku_unit` WHERE `sku_id` = #{skuId} AND `deleted_at` IS NULL
+				AND (#{targetUnitId} IS NULL OR `id` &lt;&gt; #{targetUnitId})
+				AND (`base_quantity_per_unit` * #{ratio} &lt;&gt; ROUND(`base_quantity_per_unit` * #{ratio}, 6) OR ABS(`base_quantity_per_unit` * #{ratio}) &gt; 999999999999.999999)
+			UNION ALL SELECT 1 FROM `gao_sales_order_item` WHERE `sku_id` = #{skuId}
+				AND (ABS(`base_quantity_per_unit_snapshot` * #{ratio}) &gt; 999999999999.999999 OR `base_quantity_per_unit_snapshot` * #{ratio} &lt;&gt; ROUND(`base_quantity_per_unit_snapshot` * #{ratio}, 6))
+			UNION ALL SELECT 1 FROM `gao_order_fulfillment_item` WHERE `sku_id` = #{skuId}
+				AND (ABS(`base_quantity_per_unit_snapshot` * #{ratio}) &gt; 999999999999.999999 OR `base_quantity_per_unit_snapshot` * #{ratio} &lt;&gt; ROUND(`base_quantity_per_unit_snapshot` * #{ratio}, 6))
+			UNION ALL SELECT 1 FROM `gao_product_stock_record` WHERE `sku_id` = #{skuId}
+				AND (ABS(`base_quantity_per_unit_snapshot` * #{ratio}) &gt; 999999999999.999999 OR `base_quantity_per_unit_snapshot` * #{ratio} &lt;&gt; ROUND(`base_quantity_per_unit_snapshot` * #{ratio}, 6))
+			UNION ALL SELECT 1 FROM `gao_package_config_item` WHERE `sku_id` = #{skuId}
+				AND (ABS(`base_quantity_per_unit_snapshot` * #{ratio}) &gt; 999999999999.999999 OR `base_quantity_per_unit_snapshot` * #{ratio} &lt;&gt; ROUND(`base_quantity_per_unit_snapshot` * #{ratio}, 6))
+			UNION ALL SELECT 1 FROM `gao_package_config_item` WHERE `sku_id` = #{skuId}
+				AND (`default_quantity` * `base_quantity_per_unit_snapshot` * #{ratio} &lt;&gt; ROUND(`default_quantity` * `base_quantity_per_unit_snapshot` * #{ratio}, 3)
+				OR ABS(`default_quantity` * `base_quantity_per_unit_snapshot` * #{ratio}) &gt; 999999999999999.999)
+			UNION ALL SELECT 1 FROM `gao_point_redemption` WHERE `sku_id_snapshot` = #{skuId}
+				AND (ABS(`base_quantity_per_unit_snapshot` * #{ratio}) &gt; 999999999999.999999 OR `base_quantity_per_unit_snapshot` * #{ratio} &lt;&gt; ROUND(`base_quantity_per_unit_snapshot` * #{ratio}, 6))
+		) precision_issue
+	</select>
+	<update id="updateProductOrderSnapshots">UPDATE `gao_sales_order_item` SET `product_name_snapshot`=#{productName} WHERE `product_id_snapshot`=#{productId}</update>
+	<update id="updateProductFulfillmentSnapshots">UPDATE `gao_order_fulfillment_item` SET `product_name_snapshot`=#{productName} WHERE `product_id_snapshot`=#{productId}</update>
+	<update id="updateProductStockRecordSnapshots">UPDATE `gao_product_stock_record` SET `product_name_snapshot`=#{productName} WHERE `product_id_snapshot`=#{productId}</update>
+	<update id="updateProductPackageSnapshots">UPDATE `gao_package_config_item` SET `product_name_snapshot`=#{productName} WHERE `product_id_snapshot`=#{productId}</update>
+	<update id="updateProductRedemptionSnapshots">UPDATE `gao_point_redemption` SET `product_name_snapshot`=#{productName} WHERE `product_id_snapshot`=#{productId}</update>
+	<update id="updateSkuOrderSnapshots">UPDATE `gao_sales_order_item` SET `sku_code_snapshot`=#{skuCode}, `sku_name_snapshot`=#{skuName}, `spec_summary_snapshot`=#{specSummary}, `sku_spec_snapshot`=#{skuSpecSnapshot} WHERE `sku_id`=#{skuId}</update>
+	<update id="updateSkuFulfillmentSnapshots">UPDATE `gao_order_fulfillment_item` SET `sku_code_snapshot`=#{skuCode}, `sku_name_snapshot`=#{skuName}, `spec_summary_snapshot`=#{specSummary}, `sku_spec_snapshot`=#{skuSpecSnapshot} WHERE `sku_id`=#{skuId}</update>
+	<update id="updateSkuStockRecordSnapshots">UPDATE `gao_product_stock_record` SET `sku_code_snapshot`=#{skuCode}, `sku_name_snapshot`=#{skuName}, `spec_summary_snapshot`=#{specSummary}, `sku_spec_snapshot`=#{skuSpecSnapshot} WHERE `sku_id`=#{skuId}</update>
+	<update id="updateSkuPackageSnapshots">UPDATE `gao_package_config_item` SET `sku_code_snapshot`=#{skuCode}, `sku_name_snapshot`=#{skuName}, `spec_summary_snapshot`=#{specSummary} WHERE `sku_id`=#{skuId}</update>
+	<update id="updateSkuRedemptionSnapshots">UPDATE `gao_point_redemption` SET `sku_code_snapshot`=#{skuCode}, `sku_name_snapshot`=#{skuName}, `sku_spec_snapshot`=#{skuSpecSnapshot} WHERE `sku_id_snapshot`=#{skuId}</update>
+	<update id="updateUnitOrderSnapshots">UPDATE `gao_sales_order_item` SET `unit_snapshot`=#{unitName} WHERE `sku_unit_id`=#{unitId}</update>
+	<update id="updateUnitFulfillmentSnapshots">UPDATE `gao_order_fulfillment_item` SET `unit_snapshot`=#{unitName} WHERE `sku_unit_id`=#{unitId}</update>
+	<update id="updateUnitStockRecordSnapshots">UPDATE `gao_product_stock_record` SET `unit_snapshot`=#{unitName} WHERE `sku_unit_id`=#{unitId}</update>
+	<update id="updateUnitPackageSnapshots">UPDATE `gao_package_config_item` SET `unit_snapshot`=#{unitName} WHERE `sku_unit_id`=#{unitId}</update>
+	<update id="updateUnitRedemptionSnapshots">UPDATE `gao_point_redemption` SET `unit_snapshot`=#{unitName} WHERE `sku_unit_id_snapshot`=#{unitId}</update>
+	<update id="scaleSkuMinimumStock">UPDATE `gao_product_sku` SET `min_stock_quantity`=`min_stock_quantity`*#{ratio} WHERE `id`=#{skuId} AND `min_stock_quantity` IS NOT NULL</update>
+	<update id="scaleProductStock">UPDATE `gao_product_stock` SET `on_hand_quantity`=`on_hand_quantity`*#{ratio}, `reserved_quantity`=`reserved_quantity`*#{ratio}, `updated_at`=FLOOR(UNIX_TIMESTAMP(NOW(3))*1000) WHERE `sku_id`=#{skuId}</update>
+	<update id="scaleSalesOrderItems">UPDATE `gao_sales_order_item` SET `base_quantity`=`base_quantity`*#{ratio}, `reserved_base_quantity`=`reserved_base_quantity`*#{ratio}, `fulfilled_base_quantity`=`fulfilled_base_quantity`*#{ratio}, `base_quantity_per_unit_snapshot`=`base_quantity_per_unit_snapshot`*#{ratio} WHERE `sku_id`=#{skuId}</update>
+	<update id="scaleFulfillmentItems">UPDATE `gao_order_fulfillment_item` SET `base_quantity`=`base_quantity`*#{ratio}, `reserved_base_before`=`reserved_base_before`*#{ratio}, `reserved_base_after`=`reserved_base_after`*#{ratio}, `fulfilled_base_before`=`fulfilled_base_before`*#{ratio}, `fulfilled_base_after`=`fulfilled_base_after`*#{ratio}, `base_quantity_per_unit_snapshot`=`base_quantity_per_unit_snapshot`*#{ratio} WHERE `sku_id`=#{skuId}</update>
+	<update id="scaleStockRecords">UPDATE `gao_product_stock_record` SET `base_quantity`=`base_quantity`*#{ratio}, `on_hand_delta`=`on_hand_delta`*#{ratio}, `reserved_delta`=`reserved_delta`*#{ratio}, `on_hand_before`=`on_hand_before`*#{ratio}, `on_hand_after`=`on_hand_after`*#{ratio}, `reserved_before`=`reserved_before`*#{ratio}, `reserved_after`=`reserved_after`*#{ratio}, `base_quantity_per_unit_snapshot`=`base_quantity_per_unit_snapshot`*#{ratio} WHERE `sku_id`=#{skuId}</update>
+	<update id="scalePackageConfigItems">UPDATE `gao_package_config_item` SET `base_quantity_per_unit_snapshot`=`base_quantity_per_unit_snapshot`*#{ratio} WHERE `sku_id`=#{skuId}</update>
+	<update id="scalePointRedemptions">UPDATE `gao_point_redemption` SET `base_quantity`=`base_quantity`*#{ratio}, `base_quantity_per_unit_snapshot`=`base_quantity_per_unit_snapshot`*#{ratio} WHERE `sku_id_snapshot`=#{skuId}</update>
+	<update id="scalePointRedemptionReturns">
+		UPDATE `gao_point_redemption_return` r
+		JOIN `gao_point_redemption` d ON d.`id`=r.`redemption_id`
+		SET r.`base_quantity`=r.`base_quantity`*#{ratio}
+		WHERE d.`sku_id_snapshot`=#{skuId}
+	</update>
+</mapper>

src/main/resources/mapper/timi-server/gao/GaoProductSpecMapper.xml

@@ -5,4 +5,5 @@
 	<select id="selectByProductIdList" resultType="com.imyeyu.api.modules.gao.entity.GaoProductSpec">SELECT * FROM `gao_product_spec` WHERE `deleted_at` IS NULL <choose><when test="productIdList != null and !productIdList.isEmpty()">AND `product_id` IN <foreach collection="productIdList" item="id" open="(" separator="," close=")">#{id}</foreach></when><otherwise>AND FALSE</otherwise></choose> ORDER BY `product_id`, `sort`, `created_at`</select>
 	<select id="selectProductIdBySpecValueId" resultType="string">SELECT `s`.`product_id` FROM `gao_product_spec_value` `v` INNER JOIN `gao_product_spec` `s` ON `s`.`id`=`v`.`spec_id` AND `s`.`deleted_at` IS NULL WHERE `v`.`id`=#{specValueId} AND `v`.`deleted_at` IS NULL</select>
 	<select id="selectProductIdBySpecId" resultType="string">SELECT `product_id` FROM `gao_product_spec` WHERE `id`=#{specId} AND `deleted_at` IS NULL</select>
+	<update id="updateSpec">UPDATE `gao_product_spec` SET `name`=#{name},`sort`=#{sort},`updated_at`=FLOOR(UNIX_TIMESTAMP(NOW(3))*1000) WHERE `id`=#{id} AND `deleted_at` IS NULL</update>
 </mapper>

src/main/resources/mapper/timi-server/gao/GaoProductSpecValueMapper.xml

@@ -3,4 +3,5 @@
 <mapper namespace="com.imyeyu.api.modules.gao.mapper.GaoProductSpecValueMapper">
 	<select id="selectById" resultType="com.imyeyu.api.modules.gao.entity.GaoProductSpecValue">SELECT * FROM `gao_product_spec_value` WHERE `id` = #{id} AND `deleted_at` IS NULL</select>
 	<select id="selectBySpecIdList" resultType="com.imyeyu.api.modules.gao.entity.GaoProductSpecValue">SELECT * FROM `gao_product_spec_value` WHERE `deleted_at` IS NULL <choose><when test="specIdList != null and !specIdList.isEmpty()">AND `spec_id` IN <foreach collection="specIdList" item="id" open="(" separator="," close=")">#{id}</foreach></when><otherwise>AND FALSE</otherwise></choose> ORDER BY `spec_id`, `sort`, `created_at`</select>
+	<update id="updateValue">UPDATE `gao_product_spec_value` SET `name`=#{name},`sort`=#{sort},`updated_at`=FLOOR(UNIX_TIMESTAMP(NOW(3))*1000) WHERE `id`=#{id} AND `deleted_at` IS NULL</update>
 </mapper>

src/main/resources/mapper/timi-server/gao/GaoProductStockMapper.xml

@@ -84,6 +84,7 @@
 			p.`name` AS `product_name`,
 			p.`product_type`,
 			COUNT(k.`id`) AS `sku_count`,
+			CASE WHEN COUNT(k.`id`) = 1 THEN MAX(k.`id`) END AS `sku_id`,
 			COALESCE(SUM(COALESCE(s.`on_hand_quantity`, 0)), 0) AS `on_hand_quantity`,
 			COALESCE(SUM(COALESCE(s.`reserved_quantity`, 0)), 0) AS `reserved_quantity`,
 			COALESCE(SUM(COALESCE(s.`on_hand_quantity`, 0) - COALESCE(s.`reserved_quantity`, 0)), 0) AS `available_quantity`

src/main/resources/mapper/timi-server/gao/GaoProductStockRecordMapper.xml

@@ -31,6 +31,7 @@
 		1 = 1
 		<if test="storeId != null and storeId != ''">AND r.`store_id` = #{storeId}</if>
 		<if test="productId != null and productId != ''">AND k.`product_id` = #{productId}</if>
+		<if test="skuId != null and skuId != ''">AND r.`sku_id` = #{skuId}</if>
 		<if test="keyword != null and keyword.trim() != ''">AND (r.`product_name_snapshot` LIKE CONCAT('%', #{keyword}, '%') OR p.`name` LIKE CONCAT('%', #{keyword}, '%') OR p.`name_pinyin_full` LIKE CONCAT(#{keyword}, '%') OR p.`name_pinyin_initial` LIKE CONCAT(#{keyword}, '%') OR p.`name_pinyin_mixed` LIKE CONCAT(#{keyword}, '%') OR p.`code` LIKE CONCAT('%', #{keyword}, '%'))</if>
 		<if test="bizType != null">AND r.`biz_type` = #{bizType}</if>
 		<if test="bizId != null and bizId != ''">AND r.`biz_id` = #{bizId}</if>

src/main/resources/mapper/timi-server/gao/GaoSalesOrderMapper.xml

@@ -23,10 +23,50 @@
 		o.`deleted_at` IS NULL
 		<if test="storeId != null and storeId != ''">AND o.`store_id` = #{storeId}</if>
 		<if test="customerId != null and customerId != ''">AND o.`customer_id` = #{customerId}</if>
-		<if test="orderType != null">AND o.`order_type` = #{orderType}</if>
+		<if test="packageConfigId != null and packageConfigId != ''">
-		<if test="status != null">AND o.`status` = #{status}</if>
+			AND EXISTS (
-		<if test="paymentStatus != null">AND o.`payment_status` = #{paymentStatus}</if>
+				SELECT 1 FROM `gao_customer_package` cp
-		<if test="refundStatus != null">AND o.`refund_status` = #{refundStatus}</if>
+				WHERE cp.`sales_order_id` = o.`id`
+				AND cp.`package_config_id` = #{packageConfigId}
+				AND cp.`deleted_at` IS NULL
+			)
+		</if>
+		<choose>
+			<when test="orderTypeList != null and 0 &lt; orderTypeList.size()">
+				AND o.`order_type` IN
+				<foreach collection="orderTypeList" item="orderTypeItem" open="(" separator="," close=")">
+					#{orderTypeItem}
+				</foreach>
+			</when>
+			<when test="orderType != null">AND o.`order_type` = #{orderType}</when>
+		</choose>
+		<choose>
+			<when test="statusList != null and 0 &lt; statusList.size()">
+				AND o.`status` IN
+				<foreach collection="statusList" item="statusItem" open="(" separator="," close=")">
+					#{statusItem}
+				</foreach>
+			</when>
+			<when test="status != null">AND o.`status` = #{status}</when>
+		</choose>
+		<choose>
+			<when test="paymentStatusList != null and 0 &lt; paymentStatusList.size()">
+				AND o.`payment_status` IN
+				<foreach collection="paymentStatusList" item="paymentStatusItem" open="(" separator="," close=")">
+					#{paymentStatusItem}
+				</foreach>
+			</when>
+			<when test="paymentStatus != null">AND o.`payment_status` = #{paymentStatus}</when>
+		</choose>
+		<choose>
+			<when test="refundStatusList != null and 0 &lt; refundStatusList.size()">
+				AND o.`refund_status` IN
+				<foreach collection="refundStatusList" item="refundStatusItem" open="(" separator="," close=")">
+					#{refundStatusItem}
+				</foreach>
+			</when>
+			<when test="refundStatus != null">AND o.`refund_status` = #{refundStatus}</when>
+		</choose>
 		<if test="pendingReceive != null and pendingReceive">AND o.`status` IN ('ACTIVE', 'FULFILLED') AND o.`payment_status` IN ('UNPAID', 'PARTIALLY_PAID')</if>
 		<if test="fulfilledButUnpaid != null and fulfilledButUnpaid">AND o.`status` = 'FULFILLED' AND o.`paid_amount` &lt; o.`sale_amount`</if>
 		<if test="keyword != null and keyword.trim() != ''">AND (o.`order_no` LIKE CONCAT('%', #{keyword}, '%') OR c.`name` LIKE CONCAT('%', #{keyword}, '%') OR c.`code` LIKE CONCAT('%', #{keyword}, '%'))</if>
@@ -41,6 +81,76 @@
 		ORDER BY o.`purchased_at` DESC, o.`created_at` DESC
 		LIMIT #{offset}, #{limit}
 	</select>
+	<select id="selectSummaryByQuery" resultType="com.imyeyu.api.modules.gao.vo.GaoSalesOrderReceivableStatView">
+		SELECT
+			COUNT(1) AS `orderCount`,
+			COALESCE(SUM(o.`sale_amount`), 0) AS `saleAmount`,
+			COALESCE(SUM(o.`paid_amount`), 0) AS `paidAmount`,
+			COALESCE(SUM(o.`pending_paid_amount`), 0) AS `pendingPaidAmount`,
+			COALESCE(SUM(o.`sale_amount` - o.`paid_amount`), 0) AS `unpaidAmount`,
+			COALESCE(SUM(o.`refunded_amount`), 0) AS `refundedAmount`,
+			COALESCE(SUM(o.`paid_amount` - o.`refunded_amount`), 0) AS `netPaidAmount`
+		FROM `gao_sales_order` o LEFT JOIN `gao_customer` c ON c.`id` = o.`customer_id`
+		WHERE <include refid="queryWhere"/>
+	</select>
+	<sql id="customerProductWhere">
+		i.`deleted_at` IS NULL
+		AND o.`deleted_at` IS NULL
+		AND o.`store_id` = #{storeId}
+		AND o.`status` &lt;&gt; 'CANCELLED'
+		<if test="customerId != null and customerId != ''">AND o.`customer_id` = #{customerId}</if>
+		<if test="customerIdList != null and customerIdList.size() &gt; 0">
+			AND o.`customer_id` IN
+			<foreach collection="customerIdList" item="customerIdItem" open="(" separator="," close=")">
+				#{customerIdItem}
+			</foreach>
+		</if>
+		<if test="itemType != null">AND i.`item_type` = #{itemType}</if>
+		<if test="keyword != null and keyword.trim() != ''">
+			AND (
+				c.`name` LIKE CONCAT('%', #{keyword}, '%')
+				OR c.`code` LIKE CONCAT('%', #{keyword}, '%')
+				OR o.`order_no` LIKE CONCAT('%', #{keyword}, '%')
+				OR i.`product_name_snapshot` LIKE CONCAT('%', #{keyword}, '%')
+				OR i.`sku_name_snapshot` LIKE CONCAT('%', #{keyword}, '%')
+				OR i.`sku_code_snapshot` LIKE CONCAT('%', #{keyword}, '%')
+				OR i.`spec_summary_snapshot` LIKE CONCAT('%', #{keyword}, '%')
+			)
+		</if>
+	</sql>
+	<select id="countCustomerProductCustomerByQuery" resultType="long">
+		SELECT COUNT(DISTINCT o.`customer_id`)
+		FROM `gao_sales_order_item` i
+		JOIN `gao_sales_order` o ON o.`id` = i.`sales_order_id`
+		LEFT JOIN `gao_customer` c ON c.`id` = o.`customer_id`
+		WHERE <include refid="customerProductWhere"/>
+	</select>
+	<select id="selectCustomerProductCustomerByQuery" resultType="com.imyeyu.api.modules.gao.vo.GaoCustomerProductCustomerRow">
+		SELECT o.`customer_id`, c.`code` AS `customer_code`, c.`name` AS `customer_name`, COUNT(DISTINCT o.`id`) AS `order_count`
+		FROM `gao_sales_order_item` i
+		JOIN `gao_sales_order` o ON o.`id` = i.`sales_order_id`
+		LEFT JOIN `gao_customer` c ON c.`id` = o.`customer_id`
+		WHERE <include refid="customerProductWhere"/>
+		GROUP BY o.`customer_id`, c.`code`, c.`name`
+		ORDER BY c.`name` ASC, c.`code` ASC, o.`customer_id` ASC
+		LIMIT #{offset}, #{limit}
+	</select>
+	<select id="selectCustomerProductByQuery" resultType="com.imyeyu.api.modules.gao.vo.GaoCustomerProductView">
+		SELECT i.`id`, i.`sales_order_id`, o.`customer_id`, c.`code` AS `customer_code`, c.`name` AS `customer_name`,
+			o.`order_no`, o.`order_type`, o.`status` AS `order_status`, o.`purchased_at`,
+			i.`item_type`, i.`gifted`, i.`sku_id`, i.`sku_unit_id`, i.`product_name_snapshot`, i.`product_id_snapshot`,
+			i.`sku_code_snapshot`, i.`sku_name_snapshot`, i.`spec_summary_snapshot`, i.`unit_snapshot`, base_unit.`name` AS `base_unit_name`,
+			i.`base_quantity_per_unit_snapshot`, i.`quantity`, i.`base_quantity`, i.`reserved_base_quantity`,
+			i.`fulfilled_base_quantity`,
+			COALESCE(i.`base_quantity`, 0) - COALESCE(i.`fulfilled_base_quantity`, 0) AS `remaining_base_quantity`,
+			COALESCE(i.`base_quantity`, 0) - COALESCE(i.`reserved_base_quantity`, 0) - COALESCE(i.`fulfilled_base_quantity`, 0) AS `available_base_quantity`
+		FROM `gao_sales_order_item` i
+		JOIN `gao_sales_order` o ON o.`id` = i.`sales_order_id`
+		LEFT JOIN `gao_customer` c ON c.`id` = o.`customer_id`
+		LEFT JOIN `gao_product_sku_unit` base_unit ON base_unit.`sku_id` = i.`sku_id` AND base_unit.`is_base` = 1 AND base_unit.`deleted_at` IS NULL
+		WHERE <include refid="customerProductWhere"/>
+		ORDER BY o.`purchased_at` DESC, o.`created_at` DESC, i.`sort` ASC, i.`created_at` ASC
+	</select>
 	<update id="updatePayment">
 		UPDATE `gao_sales_order`
 		SET `pending_paid_amount` = #{pendingPaidAmount}, `paid_amount` = #{paidAmount}, `paid_at` = #{paidAt}, `refunded_amount` = #{refundedAmount},

src/main/resources/templates/GaoOrderReminder.ftl

@@ -0,0 +1,21 @@
+<div class="gao-order-reminder">
+	<p>以下订单存在待处理事项，请及时处理。</p>
+	<#list customerList as customer>
+		<h3>客户：${customer.name?html}</h3>
+		<#list customer.orderList as order>
+			<p><strong>订单号：${order.orderNo?html}</strong></p>
+			<ul>
+				<li><strong>订单状态：</strong>${order.orderStatus?html}</li>
+				<li><strong>付款状态：</strong>${order.paymentStatus?html}</li>
+				<li><strong>金额情况：</strong>${order.amountSummary?html}</li>
+				<li><strong>履约情况：</strong>${order.fulfillmentSummary?html}</li>
+			</ul>
+			<p>
+				<a
+					href="/management/sales-orders/${order.orderId?html}"
+					style="display: inline-block; padding: 6px 12px; color: #FFFFFF; background-color: #1677FF; text-decoration: none; border-radius: 4px;"
+				>查看订单详情</a>
+			</p>
+		</#list>
+	</#list>
+</div>