package cn.iocoder.yudao.module.wxcp.service.activity;
|
|
import cn.hutool.core.collection.CollUtil;
|
import cn.hutool.core.util.StrUtil;
|
import cn.iocoder.yudao.framework.common.pojo.PageResult;
|
import cn.iocoder.yudao.framework.common.util.object.BeanUtils;
|
import cn.iocoder.yudao.module.system.controller.admin.storage.vo.SystemStorageAttachmentListReqVO;
|
import cn.iocoder.yudao.module.system.controller.admin.storage.vo.SystemStorageAttachmentSaveReqVO;
|
import cn.iocoder.yudao.module.system.controller.admin.storage.vo.SystemStorageBlobRespVO;
|
import cn.iocoder.yudao.module.system.dal.dataobject.storage.SystemStorageBlobDO;
|
import cn.iocoder.yudao.module.system.service.storage.SystemStorageAttachmentService;
|
import cn.iocoder.yudao.module.system.service.storage.SystemStorageBlobService;
|
import cn.iocoder.yudao.module.wxcp.controller.admin.activity.vo.*;
|
import cn.iocoder.yudao.module.wxcp.dal.dataobject.activity.WxCpActivityDO;
|
import cn.iocoder.yudao.module.wxcp.dal.dataobject.activity.WxCpActivityFieldDO;
|
import cn.iocoder.yudao.module.wxcp.dal.dataobject.activity.WxCpActivitySignupDO;
|
import cn.iocoder.yudao.module.wxcp.dal.dataobject.activity.WxCpActivitySignupValueDO;
|
import cn.iocoder.yudao.module.wxcp.dal.mysql.activity.WxCpActivityFieldMapper;
|
import cn.iocoder.yudao.module.wxcp.dal.mysql.activity.WxCpActivityMapper;
|
import cn.iocoder.yudao.module.wxcp.dal.mysql.activity.WxCpActivitySignupMapper;
|
import cn.iocoder.yudao.module.wxcp.dal.mysql.activity.WxCpActivitySignupValueMapper;
|
import cn.iocoder.yudao.module.wxcp.enums.activity.WxCpActivityStatusEnum;
|
import cn.iocoder.yudao.module.wxcp.enums.activity.WxCpActivityTypeEnum;
|
import cn.iocoder.yudao.module.wxcp.enums.activity.WxCpPushScopeEnum;
|
import cn.iocoder.yudao.module.wxcp.enums.activity.WxCpSignupStatusEnum;
|
import cn.iocoder.yudao.module.wxcp.controller.admin.vo.WxCpPushReqVO;
|
import cn.iocoder.yudao.module.wxcp.controller.admin.vo.WxCpPushResultVO;
|
import cn.iocoder.yudao.module.wxcp.framework.config.WxCpProperties;
|
import cn.iocoder.yudao.module.wxcp.framework.qrcode.WxCpQrCodeUtil;
|
import cn.iocoder.yudao.module.wxcp.service.push.WxCpMessagePushService;
|
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
|
import jakarta.annotation.Resource;
|
import lombok.extern.slf4j.Slf4j;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.springframework.validation.annotation.Validated;
|
|
import java.io.File;
|
import java.time.LocalDateTime;
|
import java.time.format.DateTimeFormatter;
|
import java.util.ArrayList;
|
import java.util.Collections;
|
import java.util.Comparator;
|
import java.util.LinkedHashMap;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Objects;
|
import java.util.Set;
|
import java.util.TreeMap;
|
import java.util.stream.Collectors;
|
|
import static cn.iocoder.yudao.framework.common.exception.util.ServiceExceptionUtil.exception;
|
import static cn.iocoder.yudao.module.wxcp.enums.ErrorCodeConstants.*;
|
|
/**
|
* 企业微信活动 Service 实现类
|
*
|
* @author 超级管理员
|
*/
|
@Service
|
@Validated
|
@Slf4j
|
public class WxCpActivityServiceImpl implements WxCpActivityService {
|
|
private static final DateTimeFormatter TIME_FMT = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm");
|
|
/**
|
* 企业微信文本消息约 2048 字节，中文按 3 字节算，这里按字符数留余量
|
*/
|
private static final int MAX_PUSH_CONTENT_LENGTH = 600;
|
|
/**
|
* 报名附件的关联记录类型，对应 system_storage_attachment.record_type
|
*/
|
public static final String SIGNUP_RECORD_TYPE = "wxcp_activity_signup";
|
|
/**
|
* 活动封面的关联记录类型，对应 system_storage_attachment.record_type
|
*/
|
public static final String ACTIVITY_RECORD_TYPE = "wxcp_activity";
|
|
/**
|
* 活动详情图片的关联记录类型，对应 system_storage_attachment.record_type
|
*
|
* 与封面分开存：封面只允许 1 张、报名页顶部裁剪展示；
|
* 详情图可以多张、报名页按原图比例完整展示（二维码/海报这类不能裁的图放这里）。
|
*/
|
public static final String ACTIVITY_DETAIL_RECORD_TYPE = "wxcp_activity_detail";
|
|
/**
|
* 图片通知模板的图片关联记录类型
|
*/
|
public static final String ACTIVITY_IMAGE_RECORD_TYPE = "wxcp_activity_image";
|
|
/**
|
* 附件通知模板的附件关联记录类型
|
*/
|
public static final String ACTIVITY_FILE_RECORD_TYPE = "wxcp_activity_file";
|
|
/**
|
* 附件用途，与其它模块保持一致
|
*/
|
private static final String ATTACHMENT_APPLICATION = "file";
|
|
/**
|
* 企业微信文件消息上限 20MB
|
*/
|
private static final long MAX_FILE_SIZE = 20L * 1024L * 1024L;
|
|
/**
|
* 默认评价最高星级
|
*/
|
private static final int DEFAULT_RATING_MAX = 5;
|
|
@Resource
|
private WxCpActivityMapper wxcpActivityMapper;
|
@Resource
|
private WxCpActivitySignupMapper wxcpSignupMapper;
|
@Resource
|
private WxCpActivityFieldMapper activityFieldMapper;
|
@Resource
|
private WxCpActivitySignupValueMapper signupValueMapper;
|
|
@Resource
|
private SystemStorageAttachmentService storageAttachmentService;
|
@Resource
|
private SystemStorageBlobService storageBlobService;
|
|
@Resource
|
private WxCpMessagePushService messagePushService;
|
@Resource
|
private WxCpProperties wxCpProperties;
|
|
// ==================== 活动管理 ====================
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public Long createActivity(WxCpActivitySaveReqVO createReqVO) {
|
WxCpActivityDO activity = BeanUtils.toBean(createReqVO, WxCpActivityDO.class);
|
// 新建的一律是草稿，避免未配置完就被扫码报名
|
activity.setStatus(WxCpActivityStatusEnum.DRAFT.getStatus());
|
activity.setSignupCount(0);
|
activity.setPushStatus(0);
|
// 模板类型：默认「数据采集/评价」，与改造前的报名活动行为保持一致
|
if (activity.getActivityType() == null) {
|
activity.setActivityType(WxCpActivityTypeEnum.FORM.getType());
|
}
|
if (activity.getRatingMax() == null || activity.getRatingMax() <= 0) {
|
activity.setRatingMax(DEFAULT_RATING_MAX);
|
}
|
if (activity.getRatingEnabled() == null) {
|
activity.setRatingEnabled(Boolean.FALSE);
|
}
|
// 报名上限只对数据采集模板有意义；其它模板不传时按不限处理，避免接口强校验
|
if (activity.getSignupLimit() == null) {
|
activity.setSignupLimit(0);
|
}
|
if (StrUtil.isBlank(activity.getButtonText())) {
|
activity.setButtonText(defaultButtonText(activity.getActivityType()));
|
}
|
// 推送范围选填，不传默认全员；推送时还能在弹窗里改
|
if (activity.getPushScope() == null) {
|
activity.setPushScope(WxCpPushScopeEnum.ALL.getScope());
|
}
|
wxcpActivityMapper.insert(activity);
|
// 封面走 system 的附件中间表，业务表不落文件地址字段
|
if (CollUtil.isNotEmpty(createReqVO.getBlobIds())) {
|
bindActivityAttachments(activity.getId(), createReqVO.getBlobIds());
|
}
|
// 详情图片同样走附件中间表，与封面分开存，互不影响
|
if (CollUtil.isNotEmpty(createReqVO.getDetailBlobIds())) {
|
bindActivityDetailAttachments(activity.getId(), createReqVO.getDetailBlobIds());
|
}
|
// 图片通知 / 附件通知的素材也走附件中间表，各自独立 recordType
|
if (CollUtil.isNotEmpty(createReqVO.getImageBlobIds())) {
|
bindAttachments(ACTIVITY_IMAGE_RECORD_TYPE, activity.getId(), createReqVO.getImageBlobIds());
|
}
|
if (CollUtil.isNotEmpty(createReqVO.getFileBlobIds())) {
|
bindAttachments(ACTIVITY_FILE_RECORD_TYPE, activity.getId(), createReqVO.getFileBlobIds());
|
}
|
// 数据采集模板的自定义字段
|
if (CollUtil.isNotEmpty(createReqVO.getFieldList())) {
|
saveActivityFields(activity.getId(), createReqVO.getFieldList());
|
}
|
return activity.getId();
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public void updateActivity(WxCpActivitySaveReqVO updateReqVO) {
|
WxCpActivityDO activity = validateActivityExists(updateReqVO.getId());
|
// 已结束或已取消的活动不再允许修改
|
if (Objects.equals(activity.getStatus(), WxCpActivityStatusEnum.FINISHED.getStatus())
|
|| Objects.equals(activity.getStatus(), WxCpActivityStatusEnum.CANCELED.getStatus())) {
|
throw exception(ACTIVITY_CANNOT_UPDATE);
|
}
|
WxCpActivityDO updateObj = BeanUtils.toBean(updateReqVO, WxCpActivityDO.class);
|
// 以下字段由系统维护，不允许前端覆盖
|
updateObj.setStatus(null);
|
updateObj.setSignupCount(null);
|
updateObj.setPushStatus(null);
|
updateObj.setPushTime(null);
|
wxcpActivityMapper.updateById(updateObj);
|
// blobIds 为 null 表示请求里没带这个字段，视为不改动封面；传空数组才是明确要清空封面
|
if (updateReqVO.getBlobIds() != null) {
|
bindActivityAttachments(activity.getId(), updateReqVO.getBlobIds());
|
}
|
// 详情图片同理：null = 不改动，空数组 = 清空
|
if (updateReqVO.getDetailBlobIds() != null) {
|
bindActivityDetailAttachments(activity.getId(), updateReqVO.getDetailBlobIds());
|
}
|
if (updateReqVO.getImageBlobIds() != null) {
|
bindAttachments(ACTIVITY_IMAGE_RECORD_TYPE, activity.getId(), updateReqVO.getImageBlobIds());
|
}
|
if (updateReqVO.getFileBlobIds() != null) {
|
bindAttachments(ACTIVITY_FILE_RECORD_TYPE, activity.getId(), updateReqVO.getFileBlobIds());
|
}
|
// 字段列表：null = 不改动，空数组 = 清空
|
if (updateReqVO.getFieldList() != null) {
|
activityFieldMapper.deleteByActivityId(activity.getId());
|
if (CollUtil.isNotEmpty(updateReqVO.getFieldList())) {
|
saveActivityFields(activity.getId(), updateReqVO.getFieldList());
|
}
|
}
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public void deleteActivity(Long id) {
|
validateActivityExists(id);
|
wxcpActivityMapper.deleteById(id);
|
// 活动删了，所有附件关系与采集字段一并清掉，避免残留成孤儿数据
|
storageAttachmentService.deleteAttachmentsByRecordTypeAndRecordId(ACTIVITY_RECORD_TYPE, id);
|
storageAttachmentService.deleteAttachmentsByRecordTypeAndRecordId(ACTIVITY_DETAIL_RECORD_TYPE, id);
|
storageAttachmentService.deleteAttachmentsByRecordTypeAndRecordId(ACTIVITY_IMAGE_RECORD_TYPE, id);
|
storageAttachmentService.deleteAttachmentsByRecordTypeAndRecordId(ACTIVITY_FILE_RECORD_TYPE, id);
|
activityFieldMapper.deleteByActivityId(id);
|
signupValueMapper.deleteByActivityId(id);
|
}
|
|
@Override
|
public WxCpActivityDO getActivity(Long id) {
|
return wxcpActivityMapper.selectById(id);
|
}
|
|
@Override
|
public PageResult<WxCpActivityDO> getActivityPage(WxCpActivityPageReqVO pageReqVO) {
|
return wxcpActivityMapper.selectPage(pageReqVO);
|
}
|
|
@Override
|
public List<SystemStorageBlobRespVO> getActivityAttachments(Long activityId) {
|
return listAttachments(ACTIVITY_RECORD_TYPE, activityId);
|
}
|
|
@Override
|
public List<SystemStorageBlobRespVO> getActivityDetailAttachments(Long activityId) {
|
List<SystemStorageBlobRespVO> attachments = listAttachments(ACTIVITY_DETAIL_RECORD_TYPE, activityId);
|
// 多张图必须保证展示顺序稳定：底层是 selectByIds，不承诺返回顺序，
|
// 这里按 blobId 升序（即上传先后）排一遍，避免同一批图每次刷新换位置。
|
return attachments.stream()
|
.sorted(Comparator.comparing(SystemStorageBlobRespVO::getId,
|
Comparator.nullsLast(Comparator.naturalOrder())))
|
.toList();
|
}
|
|
@Override
|
public List<SystemStorageBlobRespVO> getActivityImageAttachments(Long activityId) {
|
return listAttachments(ACTIVITY_IMAGE_RECORD_TYPE, activityId);
|
}
|
|
@Override
|
public List<SystemStorageBlobRespVO> getActivityFileAttachments(Long activityId) {
|
return listAttachments(ACTIVITY_FILE_RECORD_TYPE, activityId);
|
}
|
|
@Override
|
public List<WxCpActivityFieldDO> getActivityFields(Long activityId) {
|
return activityFieldMapper.selectListByActivityId(activityId);
|
}
|
|
@Override
|
public List<WxCpActivitySignupValueDO> getSignupValues(Long signupId) {
|
return signupValueMapper.selectListBySignupId(signupId);
|
}
|
|
/**
|
* 保存活动自定义采集字段
|
*
|
* 先整体清空再插入，保证前端提交的顺序与内容就是最终结果；
|
* 已产生的报名值做字段名/类型快照，不会因为这里重建字段而丢失含义。
|
*/
|
private void saveActivityFields(Long activityId, List<WxCpActivityFieldSaveReqVO> fieldList) {
|
int index = 1;
|
for (WxCpActivityFieldSaveReqVO field : fieldList) {
|
if (field == null || StrUtil.isBlank(field.getFieldLabel())) {
|
throw exception(ACTIVITY_FIELD_LABEL_REQUIRED, index);
|
}
|
String fieldType = StrUtil.blankToDefault(field.getFieldType(), WxCpActivityFieldDO.TYPE_TEXT);
|
boolean needOptions = WxCpActivityFieldDO.TYPE_SELECT.equals(fieldType)
|
|| WxCpActivityFieldDO.TYPE_RADIO.equals(fieldType)
|
|| WxCpActivityFieldDO.TYPE_CHECKBOX.equals(fieldType);
|
if (needOptions && StrUtil.isBlank(field.getFieldOptions())) {
|
throw exception(ACTIVITY_FIELD_OPTIONS_REQUIRED, field.getFieldLabel());
|
}
|
activityFieldMapper.insert(WxCpActivityFieldDO.builder()
|
.activityId(activityId)
|
.fieldLabel(StrUtil.trim(field.getFieldLabel()))
|
.fieldType(fieldType)
|
.fieldOptions(StrUtil.trim(field.getFieldOptions()))
|
.required(Boolean.TRUE.equals(field.getRequired()))
|
.placeholder(StrUtil.trim(field.getPlaceholder()))
|
.sortNo(field.getSortNo() != null ? field.getSortNo() : index)
|
.build());
|
index++;
|
}
|
}
|
|
/**
|
* 绑定活动封面附件
|
*
|
* 走 system 模块的附件中间表（record_type = wxcp_activity），
|
* 业务表不加文件地址列、不自建 upload 接口，符合项目统一文件管理规范。
|
*
|
* 传空集合会清掉关联记录但保留文件本身（bindAttachments 只删中间表记录）。
|
* 注意不要改用 deleteAttachmentsByRecordTypeAndRecordId 来"先删后加"：
|
* 那个方法会连 blob 一起删掉，同一个文件重新绑定时会因为文件已不存在而查不出来。
|
*/
|
private void bindActivityAttachments(Long activityId, List<Long> blobIds) {
|
bindAttachments(ACTIVITY_RECORD_TYPE, activityId, blobIds);
|
}
|
|
/**
|
* 绑定活动详情图片附件（record_type = wxcp_activity_detail），规则同封面
|
*/
|
private void bindActivityDetailAttachments(Long activityId, List<Long> blobIds) {
|
bindAttachments(ACTIVITY_DETAIL_RECORD_TYPE, activityId, blobIds);
|
}
|
|
private void bindAttachments(String recordType, Long activityId, List<Long> blobIds) {
|
SystemStorageAttachmentSaveReqVO bindReqVO = new SystemStorageAttachmentSaveReqVO();
|
bindReqVO.setApplication(ATTACHMENT_APPLICATION);
|
bindReqVO.setRecordType(recordType);
|
bindReqVO.setRecordId(activityId);
|
bindReqVO.setBlobItems(toBlobItems(blobIds));
|
storageAttachmentService.bindAttachments(bindReqVO);
|
}
|
|
private List<SystemStorageAttachmentSaveReqVO.BlobItem> toBlobItems(List<Long> blobIds) {
|
if (CollUtil.isEmpty(blobIds)) {
|
return Collections.emptyList();
|
}
|
return blobIds.stream()
|
.filter(Objects::nonNull)
|
.distinct()
|
.map(blobId -> {
|
SystemStorageAttachmentSaveReqVO.BlobItem item = new SystemStorageAttachmentSaveReqVO.BlobItem();
|
item.setBlobId(blobId);
|
return item;
|
})
|
.toList();
|
}
|
|
private List<SystemStorageBlobRespVO> listAttachments(String recordType, Long recordId) {
|
SystemStorageAttachmentListReqVO listReqVO = new SystemStorageAttachmentListReqVO();
|
listReqVO.setApplication(ATTACHMENT_APPLICATION);
|
listReqVO.setRecordType(recordType);
|
listReqVO.setRecordId(recordId);
|
return storageAttachmentService.listAttachments(listReqVO);
|
}
|
|
@Override
|
public void publishActivity(Long id) {
|
WxCpActivityDO activity = validateActivityExists(id);
|
if (Objects.equals(activity.getStatus(), WxCpActivityStatusEnum.PUBLISHED.getStatus())) {
|
return; // 已发布，幂等返回
|
}
|
if (Objects.equals(activity.getStatus(), WxCpActivityStatusEnum.FINISHED.getStatus())
|
|| Objects.equals(activity.getStatus(), WxCpActivityStatusEnum.CANCELED.getStatus())) {
|
throw exception(ACTIVITY_STATUS_FINISHED);
|
}
|
wxcpActivityMapper.updateById(WxCpActivityDO.builder()
|
.id(id).status(WxCpActivityStatusEnum.PUBLISHED.getStatus()).build());
|
}
|
|
@Override
|
public void finishActivity(Long id) {
|
validateActivityExists(id);
|
wxcpActivityMapper.updateById(WxCpActivityDO.builder()
|
.id(id).status(WxCpActivityStatusEnum.FINISHED.getStatus()).build());
|
}
|
|
@Override
|
public void cancelActivity(Long id) {
|
validateActivityExists(id);
|
wxcpActivityMapper.updateById(WxCpActivityDO.builder()
|
.id(id).status(WxCpActivityStatusEnum.CANCELED.getStatus()).build());
|
}
|
|
// ==================== 推送 ====================
|
|
@Override
|
public WxCpPushResultVO pushActivity(WxCpPushReqVO pushReqVO) {
|
WxCpActivityDO activity = validateActivityExists(pushReqVO.getId());
|
if (!Objects.equals(activity.getStatus(), WxCpActivityStatusEnum.PUBLISHED.getStatus())) {
|
throw exception(ACTIVITY_STATUS_NOT_PUBLISHED);
|
}
|
|
// 推送范围与目标：请求里传了就用请求的，否则沿用活动上配置的
|
Integer scope = pushReqVO.getPushScope() != null ? pushReqVO.getPushScope() : activity.getPushScope();
|
String target = StrUtil.isNotBlank(pushReqVO.getPushTarget())
|
? pushReqVO.getPushTarget() : activity.getPushTarget();
|
if (scope == null) {
|
scope = WxCpPushScopeEnum.ALL.getScope();
|
}
|
|
// 按活动模板类型选择推送形态
|
Integer activityType = activity.getActivityType() != null
|
? activity.getActivityType() : WxCpActivityTypeEnum.FORM.getType();
|
WxCpPushResultVO result;
|
if (Objects.equals(activityType, WxCpActivityTypeEnum.TEXT.getType())) {
|
result = messagePushService.pushText(buildTextContent(activity), scope, target);
|
} else if (Objects.equals(activityType, WxCpActivityTypeEnum.IMAGE.getType())) {
|
result = pushImages(activity, scope, target);
|
} else if (Objects.equals(activityType, WxCpActivityTypeEnum.FILE.getType())) {
|
result = pushFiles(activity, scope, target);
|
} else if (Objects.equals(activityType, WxCpActivityTypeEnum.MESSAGE.getType())) {
|
String url = tryBuildSignupUrl(activity.getId());
|
result = StrUtil.isBlank(url)
|
? messagePushService.pushText(buildTextContent(activity), scope, target)
|
: messagePushService.pushCard(activity.getTitle(), buildMessageDescription(activity),
|
url, pushButtonText(activity), scope, target);
|
} else {
|
// 数据采集/评价：卡片直达采集页，点消息或扫码都能填写
|
result = messagePushService.pushCard(
|
activity.getTitle(), buildPushDescription(activity),
|
buildSignupUrl(activity.getId()), pushButtonText(activity), scope, target);
|
}
|
|
if (Boolean.TRUE.equals(result.getSuccess())) {
|
wxcpActivityMapper.updateById(WxCpActivityDO.builder()
|
.id(activity.getId())
|
.pushScope(scope)
|
.pushTarget(target)
|
.pushStatus(1)
|
.pushTime(LocalDateTime.now())
|
.build());
|
}
|
return result;
|
}
|
|
/**
|
* 拼装推送消息正文
|
*
|
* 只放成员报名前最关心的信息：时间、地点、报名截止；详情让用户点进报名页看
|
*/
|
private String buildPushDescription(WxCpActivityDO activity) {
|
StringBuilder sb = new StringBuilder();
|
if (activity.getStartTime() != null) {
|
sb.append("活动时间：").append(activity.getStartTime().format(TIME_FMT));
|
if (activity.getEndTime() != null) {
|
sb.append(" ~ ").append(activity.getEndTime().format(TIME_FMT));
|
}
|
sb.append("\n");
|
}
|
if (StrUtil.isNotBlank(activity.getLocation())) {
|
sb.append("活动地点：").append(activity.getLocation()).append("\n");
|
}
|
if (activity.getSignupEndTime() != null) {
|
sb.append("报名截止：").append(activity.getSignupEndTime().format(TIME_FMT)).append("\n");
|
}
|
if (activity.getSignupLimit() != null && activity.getSignupLimit() > 0) {
|
sb.append("名额：").append(activity.getSignupCount()).append("/")
|
.append(activity.getSignupLimit()).append("\n");
|
}
|
sb.append("点击下方按钮查看详情并报名");
|
return sb.toString();
|
}
|
|
/**
|
* 纯文本/图片/附件模板的正文：标题 + 时间地点 + 活动详情，过长截断避免整条消息发送失败
|
*/
|
private String buildTextContent(WxCpActivityDO activity) {
|
StringBuilder body = new StringBuilder();
|
if (activity.getStartTime() != null) {
|
body.append("活动时间：").append(activity.getStartTime().format(TIME_FMT));
|
if (activity.getEndTime() != null) {
|
body.append(" ~ ").append(activity.getEndTime().format(TIME_FMT));
|
}
|
body.append("\n");
|
}
|
if (StrUtil.isNotBlank(activity.getLocation())) {
|
body.append("活动地点：").append(activity.getLocation()).append("\n");
|
}
|
if (StrUtil.isNotBlank(activity.getContent())) {
|
body.append(activity.getContent());
|
}
|
String content = "【" + activity.getTitle() + "】\n" + body.toString().trim();
|
if (content.length() > MAX_PUSH_CONTENT_LENGTH) {
|
content = content.substring(0, MAX_PUSH_CONTENT_LENGTH)
|
+ "\n……（内容过长已截断，请到系统内查看完整内容）";
|
}
|
return content;
|
}
|
|
/**
|
* 单条消息模板的卡片正文：活动摘要 + 引导点击
|
*/
|
private String buildMessageDescription(WxCpActivityDO activity) {
|
String body = buildTextContent(activity);
|
// textcard 的 description 约 512 字节，留出余量，避免整条卡片发送失败
|
if (body.length() > 300) {
|
body = body.substring(0, 300) + "……";
|
}
|
return body + "\n点击下方按钮查看详情";
|
}
|
|
private String pushButtonText(WxCpActivityDO activity) {
|
return StrUtil.blankToDefault(activity.getButtonText(),
|
defaultButtonText(activity.getActivityType()));
|
}
|
|
private String defaultButtonText(Integer activityType) {
|
if (Objects.equals(activityType, WxCpActivityTypeEnum.MESSAGE.getType())) {
|
return "查看详情";
|
}
|
return "立即报名";
|
}
|
|
/**
|
* 拼装活动页地址；未配置外网前缀时返回 null，由调用方降级为文本推送
|
*/
|
private String tryBuildSignupUrl(Long id) {
|
try {
|
return buildSignupUrl(id);
|
} catch (Exception e) {
|
log.warn("[tryBuildSignupUrl][未配置活动页外网地址，降级为文本推送 id={}]", id);
|
return null;
|
}
|
}
|
|
/**
|
* 图片通知：先发文字说明，再逐张发送图片
|
*/
|
private WxCpPushResultVO pushImages(WxCpActivityDO activity, Integer scope, String target) {
|
List<SystemStorageBlobRespVO> images = getActivityImageAttachments(activity.getId());
|
if (CollUtil.isEmpty(images)) {
|
throw exception(ACTIVITY_IMAGE_REQUIRED);
|
}
|
List<WxCpPushResultVO> results = new ArrayList<>();
|
// 有正文就先发一条文字说明；文字失败不影响后续图片发送
|
if (StrUtil.isNotBlank(activity.getContent())) {
|
results.add(messagePushService.pushText(buildTextContent(activity), scope, target));
|
}
|
for (SystemStorageBlobRespVO image : images) {
|
SystemStorageBlobDO blob = storageBlobService.getStorageBlob(image.getId());
|
if (blob == null) {
|
throw exception(ACTIVITY_FILE_NOT_EXISTS);
|
}
|
if (StrUtil.isNotBlank(blob.getContentType())
|
&& !StrUtil.startWithIgnoreCase(blob.getContentType(), "image/")) {
|
throw exception(ACTIVITY_IMAGE_ONLY);
|
}
|
File file = storageBlobService.getPublicFile(blob.getUidFilename(), blob.getResourceKey());
|
if (file == null || !file.exists()) {
|
throw exception(ACTIVITY_FILE_NOT_EXISTS);
|
}
|
results.add(messagePushService.pushImage(file, scope, target));
|
}
|
return aggregatePushResults(results, "图片");
|
}
|
|
/**
|
* 附件通知：先发文字说明，再逐个发送文件
|
*/
|
private WxCpPushResultVO pushFiles(WxCpActivityDO activity, Integer scope, String target) {
|
List<SystemStorageBlobRespVO> files = getActivityFileAttachments(activity.getId());
|
if (CollUtil.isEmpty(files)) {
|
throw exception(ACTIVITY_FILE_REQUIRED);
|
}
|
List<WxCpPushResultVO> results = new ArrayList<>();
|
if (StrUtil.isNotBlank(activity.getContent())) {
|
results.add(messagePushService.pushText(buildTextContent(activity), scope, target));
|
}
|
for (SystemStorageBlobRespVO item : files) {
|
SystemStorageBlobDO blob = storageBlobService.getStorageBlob(item.getId());
|
if (blob == null) {
|
throw exception(ACTIVITY_FILE_NOT_EXISTS);
|
}
|
if (blob.getByteSize() != null && blob.getByteSize() > MAX_FILE_SIZE) {
|
throw exception(ACTIVITY_FILE_TOO_LARGE);
|
}
|
File file = storageBlobService.getPublicFile(blob.getUidFilename(), blob.getResourceKey());
|
if (file == null || !file.exists()) {
|
throw exception(ACTIVITY_FILE_NOT_EXISTS);
|
}
|
results.add(messagePushService.pushFile(file, blob.getOriginalFilename(), null, scope, target));
|
}
|
return aggregatePushResults(results, "附件");
|
}
|
|
/**
|
* 多条消息合并结果：任一条失败即视为整体失败，并把失败原因汇总给前端
|
*/
|
private WxCpPushResultVO aggregatePushResults(List<WxCpPushResultVO> results, String label) {
|
if (CollUtil.isEmpty(results)) {
|
return new WxCpPushResultVO(false, null, label + "推送内容为空", null, null);
|
}
|
List<WxCpPushResultVO> failures = results.stream()
|
.filter(r -> !Boolean.TRUE.equals(r.getSuccess()))
|
.toList();
|
if (failures.isEmpty()) {
|
return new WxCpPushResultVO(true, 0, "推送成功", null, null);
|
}
|
String message = failures.stream()
|
.map(WxCpPushResultVO::getMessage)
|
.filter(StrUtil::isNotBlank)
|
.distinct()
|
.collect(Collectors.joining("；"));
|
return new WxCpPushResultVO(false, failures.get(0).getErrCode(),
|
label + "推送失败：" + message, null, null);
|
}
|
|
@Override
|
public byte[] generateSignupQrCode(Long id, int size) {
|
validateActivityExists(id);
|
String url = buildSignupUrl(id);
|
Integer configured = wxCpProperties.getQrcodeSize();
|
int actualSize = size > 0 ? size : (configured != null ? configured : WxCpQrCodeUtil.DEFAULT_SIZE);
|
return WxCpQrCodeUtil.generatePng(url, actualSize);
|
}
|
|
@Override
|
public String buildSignupUrl(Long id) {
|
String prefix = wxCpProperties.getSignupUrlPrefix();
|
if (StrUtil.isBlank(prefix)) {
|
throw exception(QRCODE_SIGNUP_URL_NOT_CONFIGURED);
|
}
|
// 去掉结尾斜杠，避免拼出 //admin-api
|
String base = StrUtil.removeSuffix(prefix.trim(), "/");
|
return base + "/admin-api/wxcp/activity/signup-page?id=" + id;
|
}
|
|
// ==================== 报名 ====================
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public Long createSignup(WxCpSignupPublicReqVO reqVO) {
|
WxCpActivityDO activity = validateActivityExists(reqVO.getActivityId());
|
|
// 1. 活动必须是已发布状态
|
if (!Objects.equals(activity.getStatus(), WxCpActivityStatusEnum.PUBLISHED.getStatus())) {
|
throw exception(SIGNUP_ACTIVITY_NOT_PUBLISHED);
|
}
|
// 只有「数据采集/评价」模板有表单，其它模板只做消息推送
|
Integer activityType = activity.getActivityType() != null
|
? activity.getActivityType() : WxCpActivityTypeEnum.FORM.getType();
|
if (!Objects.equals(activityType, WxCpActivityTypeEnum.FORM.getType())) {
|
throw exception(SIGNUP_NOT_SUPPORTED);
|
}
|
|
// 2. 校验报名时间窗口
|
LocalDateTime now = LocalDateTime.now();
|
if (activity.getSignupStartTime() != null && now.isBefore(activity.getSignupStartTime())) {
|
throw exception(SIGNUP_NOT_IN_PERIOD);
|
}
|
if (activity.getSignupEndTime() != null && now.isAfter(activity.getSignupEndTime())) {
|
throw exception(SIGNUP_NOT_IN_PERIOD);
|
}
|
|
// 3. 校验名额
|
if (activity.getSignupLimit() != null && activity.getSignupLimit() > 0
|
&& activity.getSignupCount() != null && activity.getSignupCount() >= activity.getSignupLimit()) {
|
throw exception(SIGNUP_FULL);
|
}
|
|
// 3.1 校验自定义采集字段与评价，避免把空值写进库
|
List<WxCpActivityFieldDO> fields = getActivityFields(activity.getId());
|
List<WxCpActivitySignupValueDO> fieldValues =
|
buildSignupValues(activity.getId(), fields, reqVO.getFieldValues());
|
validateRating(activity, reqVO.getRatingScore());
|
|
// 4. 去重：有企业微信账号按账号查；没有账号但有手机号则按手机号查；
|
// 两者都没有时无法判定身份，不做去重——否则空手机号会互相误判成同一人
|
String wxUserId = StrUtil.trimToEmpty(reqVO.getWxUserId());
|
String mobile = StrUtil.trimToEmpty(reqVO.getMobile());
|
WxCpActivitySignupDO exists = null;
|
if (StrUtil.isNotBlank(wxUserId)) {
|
exists = wxcpSignupMapper.selectByActivityIdAndWxUserId(activity.getId(), wxUserId);
|
} else if (StrUtil.isNotBlank(mobile)) {
|
exists = wxcpSignupMapper.selectByActivityIdAndMobile(activity.getId(), mobile);
|
}
|
if (exists != null && !Objects.equals(exists.getStatus(), WxCpSignupStatusEnum.CANCELED.getStatus())) {
|
throw exception(SIGNUP_DUPLICATED);
|
}
|
// 之前取消过，则复用原记录重新报名，避免同一个人留多条历史
|
if (exists != null) {
|
wxcpSignupMapper.updateById(WxCpActivitySignupDO.builder()
|
.id(exists.getId())
|
.name(StrUtil.trimToEmpty(reqVO.getName()))
|
.mobile(mobile)
|
.deptName(reqVO.getDeptName())
|
.content(reqVO.getContent())
|
.ratingScore(reqVO.getRatingScore())
|
.remark(reqVO.getRemark())
|
.status(WxCpSignupStatusEnum.SIGNED_UP.getStatus())
|
.signupTime(now)
|
.checkInTime(null)
|
.build());
|
// 重新报名时旧附件/采集值作废，按本次提交覆盖
|
bindSignupAttachments(exists.getId(), reqVO.getBlobIds());
|
signupValueMapper.deleteBySignupId(exists.getId());
|
insertSignupValues(fieldValues, exists.getId());
|
incrementSignupCount(activity.getId());
|
return exists.getId();
|
}
|
|
// 5. 新增报名记录
|
WxCpActivitySignupDO signup = BeanUtils.toBean(reqVO, WxCpActivitySignupDO.class);
|
signup.setWxUserId(wxUserId);
|
// 姓名、手机号改为选填：统一存空串而不是 null，避免后续按手机号查重时空值语义混乱
|
signup.setName(StrUtil.trimToEmpty(reqVO.getName()));
|
signup.setMobile(mobile);
|
signup.setRatingScore(reqVO.getRatingScore());
|
signup.setStatus(WxCpSignupStatusEnum.SIGNED_UP.getStatus());
|
signup.setSignupTime(now);
|
wxcpSignupMapper.insert(signup);
|
|
// 6. 绑定报名人上传的图片/附件与采集字段值
|
bindSignupAttachments(signup.getId(), reqVO.getBlobIds());
|
insertSignupValues(fieldValues, signup.getId());
|
|
// 7. 用 SQL 自增，避免并发下的读改写丢失更新
|
incrementSignupCount(activity.getId());
|
return signup.getId();
|
}
|
|
/**
|
* 绑定报名附件（全量覆盖：先清掉该报名记录下的旧关联，再绑新的）
|
*
|
* 走 system 模块的附件中间表（record_type = wxcp_activity_signup），
|
* 不新建 upload 接口、不落文件地址字段，符合项目统一文件管理规范。
|
* 传空集合只清关联、不删文件本身。
|
*/
|
private void bindSignupAttachments(Long signupId, List<Long> blobIds) {
|
SystemStorageAttachmentSaveReqVO bindReqVO = new SystemStorageAttachmentSaveReqVO();
|
bindReqVO.setApplication(ATTACHMENT_APPLICATION);
|
bindReqVO.setRecordType(SIGNUP_RECORD_TYPE);
|
bindReqVO.setRecordId(signupId);
|
bindReqVO.setBlobItems(toBlobItems(blobIds));
|
storageAttachmentService.bindAttachments(bindReqVO);
|
}
|
|
@Override
|
public List<SystemStorageBlobRespVO> getSignupAttachments(Long signupId) {
|
return listAttachments(SIGNUP_RECORD_TYPE, signupId);
|
}
|
|
/**
|
* 组装报名采集值：按字段定义逐项校验必填，没填的字段不落行
|
*/
|
private List<WxCpActivitySignupValueDO> buildSignupValues(Long activityId, List<WxCpActivityFieldDO> fields,
|
List<WxCpSignupValueReqVO> reqValues) {
|
if (CollUtil.isEmpty(fields)) {
|
return Collections.emptyList();
|
}
|
Map<Long, String> valueMap = CollUtil.isEmpty(reqValues) ? Collections.emptyMap()
|
: reqValues.stream()
|
.filter(v -> v != null && v.getFieldId() != null)
|
.collect(Collectors.toMap(WxCpSignupValueReqVO::getFieldId,
|
v -> StrUtil.trimToEmpty(v.getFieldValue()), (a, b) -> b));
|
List<WxCpActivitySignupValueDO> result = new ArrayList<>();
|
for (WxCpActivityFieldDO field : fields) {
|
String value = StrUtil.trimToEmpty(valueMap.get(field.getId()));
|
if (Boolean.TRUE.equals(field.getRequired()) && StrUtil.isBlank(value)) {
|
throw exception(SIGNUP_FIELD_REQUIRED, field.getFieldLabel());
|
}
|
if (StrUtil.isBlank(value)) {
|
continue;
|
}
|
result.add(WxCpActivitySignupValueDO.builder()
|
.activityId(activityId)
|
.fieldId(field.getId())
|
.fieldLabel(field.getFieldLabel())
|
.fieldType(field.getFieldType())
|
.fieldValue(value)
|
.sortNo(field.getSortNo())
|
.build());
|
}
|
return result;
|
}
|
|
private void insertSignupValues(List<WxCpActivitySignupValueDO> values, Long signupId) {
|
if (CollUtil.isEmpty(values)) {
|
return;
|
}
|
values.forEach(value -> value.setSignupId(signupId));
|
signupValueMapper.insertBatch(values);
|
}
|
|
/**
|
* 开启评价时校验星级范围
|
*/
|
private void validateRating(WxCpActivityDO activity, Integer score) {
|
if (!Boolean.TRUE.equals(activity.getRatingEnabled())) {
|
return;
|
}
|
if (score == null) {
|
throw exception(SIGNUP_RATING_REQUIRED);
|
}
|
int max = activity.getRatingMax() != null && activity.getRatingMax() > 0
|
? activity.getRatingMax() : DEFAULT_RATING_MAX;
|
if (score < 1 || score > max) {
|
throw exception(SIGNUP_RATING_INVALID, max);
|
}
|
}
|
|
private void incrementSignupCount(Long activityId) {
|
wxcpActivityMapper.update(null, new LambdaUpdateWrapper<WxCpActivityDO>()
|
.setSql("signup_count = signup_count + 1")
|
.eq(WxCpActivityDO::getId, activityId));
|
}
|
|
private void decrementSignupCount(Long activityId) {
|
wxcpActivityMapper.update(null, new LambdaUpdateWrapper<WxCpActivityDO>()
|
.setSql("signup_count = CASE WHEN signup_count > 0 THEN signup_count - 1 ELSE 0 END")
|
.eq(WxCpActivityDO::getId, activityId));
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public void cancelSignup(Long id) {
|
WxCpActivitySignupDO signup = validateSignupExists(id);
|
if (Objects.equals(signup.getStatus(), WxCpSignupStatusEnum.CANCELED.getStatus())) {
|
throw exception(SIGNUP_ALREADY_CANCELED);
|
}
|
wxcpSignupMapper.updateById(WxCpActivitySignupDO.builder()
|
.id(id).status(WxCpSignupStatusEnum.CANCELED.getStatus()).build());
|
decrementSignupCount(signup.getActivityId());
|
}
|
|
@Override
|
public void checkInSignup(Long id) {
|
WxCpActivitySignupDO signup = validateSignupExists(id);
|
if (Objects.equals(signup.getStatus(), WxCpSignupStatusEnum.CANCELED.getStatus())) {
|
throw exception(SIGNUP_ALREADY_CANCELED);
|
}
|
if (Objects.equals(signup.getStatus(), WxCpSignupStatusEnum.CHECKED_IN.getStatus())) {
|
throw exception(SIGNUP_ALREADY_CHECKED_IN);
|
}
|
wxcpSignupMapper.updateById(WxCpActivitySignupDO.builder()
|
.id(id)
|
.status(WxCpSignupStatusEnum.CHECKED_IN.getStatus())
|
.checkInTime(LocalDateTime.now())
|
.build());
|
}
|
|
@Override
|
public WxCpActivitySignupDO getSignup(Long id) {
|
return wxcpSignupMapper.selectById(id);
|
}
|
|
@Override
|
public PageResult<WxCpActivitySignupDO> getSignupPage(WxCpSignupPageReqVO pageReqVO) {
|
return wxcpSignupMapper.selectPage(pageReqVO);
|
}
|
|
@Override
|
public WxCpActivityStatsRespVO getActivityStats(Long activityId) {
|
WxCpActivityDO activity = validateActivityExists(activityId);
|
List<WxCpActivitySignupDO> all = wxcpSignupMapper.selectListByActivityId(activityId);
|
|
// 一次遍历同时算总数与三类分布，避免多次全表扫描
|
int signedUp = 0, checkedIn = 0, canceled = 0;
|
Map<String, Integer> deptMap = new LinkedHashMap<>();
|
Map<String, Integer> dateMap = new TreeMap<>();
|
int fromWxCp = 0, fromForm = 0;
|
for (WxCpActivitySignupDO s : all) {
|
Integer st = s.getStatus();
|
if (Objects.equals(st, WxCpSignupStatusEnum.CANCELED.getStatus())) {
|
canceled++;
|
continue; // 已取消不计入部门/日期分布，否则统计会虚高
|
}
|
if (Objects.equals(st, WxCpSignupStatusEnum.CHECKED_IN.getStatus())) {
|
checkedIn++;
|
} else {
|
signedUp++;
|
}
|
deptMap.merge(StrUtil.blankToDefault(s.getDeptName(), "未填写部门"), 1, Integer::sum);
|
if (s.getSignupTime() != null) {
|
dateMap.merge(s.getSignupTime().toLocalDate().toString(), 1, Integer::sum);
|
}
|
if (StrUtil.isNotBlank(s.getWxUserId())) {
|
fromWxCp++;
|
} else {
|
fromForm++;
|
}
|
}
|
|
int totalSignup = signedUp + checkedIn;
|
WxCpActivityStatsRespVO vo = new WxCpActivityStatsRespVO();
|
vo.setActivityId(activity.getId());
|
vo.setActivityTitle(activity.getTitle());
|
vo.setSignupLimit(activity.getSignupLimit());
|
vo.setTotalSignup(totalSignup);
|
vo.setSignedUpCount(signedUp);
|
vo.setCheckedInCount(checkedIn);
|
vo.setCanceledCount(canceled);
|
|
// 名额相关指标：不限名额时保持 null，前端据此显示"不限"
|
Integer limit = activity.getSignupLimit();
|
if (limit != null && limit > 0) {
|
vo.setRemaining(Math.max(0, limit - totalSignup));
|
vo.setSignupPercent(Math.min(100, (int) Math.round(totalSignup * 100.0 / limit)));
|
}
|
vo.setCheckInPercent(totalSignup == 0 ? 0
|
: (int) Math.round(checkedIn * 100.0 / totalSignup));
|
|
vo.setDeptStats(toNameCountList(deptMap));
|
vo.setDateStats(toNameCountList(dateMap));
|
// 来源分布：用显式 put，避免双大括号初始化捕获循环中变更的局部变量
|
Map<String, Integer> sourceMap = new LinkedHashMap<>();
|
sourceMap.put("企业微信身份", fromWxCp);
|
sourceMap.put("表单填写", fromForm);
|
vo.setSourceStats(toNameCountList(sourceMap));
|
return vo;
|
}
|
|
private List<WxCpActivityStatsRespVO.NameCount> toNameCountList(Map<String, Integer> map) {
|
return map.entrySet().stream()
|
.map(e -> new WxCpActivityStatsRespVO.NameCount(e.getKey(), e.getValue()))
|
.toList();
|
}
|
|
// ==================== 校验辅助 ====================
|
|
private WxCpActivityDO validateActivityExists(Long id) {
|
if (id == null) {
|
throw exception(ACTIVITY_NOT_EXISTS);
|
}
|
WxCpActivityDO activity = wxcpActivityMapper.selectById(id);
|
if (activity == null) {
|
throw exception(ACTIVITY_NOT_EXISTS);
|
}
|
return activity;
|
}
|
|
private WxCpActivitySignupDO validateSignupExists(Long id) {
|
WxCpActivitySignupDO signup = wxcpSignupMapper.selectById(id);
|
if (signup == null) {
|
throw exception(SIGNUP_NOT_EXISTS);
|
}
|
return signup;
|
}
|
|
}
|
