add customer followup

This commit is contained in:
Timi
2026-09-18 01:47:54 +08:00
parent b5a7c0d46c
commit 8f2545f271
22 changed files with 1262 additions and 5 deletions
@@ -56,6 +56,8 @@ public class Attachment extends UUIDEntity {
GAO_POINT_REDEMPTION_RETURN,
GAO_CUSTOMER_FOLLOW_UP_REMINDER,
TEMP_FILE,
MIRROR
@@ -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
@@ -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 分页参数
@@ -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 分页参数
@@ -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";
@@ -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
@@ -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 通知
@@ -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),
@@ -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();
}
}
@@ -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()));
gaoUser.getUser().setRoleEntityList(roleMap.get(gaoUser.getUserId()));
User user = userMap.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;
@@ -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;
}
}
@@ -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);
}
@@ -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();
}
@@ -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) {
}
}
@@ -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()));
}
@@ -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);
}
}
}
@@ -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;
}
@@ -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> {
}