backend/java-mall
6
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'main' into dev

Browse Source
This commit is contained in:
liyj 2025-09-26 11:18:58 +08:00
commit 7253649412
14 changed files with 1405 additions and 725 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
mall-common/src/main/java/com/suisung/mall/common/exception/GlobalExceptionHandler.java
View File

@ -63,8 +63,8 @@ public class GlobalExceptionHandler {
.map(ConstraintViolation::getMessage)
.collect(Collectors.joining("; "));
logError(req, "约束违反异常", e);
return CommonResult.validateFailed("系统数据异常，请联系管理员！");
logError(req, "数据库约束违反异常", e);
return CommonResult.validateFailed("记录是否已存在，请检查！");
}
/**

62
mall-common/src/main/java/com/suisung/mall/common/utils/CheckUtil.java
View File

@ -27,38 +27,78 @@ import java.util.regex.Pattern;
@Slf4j
public class CheckUtil {
// private static String[] parsePatterns = {"yyyy-MM-dd", "yyyy年MM月dd日",
// "yyyy-MM-dd HH:mm:ss", "yyyy-MM-dd HH:mm", "yyyy/MM/dd",
// "yyyy/MM/dd HH:mm:ss", "yyyy/MM/dd HH:mm", "yyyyMMdd"};
/**
* 校验数据 不为null和0
*
* @param param
* @return
* @param param 待校验的Integer值
* @return boolean 不为null且不为0返回true，否则返回false
*/
public static boolean isNotEmpty(Integer param) {
return param != null && param != 0;
}
/**
* 校验数据 不为null和0
*
* @param param 待校验的Long值
* @return boolean 不为null且不为0返回true，否则返回false
*/
public static boolean isNotEmpty(Long param) {
return param != null && param != 0;
return param != null && param != 0L;
}
/**
* 校验数据 不为null和0
*
* @param param 待校验的BigDecimal值
* @return boolean 不为null且不为0返回true，否则返回false
*/
public static boolean isNotEmpty(BigDecimal param) {
return param != null && param.floatValue() != 0;
return param != null && param.compareTo(BigDecimal.ZERO) != 0;
}
/**
* 校验数据 不为null和0
*
* @param param 待校验的Float值
* @return boolean 不为null且不为0返回true，否则返回false
*/
public static boolean isNotEmpty(Float param) {
return param != null && param != 0;
return param != null && param != 0f && !param.isNaN();
}
/**
* 校验数据 不为null和0
*
* @param param 待校验的Double值
* @return boolean 不为null且不为0返回true，否则返回false
*/
public static boolean isNotEmpty(Double param) {
return param != null && param != 0;
return param != null && param != 0d && !param.isNaN();
}
/**
* 校验字符串不为null、空字符串、空白字符及特殊值
*
* @param param 待校验的字符串
* @return boolean 不为空返回true，否则返回false
*/
public static boolean isNotEmpty(String param) {
return param != null && param != "";
// 检查null值和空字符串
if (param == null || param.isEmpty()) {
return false;
}
// 去除首尾空格后检查是否为空
String trimmed = param.trim();
if (trimmed.isEmpty()) {
return false;
}
// 检查特殊值：undefined、null、none（不区分大小写）
return !"undefined".equalsIgnoreCase(trimmed) &&
!"null".equalsIgnoreCase(trimmed) &&
!"none".equalsIgnoreCase(trimmed);
}
public static boolean isEmpty(Integer param) {

14
mall-shop/src/main/java/com/suisung/mall/shop/components/quartz/service/impl/QuartzServiceImpl.java
View File

@ -58,19 +58,15 @@ public class QuartzServiceImpl implements QuartzService {
throw new ApiException(I18nUtil._("任务实现类名称不能为空！"));
}
try {
// 2. 加载任务类
Class<Job> clazz;
try {
String fullClassName = PATH_PREFIX + cName;
logger.debug("[Quartz] 尝试加载任务类: {}", fullClassName);
clazz = (Class<Job>) Class.forName(fullClassName);
logger.debug("[Quartz] 成功加载任务类: {}", fullClassName);
} catch (ClassNotFoundException e) {
logger.error("[Quartz] 定时任务脚本不存在！类名: {}{}", PATH_PREFIX, cName, e);
throw new ApiException(I18nUtil._("定时任务脚本不存在！类名: " + PATH_PREFIX + cName), e);
}
try {
// 3. 构建任务详情和触发器
JobKey jobKey = new JobKey(jName, jGroup);
JobDetail jobDetail = JobBuilder.newJob(clazz)
@ -86,6 +82,9 @@ public class QuartzServiceImpl implements QuartzService {
logger.debug("[Quartz] 构建任务详情和触发器完成: jobKey={}, triggerKey={}", jobKey, triggerKey);
// 打印最终执行的 cron 表达式
logger.info("[Quartz] 定时任务最终执行表达式: {}", trigger.getCronExpression());
// 4. 检查任务是否已存在
if (scheduler.checkExists(jobKey)) {
logger.info("[Quartz] 任务已存在，先删除旧任务: jobKey={}", jobKey);
@ -110,6 +109,9 @@ public class QuartzServiceImpl implements QuartzService {
logger.error("[Quartz] 添加定时任务失败！任务名称={}, 任务组={}, 触发器名称={}, 触发器组={}",
jName, jGroup, tName, tGroup, e);
throw new ApiException(I18nUtil._("添加定时任务失败！"), e);
} catch (ClassNotFoundException e) {
logger.error("[Quartz] 定时任务脚本不存在！类名: {}{}", PATH_PREFIX, cName, e);
throw new ApiException(I18nUtil._("定时任务脚本不存在！类名: " + PATH_PREFIX + cName), e);
} catch (Exception e) {
logger.error("[Quartz] 添加定时任务时发生未知异常！任务名称={}, 任务组={}, 触发器名称={}, 触发器组={}",
jName, jGroup, tName, tGroup, e);

4
mall-shop/src/main/java/com/suisung/mall/shop/lakala/controller/mobile/LakalaController.java
View File

@ -116,7 +116,9 @@ public class LakalaController extends BaseControllerImpl {
// return sfExpressApiService.createSfExpressShop(66, "能辉超市", "桂平市", "广西壮族自治区贵港市桂平市广佰汇超市(桂平店)", "谢能坤", "17777525395", "110.07165452271", "23.369069486251");
return lakalaApiService.sacsQuery("8226330541100GU", "20250918770188017227140800").toString();
// return lakalaApiService.sacsQuery("8226330541100GU", "20250918770188017227140800").toString();
return lakalaApiService.queryLedgerMer("8226330541100HA");
}
@ApiOperation(value = "批量发送推送消息 - 测试案例", notes = "批量发送推送消息 - 测试案例")

22
mall-shop/src/main/java/com/suisung/mall/shop/lakala/service/LakalaApiService.java
View File

@ -10,6 +10,7 @@ package com.suisung.mall.shop.lakala.service;
import cn.hutool.json.JSONObject;
import com.suisung.mall.common.api.CommonResult;
import com.suisung.mall.common.modules.store.ShopMchEntry;
import org.springframework.data.util.Pair;
import javax.servlet.http.HttpServletRequest;
@ -268,6 +269,18 @@ public interface LakalaApiService {
*/
JSONObject sacsQuery(String merchantNo, String separateNo);
/**
* 商户分账业务信息查询
* 参考：https://o.lakala.com/#/home/document/detail?id=381
*
* @param merCupNo 银联商户号
* @return 分账业务信息，查询失败时返回null
* <p>
* 返回：{"merInnerNo":"4002025092404043540","merCupNo":"8226330541100HA","splitLowestRatio":20.0,"orgId":"980688","orgName":"桂平发发","splitStatus":"VALID","splitStatusText":"启用","splitRange":"ALL","sepFundSource":"TR","bindRelations":[{"merInnerNo":"4002025092404043540","merCupNo":"8226330541100HA","receiverNo":"SR2024000129789","receiverName":"桂平发发网络有限公司"}],"platformId":null,"splitLaunchMode":"MANUAL","splitRuleSource":null,"eleContractNo":"QY20250924613672961"}
*/
JSONObject queryLedgerMer(String merCupNo);
/**
* 订单分账撤销
* 参考：https://o.lakala.com/#/home/document/detail?id=390
@ -288,4 +301,13 @@ public interface LakalaApiService {
*/
Integer fixedUnSuccessSeparateStatusJob();
/**
* 检测修复补全商户的商户分账业务信息及分账接收方绑定关系（分账业务申请异步通知的补偿机制）
*
* @param shopMchEntry 商户入驻信息实例
* @return
*/
Boolean checkAndFixLedgerMerApplyAndBindRelations(ShopMchEntry shopMchEntry);
}

3
mall-shop/src/main/java/com/suisung/mall/shop/lakala/service/LklLedgerMemberService.java
View File

@ -50,8 +50,9 @@ public interface LklLedgerMemberService extends IBaseService<LklLedgerMember> {
* @param auditStatus
* @param auditStatusText
* @param remark
* @param notifyResp
* @return
*/
Boolean updateAuditResult(String applyId, String merInnerNo, String merCupNo, String entrustFileName, String entrustFilePath, String auditStatus, String auditStatusText, String remark);
Boolean updateAuditResult(String applyId, String merInnerNo, String merCupNo, String entrustFileName, String entrustFilePath, String auditStatus, String auditStatusText, String remark, String notifyResp);
}

645
mall-shop/src/main/java/com/suisung/mall/shop/lakala/service/impl/LakalaApiServiceImpl.java
View File

File diff suppressed because it is too large Load Diff

4
mall-shop/src/main/java/com/suisung/mall/shop/lakala/service/impl/LklLedgerMemberServiceImpl.java
View File

@ -101,10 +101,11 @@ public class LklLedgerMemberServiceImpl extends BaseServiceImpl<LklLedgerMemberM
* @param auditStatus
* @param auditStatusText
* @param remark
* @param notifyResp
* @return
*/
@Override
public Boolean updateAuditResult(String applyId, String merInnerNo, String merCupNo, String entrustFileName, String entrustFilePath, String auditStatus, String auditStatusText, String remark) {
public Boolean updateAuditResult(String applyId, String merInnerNo, String merCupNo, String entrustFileName, String entrustFilePath, String auditStatus, String auditStatusText, String remark, String notifyResp) {
if (StrUtil.isBlank(applyId) || StrUtil.isBlank(merCupNo) || StrUtil.isBlank(auditStatus)) {
log.error("缺少参数：applyId={}, merCupNo={}, auditStatus={}", applyId, merCupNo, auditStatus);
return false;
@ -119,6 +120,7 @@ public class LklLedgerMemberServiceImpl extends BaseServiceImpl<LklLedgerMemberM
updateWrapper.set("audit_status", auditStatus);
updateWrapper.set("audit_status_text", auditStatusText);
updateWrapper.set("remark", remark);
updateWrapper.set("audit_resp", notifyResp);
return update(updateWrapper);
}

3
mall-shop/src/main/java/com/suisung/mall/shop/message/service/PushMessageService.java
View File

@ -42,9 +42,10 @@ public interface PushMessageService {
*
* @param userId
* @param payload
* @param isFinishNotice 是签署完成通知？
* @return
*/
CompletableFuture<Boolean> noticeMerchantSignEcContract(Integer userId, JSONObject payload);
CompletableFuture<Boolean> noticeMerchantSignEcContract(Integer userId, JSONObject payload, Boolean isFinishNotice);
/**

9
mall-shop/src/main/java/com/suisung/mall/shop/message/service/impl/PushMessageServiceImpl.java
View File

@ -109,7 +109,7 @@ public class PushMessageServiceImpl implements PushMessageService {
@Async
@Override
public CompletableFuture<Boolean> noticeMerchantSignEcContract(Integer userId, JSONObject payload) {
public CompletableFuture<Boolean> noticeMerchantSignEcContract(Integer userId, JSONObject payload, Boolean isFinishNotice) {
try {
// 获取商家的 cid 列表，确保用户 ID 有效
if (userId == null || userId <= 0) {
@ -137,9 +137,12 @@ public class PushMessageServiceImpl implements PushMessageService {
return CompletableFuture.completedFuture(false); // 无有效 cid 无需推送
}
String title = isFinishNotice ? "通知您合同已签署完毕" : "邀请您签署入驻合同";
String content = isFinishNotice ? "您的开店入驻合同已签署完成！" : "恭喜您！您的开店入驻申请已初步审核通过！请尽快登录小发商家 APP 平台签署电子合同，签署链接24小时内有效（逾期需重新提交申请）。如有疑问请联系客服，感谢您的支持！";
Pair<Boolean, String> result = uniCloudPushService.sendPushMessageBatch(cidList,
appName + "邀请您签署入驻合同",
"恭喜您的开店入驻申请已审核通过！请尽快登录小发商家 APP 平台签署电子合同，签署链接24小时内有效（逾期需重新提交申请）。如有疑问请联系客服，感谢您的支持！",
appName + title,
content,
payload);
if (!result.getFirst()) {

4
mall-shop/src/main/java/com/suisung/mall/shop/sfexpress/controller/mobile/SFExpressController.java
View File

@ -72,8 +72,8 @@ public class SFExpressController {
@ApiOperation(value = "查询顺丰同城订单状态流", notes = "查询顺丰同城订单状态流")
@RequestMapping(value = "/list-order-feed", method = RequestMethod.POST)
public ThirdApiRes listOrderFeed(@RequestParam(name = "order_id", defaultValue = "") String orderId) {
if (StrUtil.isBlank(orderId) || orderId == "undefined" || orderId == "null") {
return new ThirdApiRes().fail(1003, "请求参数有误！");
if (StrUtil.isBlank(orderId) || "undefined".equals(orderId) || "null".equals(orderId) || "none".equals(orderId)) {
return new ThirdApiRes().fail(1003, "缺少参数或参数有误！");
}
Map<String, Object> params = new HashMap<>();

9
mall-shop/src/main/java/com/suisung/mall/shop/store/service/ShopMchEntryService.java
View File

@ -293,6 +293,15 @@ public interface ShopMchEntryService {
*/
Boolean checkMerchEntryFinished(Long mchId);
/**
* 检查商户入驻流程，当前是否可以创建店铺了？
*
* @param mchId 商户入驻ID
* @return boolean 可以创建店铺返回true，否则返回false
*/
Boolean canBuildingShopStore(Long mchId);
/**
* 检查更新商户入驻店铺初始化状态
*

162
mall-shop/src/main/java/com/suisung/mall/shop/store/service/impl/ShopMchEntryServiceImpl.java
View File

@ -173,7 +173,6 @@ public class ShopMchEntryServiceImpl extends BaseServiceImpl<ShopMchEntryMapper,
return CommonResult.failed("请指定店铺或银行的省市区！");
}
if (!PhoneNumberUtils.checkPhoneNumber(loginMobile)) {
log.warn("申请人手机号码格式错误，手机号: {}", loginMobile);
return CommonResult.failed("申请人手机号码有误！");
@ -780,6 +779,12 @@ public class ShopMchEntryServiceImpl extends BaseServiceImpl<ShopMchEntryMapper,
return fixCount > 0;
}
/**
* 重要（补偿机制），检查修复商户入驻店铺信息(商家账号关联入驻店铺Id，给商家账户创立公司员工账号和权限)
*
* @param mchId 商户入驻ID（必填）
* @return boolean 是否成功修复商户信息
*/
public Boolean checkAndFixMchStoreInfo(Long mchId) {
// 1. 参数校验
if (CheckUtil.isEmpty(mchId)) {
@ -788,76 +793,86 @@ public class ShopMchEntryServiceImpl extends BaseServiceImpl<ShopMchEntryMapper,
}
try {
// 2. 获取当前商户用户信息
// 6. 获取当前商户用户信息
UserDto currentUser = getCurrentUser();
if (currentUser == null || !currentUser.isMerchant()) {
log.warn("当前用户非商户账号");
if (currentUser == null || CheckUtil.isEmpty(currentUser.getId())) {
log.warn("当前用户未登录，入驻ID: {}", mchId);
return false;
}
// 4.3 获取用户基础信息
// 7. 获取用户基础信息
AccountUserBase userBase = accountService.getUserBase(currentUser.getId());
if (userBase == null) {
log.warn("商户用户基础信息不存在，用户ID: {}", currentUser.getId());
return false;
}
// 3. 查询商户入驻记录
// 2. 查询商户入驻记录
ShopMchEntry shopMchEntry = get(mchId);
if (shopMchEntry == null) {
log.debug("未找到商户入驻记录 mchId {}", mchId);
return false;
}
// 4.2 检查入驻状态
// 3. 检测修复补全商户的商户分账业务信息及分账接收方绑定关系（分账业务申请异步通知的补偿机制）
lakalaApiService.checkAndFixLedgerMerApplyAndBindRelations(shopMchEntry);
// 5. 检查入驻状态
boolean isValidStatus = CommonConstant.Enable.equals(shopMchEntry.getHas_ec_signed())
&& CommonConstant.Enable.equals(shopMchEntry.getHas_apply_mer())
&& CommonConstant.Enable.equals(shopMchEntry.getHas_apply_split())
&& CommonConstant.Enable.equals(shopMchEntry.getHas_apply_receiver())
&& CommonConstant.Enable.equals(shopMchEntry.getHas_bind_receiver());
if (isValidStatus) {
log.debug("入驻记录状态都通过了审核，进一步验证修复条件，入驻ID: {}", mchId);
} else {
log.debug("入驻记录状态个别未通过审核，接着检查验证修复条件，入驻ID: {}", mchId);
if (!isValidStatus) {
log.debug("入驻记录状态未全部通过审核，不能创建店铺，入驻ID: {}", mchId);
return false;
}
// 4.4 获取店铺员工信息
// 8. 检查店铺关联关系
boolean hasStoreRelation = false;
if (StrUtil.isNotBlank(shopMchEntry.getStore_id()) && StrUtil.isNotBlank(userBase.getStore_ids())) {
hasStoreRelation = userBase.getStore_ids().contains(shopMchEntry.getStore_id());
}
// 9. 获取店铺员工信息
ShopStoreEmployee storeEmployee = null;
if (StrUtil.isNotBlank(shopMchEntry.getStore_id())) {
Integer storeId = Convert.toInt(shopMchEntry.getStore_id());
if (CheckUtil.isNotEmpty(storeId)) {
storeEmployee = shopStoreEmployeeService.getStoreEmployeeByUserId(
Convert.toInt(shopMchEntry.getStore_id()),
storeId,
currentUser.getId()
);
}
}
// 4.5 检查店铺关联关系
boolean hasStoreRelation = StrUtil.isNotBlank(userBase.getStore_ids()) &&
userBase.getStore_ids().contains(shopMchEntry.getStore_id());
// 10. 检查权限组信息
boolean hasRoles = storeEmployee != null && StrUtil.isNotBlank(storeEmployee.getRights_group_id());
// 4.6 检查权限组信息
boolean hasRoles = storeEmployee != null &&
StrUtil.isNotBlank(storeEmployee.getRights_group_id());
// 11. 当满足创建店铺条件且存在信息缺失时，需要进行修复
if (storeEmployee == null || !hasRoles || !hasStoreRelation) {
log.info("开始修复商户信息，入驻ID: {}, storeEmployee为空: {}, 缺少角色: {}, 缺少店铺关联: {}",
mchId, storeEmployee == null, !hasRoles, !hasStoreRelation);
// 4.7 当以下任一条件满足时，需要进行修复
// - 无店铺员工信息
// - 无权限组信息
// - 无店铺关联
if (storeEmployee == null ||
!hasRoles ||
!hasStoreRelation) {
// 4.8 补偿创建初始化店铺部分赋值
// 补偿创建初始化店铺部分赋值
Pair<Integer, String> result = shopStoreBaseService.covMerchEntryInfo2StoreInfo(mchId, false);
if (result != null && result.getFirst() > 0) {
log.warn("商户信息修复成功，入驻ID: {}", mchId);
log.info("商户信息修复成功，入驻ID: {}", mchId);
// 修复成功后检查商户绑定状态是否完成，更改总的审核状态
checkMerchEntryFinished(mchId);
return true;
} else {
log.error("商户信息修复失败，入驻ID: {}, 错误信息:{}", mchId, result != null ? result.getSecond() : "未知错误");
return false;
}
}
// 12. 如果信息完整，检查商户绑定状态是否完成，更改总的审核状态
log.debug("商户信息完整，检查是否需要更新审核状态，入驻ID: {}", mchId);
checkMerchEntryFinished(mchId);
return true;
} catch (Exception e) {
log.error("商户信息修复异常，mchId: {}", mchId, e);
@ -1042,7 +1057,7 @@ public class ShopMchEntryServiceImpl extends BaseServiceImpl<ShopMchEntryMapper,
if (StrUtil.isBlank(contactMobile)) {
return Pair.of(false, "联系人手机号不能为空");
}
queryWrapper.eq("legal_person_mobile", contactMobile);
queryWrapper.eq("legal_person_mobile", contactMobile); // 企业和个人公用该字段（联系人手机号）
String msg = "";
// 4. 根据主体类型设置额外查询条件和提示信息
@ -1067,7 +1082,6 @@ public class ShopMchEntryServiceImpl extends BaseServiceImpl<ShopMchEntryMapper,
return Pair.of(false, msg);
}
log.info("可以申请入驻，准备申请入驻");
return Pair.of(true, "可以申请入驻，准备下一个流程");
@ -1430,21 +1444,45 @@ public class ShopMchEntryServiceImpl extends BaseServiceImpl<ShopMchEntryMapper,
/**
* 更新商家入驻申请的店铺 ID
*
* @param id
* @param storeId
* @return
* @param mchId 商户ID
* @param storeId 店铺ID
* @return 更新成功返回 true，否则返回 false
*/
@Override
public Boolean updateMerchEntryStoreStatus(Long id, Integer storeId) {
if (ObjectUtil.isEmpty(id) && ObjectUtil.isEmpty(storeId)) {
public Boolean updateMerchEntryStoreStatus(Long mchId, Integer storeId) {
// 1. 参数校验：mchId 不能为空
if (CheckUtil.isEmpty(mchId) || CheckUtil.isEmpty(storeId)) {
log.warn("更新商户店铺状态失败：商户ID不能为空");
return false;
}
return update(new UpdateWrapper<ShopMchEntry>()
.eq("id", id)
.set("store_id", storeId).set("store_status", CommonConstant.Enable));
try {
// 2. 构建更新条件
UpdateWrapper<ShopMchEntry> updateWrapper = new UpdateWrapper<>();
updateWrapper.eq("id", mchId)
.set("store_id", storeId)
.set("store_status", CommonConstant.Enable)
.set("updated_at", new Date()); // 更新时间戳
// 3. 执行更新操作并返回结果
boolean result = update(updateWrapper);
if (result) {
log.info("商户店铺状态更新成功，mchId: {}, storeId: {}", mchId, storeId);
} else {
log.warn("商户店铺状态更新失败，未找到匹配记录，mchId: {}", mchId);
}
return result;
} catch (Exception e) {
// 4. 异常处理：记录异常信息
log.error("更新商户店铺状态时发生异常，mchId: {}, storeId: {}", mchId, storeId, e);
return false;
}
}
// /**
// * 更新拉卡拉入网电子合同和签署地址
// *
@ -1738,6 +1776,7 @@ public class ShopMchEntryServiceImpl extends BaseServiceImpl<ShopMchEntryMapper,
log.error("更新商户入驻信息状态失败, mchId={}", mchId);
return false;
}
return true; // 返回 true，表示入驻流程已全部完成
} catch (Exception e) {
@ -1747,6 +1786,51 @@ public class ShopMchEntryServiceImpl extends BaseServiceImpl<ShopMchEntryMapper,
}
}
/**
* 检查商户入驻流程，当前是否可以创建店铺了？
*
* @param mchId 商户入驻ID
* @return boolean 可以创建店铺返回true，否则返回false
*/
@Override
public Boolean canBuildingShopStore(Long mchId) {
// 1. 参数校验
if (ObjectUtil.isEmpty(mchId)) {
log.error("检查商户是否可以创建店铺失败：商户入驻ID为空");
return false;
}
try {
// 2. 根据商户ID获取商户入驻信息
ShopMchEntry merchantEntry = shopMerchEntryById(mchId);
if (merchantEntry == null) {
log.error("检查商户是否可以创建店铺失败：商户不存在, mchId={}", mchId);
return false;
}
// 3. 检查各项前置状态是否已完成
boolean isFinished = CommonConstant.Enable.equals(merchantEntry.getHas_ec_signed())
&& CommonConstant.Enable.equals(merchantEntry.getHas_apply_mer())
&& CommonConstant.Enable.equals(merchantEntry.getHas_apply_split())
&& CommonConstant.Enable.equals(merchantEntry.getHas_apply_receiver())
&& CommonConstant.Enable.equals(merchantEntry.getHas_bind_receiver());
// 4. 返回检查结果
if (isFinished) {
log.debug("商户满足创建店铺条件, mchId={}", mchId);
return true;
} else {
log.debug("商户不满足创建店铺条件, mchId={}", mchId);
return false;
}
} catch (Exception e) {
// 5. 异常处理：记录异常信息，避免程序中断
log.error("检查商户是否可以创建店铺时发生异常, mchId={}", mchId, e);
return false;
}
}
/**
* 根据商户号或商家手机号修改商户入驻信息多个状态

481
mall-shop/src/main/java/com/suisung/mall/shop/store/service/impl/ShopStoreBaseServiceImpl.java
View File

@ -2261,18 +2261,25 @@ public class ShopStoreBaseServiceImpl extends BaseServiceImpl<ShopStoreBaseMappe
/**
* 店铺信息设置
*
* @return
* @return CommonResult 操作结果
*/
@Override
@Transactional
public CommonResult storeSetUp() {
UserDto user = getCurrentUser();
ShopStoreBase base = new ShopStoreBase();
if (user == null) {
logger.warn("用户未登录，无法设置店铺信息");
return CommonResult.failed("用户未登录");
}
ShopStoreBase base = new ShopStoreBase();
if (user.isPlatform()) {
// 平台方
Integer store_id = getParameter("store_id", Integer.class);
if (store_id == null) {
logger.warn("平台方设置店铺信息缺少必要参数 store_id");
return CommonResult.failed("缺少必要参数 store_id");
}
base.setStore_id(store_id);
ShopStoreInfo info = new ShopStoreInfo();
@ -2330,7 +2337,6 @@ public class ShopStoreBaseServiceImpl extends BaseServiceImpl<ShopStoreBaseMappe
base.setStore_circle(store_circle);
}
String store_area = getParameter("store_area");
if (StrUtil.isNotBlank(store_area)) {
base.setStore_area(store_area);
@ -2379,17 +2385,29 @@ public class ShopStoreBaseServiceImpl extends BaseServiceImpl<ShopStoreBaseMappe
}
if (packingFee.compareTo(new BigDecimal("10")) > 0) {
logger.warn("打包费超出范围: {}", packingFee);
return CommonResult.failed("打包费请控制在0到10元范围");
}
base.setPacking_fee(packingFee);
// 铃声开关
Integer ringtoneIsEnable = Convert.toInt(getParameter("ringtone_is_enable"));
if (ringtoneIsEnable == null || ringtoneIsEnable <= 0) {
ringtoneIsEnable = CommonConstant.Enable;
}
base.setRingtone_is_enable(ringtoneIsEnable);
// 商家分账比例
BigDecimal splitRatio = Convert.toBigDecimal(getParameter("split_ratio"));
if (CheckUtil.isNotEmpty(splitRatio)) {
if (splitRatio.compareTo(BigDecimal.valueOf(70)) >= 0
&& splitRatio.compareTo(BigDecimal.valueOf(99)) <= 0) {
base.setSplit_ratio(splitRatio);
} else {
logger.warn("分账比例超出范围: {}", splitRatio);
return CommonResult.failed("分账比例超出[70.00,99.00]范围，请修正");
}
}
// 百度坐标系BD09经纬度 转出 火星坐标系GCJ02经纬度 （因为数据库保存的经纬度统一是GCJ02经纬度，所以需要转换 ）
base = bd09ToGcj02Gps(base);
@ -2397,10 +2415,20 @@ public class ShopStoreBaseServiceImpl extends BaseServiceImpl<ShopStoreBaseMappe
AccountUserBase userInfo = new AccountUserBase();
userInfo.setUser_id(getParameter("user_id", Integer.class));
userInfo.setUser_password(getParameter("user_password"));
saveInfo(base, info, userInfo, null);
boolean result = saveInfo(base, info, userInfo, null);
if (!result) {
logger.error("平台方保存店铺信息失败，店铺ID: {}", store_id);
return CommonResult.failed("保存店铺信息失败");
}
} else if (user.isStore()) {
// 店铺
Integer store_id = Convert.toInt(user.getStore_id());
if (store_id == null) {
logger.warn("商户用户无关联店铺，用户ID: {}", user.getId());
return CommonResult.failed("用户无关联店铺");
}
ShopStoreInfo info = new ShopStoreInfo();
String store_slogan = getParameter("store_slogan");
@ -2457,15 +2485,6 @@ public class ShopStoreBaseServiceImpl extends BaseServiceImpl<ShopStoreBaseMappe
if (StrUtil.isNotBlank(store_o2o_tags)) {
base.setStore_o2o_tags(store_o2o_tags);
}
//兼容不同终端 已经无推荐地址情况
// todo if (empty($data['base']['store_longitude']) || $data['base']['store_latitude'] )
// {
// $address_str = sprintf('%s %s', $data['base']['store_area'] , $data['base']['store_address']);
// $coord = Zero_Utils_Ip::getLatAndLngByAddress($address_str);
//
// $data['base']['store_longitude'] = $coord['lng']; // 经度
// $data['base']['store_latitude'] = $coord['lat']; // 纬读
// }
String store_banner = getParameter("store_banner");
if (StrUtil.isNotBlank(store_banner)) {
@ -2538,6 +2557,7 @@ public class ShopStoreBaseServiceImpl extends BaseServiceImpl<ShopStoreBaseMappe
shopStoreConfig.setStore_id(store_id);
shopStoreConfig.setSc_is_enabled_invoice(Convert.toInt(sc_is_enabled_invoice));
if (!shopStoreConfigService.edit(shopStoreConfig)) {
logger.error("保存店铺参数失败，店铺ID: {}", store_id);
throw new ApiException(I18nUtil._("保存店铺参数失败"));
}
}
@ -2549,6 +2569,7 @@ public class ShopStoreBaseServiceImpl extends BaseServiceImpl<ShopStoreBaseMappe
}
if (packingFee.compareTo(new BigDecimal("10")) > 0) {
logger.warn("打包费超出范围: {}", packingFee);
return CommonResult.failed("打包费请控制在0到10元范围");
}
base.setPacking_fee(packingFee);
@ -2564,14 +2585,19 @@ public class ShopStoreBaseServiceImpl extends BaseServiceImpl<ShopStoreBaseMappe
base = bd09ToGcj02Gps(base);
if (!saveInfo(base, info, null, company)) {
logger.error("商户保存店铺信息失败，店铺ID: {}", store_id);
throw new ApiException(I18nUtil._("保存店铺信息失败"));
}
} else {
logger.warn("用户无操作权限，用户ID: {}", user.getId());
return CommonResult.failed("无操作权限");
}
return CommonResult.success();
}
public Integer getSubsiteId(String store_district_id) {
int[] area = StrUtil.splitToInt(store_district_id, "/");
String city = Convert.toStr(area[1]);
@ -3125,138 +3151,144 @@ public class ShopStoreBaseServiceImpl extends BaseServiceImpl<ShopStoreBaseMappe
return covMerchEntryInfo2StoreInfo(mchId, allowThrown);
}
/**
* （重要）入驻审批通过并且合同盖章完结之后，把商家入驻信息转换成店铺信息，正式生成店铺所需的数据
*
* @param mchId
* @param allowThrown 是否允许抛出异常？
* @return
*/
@Override
public Pair<Integer, String> covMerchEntryInfo2StoreInfo(Long mchId, Boolean allowThrown) {
// TODO 用法人、小微个人的手机号注册商家账号，作为店铺的管理员
// 参数校验
if (ObjectUtil.isEmpty(mchId)) {
logger.error("生成店铺：入驻商家自增Id不能为空");
return Pair.of(0, "入驻商家自增Id不能为空");
}
try {
// 获取入驻信息
ShopMchEntry shopMchEntry = shopMchEntryService.shopMerchEntryById(mchId);
if (shopMchEntry == null) {
logger.error("生成店铺：入驻信息不能为空");
return Pair.of(0, "入驻信息不能为空");
}
// 如果 还没有签署入网电子合同且没有进件成功，则提示前置条件未满足
// 前置条件检查
if (!CommonConstant.Enable.equals(shopMchEntry.getHas_ec_signed())
&& !CommonConstant.Enable.equals(shopMchEntry.getHas_apply_mer())) {
return Pair.of(0, "请先签署电子合同和商家进件，再创建店铺。");
}
// TODO 判断要不要给入驻的企业法人手机、小微联系人手机注册一个账号？
// 从绑定关系中，获取入驻商家注册账号信息
Integer userId = accountService.getUserBindConnectUserIdByCondition(shopMchEntry.getLogin_mobile(), BindCode.MOBILE, CommonConstant.USER_TYPE_MCH);
// 获取用户ID
Integer userId = accountService.getUserBindConnectUserIdByCondition(
shopMchEntry.getLogin_mobile(), BindCode.MOBILE, CommonConstant.USER_TYPE_MCH);
if (userId == null) {
logger.error("生成店铺：{}手机未注册商家账号", shopMchEntry.getLogin_mobile());
return Pair.of(0, "手机未注册商家账号！");
}
// 入驻时已经检查过店铺名称了，此处忽略
// 检查店铺名称
ShopStoreBase shopStoreBase = findOneByStoreName(shopMchEntry.getStore_name());
if (shopStoreBase != null
&& StrUtil.isNotBlank(shopStoreBase.getLkl_merchant_no())
&& StrUtil.isNotBlank(shopStoreBase.getLkl_term_no())
&& !shopStoreBase.getStore_id().toString().equals(shopMchEntry.getStore_id())) {
// 如果店铺名称已存在，且店铺已经进件，且不等于当前入驻商家的店铺Id，提示店铺名称已存在
&& StrUtil.isNotBlank(shopMchEntry.getLkl_mer_cup_no())
&& !shopStoreBase.getLkl_merchant_no().equals(shopMchEntry.getLkl_mer_cup_no())) {
logger.error("生成店铺：店铺名称已存在");
return Pair.of(0, "店铺名称已存在，请使用另一名称");
}
// 新增 shop_store_base，shop_store_info，shop_store_company, shop_store_employee 待补充
// shop_store_base
// 创建或更新店铺基础信息
if (shopStoreBase == null) {
shopStoreBase = new ShopStoreBase();
}
shopStoreBase.setUser_id(userId); // 店铺管理员用户Id
// 设置店铺基础信息（添加null检查）
shopStoreBase.setUser_id(userId);
shopStoreBase.setStore_name(shopMchEntry.getStore_name());
shopStoreBase.setStore_category_id(shopMchEntry.getBiz_category()); // 重要，店铺分类id，对应 shop_base_store_category 表的分类
shopStoreBase.setStore_2nd_category_id(shopMchEntry.getBiz_second_category());
shopStoreBase.setStore_category_id(shopMchEntry.getBiz_category());
shopStoreBase.setStore_2nd_category_id(
shopMchEntry.getBiz_second_category() != null ? shopMchEntry.getBiz_second_category() : 0);
// 分账比例，最终提交给拉卡拉的分账比例是 20%。
BigDecimal splitRatio = shopMchEntryService.getMchEntryRatioOrDefault(shopMchEntry.getBiz_category(), shopMchEntry.getBiz_second_category(), shopMchEntry.getSplit_ratio(), new BigDecimal(94));
// 计算分账比例
BigDecimal splitRatio = shopMchEntryService.getMchEntryRatioOrDefault(
shopMchEntry.getBiz_category(),
shopMchEntry.getBiz_second_category(),
shopMchEntry.getSplit_ratio(),
new BigDecimal(94));
shopStoreBase.setSplit_ratio(splitRatio);
shopStoreBase.setPacking_fee(BigDecimal.ZERO);
shopStoreBase.setSplit_ratio(splitRatio); // 分账比例
shopStoreBase.setPacking_fee(BigDecimal.ZERO);// 默认0元打包费
// 处理图片信息
String storeFacadeImage = shopMchEntry.getFront_facade_image();
String storeLogoImage = shopMchEntry.getStore_logo();
if (StrUtil.isBlank(storeLogoImage)) {
storeLogoImage = storeFacadeImage;
}
shopStoreBase.setStore_logo(storeLogoImage); // 临时使用门面照片做logo
shopStoreBase.setStore_logo(storeLogoImage);
// 处理地址信息（添加null检查）
String storeDistrict = shopMchEntry.getStore_district();
if (storeDistrict != null) {
shopStoreBase.setStore_district_id(storeDistrict);
}
String storeArea = shopMchEntry.getStore_area();
if (storeArea != null) {
shopStoreBase.setStore_area(storeArea);
}
// 省市区记录有序列表
shopStoreBase.setStore_district_id(shopMchEntry.getStore_district());
shopStoreBase.setStore_area(shopMchEntry.getStore_area());
shopStoreBase.setStore_address(shopMchEntry.getStore_address());
shopStoreBase.setStore_longitude(shopMchEntry.getStore_longitude());
shopStoreBase.setStore_latitude(shopMchEntry.getStore_latitude());
shopStoreBase.setStore_grade_id(1001); // 店铺等级，默认为普通店铺
shopStoreBase.setStore_type(1);//店铺类型(ENUM): 1-卖家店铺; 2-供应商店铺
shopStoreBase.setStore_grade_id(1001);
shopStoreBase.setStore_type(1);
shopStoreBase.setStore_is_open(1);
shopStoreBase.setStore_is_selfsupport(0);
shopStoreBase.setStore_o2o_flag(0);
shopStoreBase.setSubsite_id(0);
// 拉卡拉外部商户号
// 设置拉卡拉信息
shopStoreBase.setLkl_merchant_no(shopMchEntry.getLkl_mer_cup_no());
// 拉卡拉分配的终端号
shopStoreBase.setLkl_term_no(shopMchEntry.getLkl_term_no());
shopStoreBase.setStore_state_id(StateCode.STORE_STATE_YES);//店铺资料信息状态(ENUM):3210-待完善资料; 3220-等待审核 ; 3230-资料审核没有通过;3240-资料审核通过,待付款
shopStoreBase.setStore_state_id(StateCode.STORE_STATE_YES);
shopStoreBase.setStore_time(DateUtil.date());
shopStoreBase.setStore_end_time(System.currentTimeMillis() + 1000L * 60 * 60 * 24 * 365 * 5); // 5年
shopStoreBase.setStore_end_time(System.currentTimeMillis() + 1000L * 60 * 60 * 24 * 365 * 5);
if (!save(shopStoreBase)) {
logger.error("生成店铺：新增或更改店铺基本信息失败");
if (allowThrown) {
throw new ApiException(I18nUtil._("新增或更改店铺基本信息失败"));
if (Boolean.TRUE.equals(allowThrown)) {
throw new ApiException("新增或更改店铺基本信息失败");
}
return Pair.of(0, "新增或更改店铺基础信息失败");
}
// 保存后店铺Id
// 获取店铺ID
Integer storeId = shopStoreBase.getStore_id();
if (CheckUtil.isEmpty(storeId)) {
logger.error("生成店铺：店铺ID获取失败");
return Pair.of(0, "店铺ID获取失败");
}
// shop_store_info
// 创建店铺信息
ShopStoreInfo shopStoreInfo = new ShopStoreInfo();
shopStoreInfo.setStore_id(storeId);
shopStoreInfo.setStore_start_time(DateUtil.date());
shopStoreInfo.setStore_end_time(DateUtil.offsetDay(DateUtil.date(), 365 * 5));
shopStoreInfo.setStore_opening_hours("08:00");
shopStoreInfo.setStore_close_hours("22:00");
shopStoreInfo.setStore_discount(BigDecimal.valueOf(10));// 原价
shopStoreInfo.setStore_opening_hours("07:30");
shopStoreInfo.setStore_close_hours("23:00");
shopStoreInfo.setStore_discount(BigDecimal.valueOf(10));
shopStoreInfo.setStore_banner(storeFacadeImage);
// 联系人手机号码
String contact_mobile = StrUtil.isBlank(shopMchEntry.getLegal_person_mobile()) ? shopMchEntry.getLogin_mobile() : shopMchEntry.getLegal_person_mobile();
// 处理联系人信息
String contact_mobile = StrUtil.isNotBlank(shopMchEntry.getLegal_person_mobile()) ?
shopMchEntry.getLegal_person_mobile() : shopMchEntry.getLogin_mobile();
shopStoreInfo.setStore_tel(contact_mobile);
shopStoreInfo.setContact_mobile(contact_mobile);
shopStoreInfo.setContact_name(shopMchEntry.getContact_name());
String websiteXFTC = "https://www.gpxscs.cn";
// 构建幻灯片
JSONArray list = new JSONArray();
if (StrUtil.isNotBlank(storeFacadeImage)) {
JSONObject slide = new JSONObject();
slide.put("img", storeFacadeImage);
slide.put("name", "店铺门面照片");
slide.put("check", true);
slide.put("url", websiteXFTC);
slide.put("url", "https://www.gpxscs.cn");
list.put(slide);
}
if (StrUtil.isNotBlank(shopMchEntry.getEnvironment_image())) {
@ -3264,54 +3296,64 @@ public class ShopStoreBaseServiceImpl extends BaseServiceImpl<ShopStoreBaseMappe
slide.put("img", shopMchEntry.getEnvironment_image());
slide.put("name", "店铺环境照片");
slide.put("check", true);
slide.put("url", websiteXFTC);
slide.put("url", "https://www.gpxscs.cn");
list.put(slide);
}
shopStoreInfo.setStore_slide(list.toString());
shopStoreInfo.setStore_address(shopMchEntry.getStore_address()); // 包含省市区的详细地址
if (shopMchEntry.getStore_address() != null) {
shopStoreInfo.setStore_address(shopMchEntry.getStore_address());
}
shopStoreInfo.setStore_state_id(StateCode.STORE_STATE_YES);
if (!shopStoreInfoService.save(shopStoreInfo)) {
logger.error("生成店铺：新增店铺info失败");
if (allowThrown) {
throw new ApiException(I18nUtil._("新增店铺信息失败"));
if (Boolean.TRUE.equals(allowThrown)) {
throw new ApiException("新增店铺信息失败");
}
return Pair.of(0, "新增店铺信息失败");
}
// 初始化默认公司信息，避免商家编辑不了，申请入驻即使是个人类型的，也需要保存相关应有信息，公司信息不能空着
// shop_store_company
// 创建店铺公司信息
ShopStoreCompany shopStoreCompany = shopStoreCompanyService.getCompany(storeId);
if (shopStoreCompany == null) {
shopStoreCompany = new ShopStoreCompany();
}
shopStoreCompany.setUser_id(userId);
shopStoreCompany.setStore_id(storeId);
// 联系人
// 设置联系人信息
shopStoreCompany.setContacts_name(shopMchEntry.getContact_name());
shopStoreCompany.setContacts_phone(contact_mobile);
// 公司名
String companyName = StrUtil.isBlank(shopMchEntry.getBiz_license_company()) ? shopMchEntry.getStore_name() : shopMchEntry.getBiz_license_company();
// 设置公司名称
String companyName = StrUtil.isNotBlank(shopMchEntry.getBiz_license_company()) ?
shopMchEntry.getBiz_license_company() : shopMchEntry.getStore_name();
shopStoreCompany.setCompany_name(companyName);
shopStoreCompany.setCompany_area(shopStoreBase.getStore_area());
if (storeArea != null) {
shopStoreCompany.setCompany_area(storeArea);
}
shopStoreCompany.setCompany_address(shopMchEntry.getStore_address());
// 营业执照
// 设置营业执照信息
shopStoreCompany.setBusiness_id(shopMchEntry.getBiz_license_number());
shopStoreCompany.setBusiness_license_electronic(shopMchEntry.getBiz_license_image());
// 企业法人
// 设置法人信息
shopStoreCompany.setLegal_person(shopMchEntry.getLegal_person_name());
shopStoreCompany.setLegal_person_number(shopMchEntry.getLegal_person_id_number());
shopStoreCompany.setLegal_person_electronic(shopMchEntry.getLegal_person_id_images());
// 银行对公账号
// 设置银行信息
shopStoreCompany.setBank_account_name(shopMchEntry.getAccount_holder_name());
shopStoreCompany.setBank_account_number(shopMchEntry.getAccount_number());
shopStoreCompany.setBank_name(shopMchEntry.getBank_name());
Date today = new Date(); // 当前时间
Date today = new Date();
shopStoreCompany.setOrganization_code_start(today);
shopStoreCompany.setOrganization_code_end(DateUtil.offsetDay(today, 365 * 5));// 五年
shopStoreCompany.setOrganization_code_end(DateUtil.offsetDay(today, 365 * 5));
shopStoreCompany.setEstablish_date(today);
shopStoreCompany.setBusiness_licence_start(today);
shopStoreCompany.setBusiness_licence_end(DateUtil.offsetDay(today, 365 * 10));
@ -3323,26 +3365,24 @@ public class ShopStoreBaseServiceImpl extends BaseServiceImpl<ShopStoreBaseMappe
if (!shopStoreCompanyService.save(shopStoreCompany)) {
logger.error("生成店铺：新增店铺公司失败");
if (allowThrown) {
throw new ApiException(I18nUtil._("新增店铺公司失败"));
if (Boolean.TRUE.equals(allowThrown)) {
throw new ApiException("新增店铺公司失败");
}
return Pair.of(0, "新增店铺公司失败");
}
}
// 创建店铺员工信息
List<ShopStoreEmployee> shopStoreEmployees = shopStoreEmployeeService.selectEmployeeByCondition(storeId, null, null);
ShopStoreEmployee shopStoreEmployee = new ShopStoreEmployee();
shopStoreEmployee.setStore_id(storeId);
shopStoreEmployee.setUser_id(userId);
shopStoreEmployee.setRights_group_id(""); // 店铺管理员,店铺
shopStoreEmployee.setRights_group_id("");
shopStoreEmployee.setEmployee_is_kefu(CommonConstant.Enable);
if (CollUtil.isEmpty(shopStoreEmployees)) { // 添加管理员
// shop_store_employee 店铺员工，添加管理员
if (CollUtil.isEmpty(shopStoreEmployees)) {
shopStoreEmployee.setEmployee_is_admin(CommonConstant.Enable);
} else { // 添加店员或管理员
} else {
shopStoreEmployees = shopStoreEmployeeService.selectEmployeeByCondition(storeId, userId, null);
if (CollUtil.isEmpty(shopStoreEmployees)) {
shopStoreEmployee.setEmployee_is_admin(CommonConstant.Disable);
@ -3353,13 +3393,13 @@ public class ShopStoreBaseServiceImpl extends BaseServiceImpl<ShopStoreBaseMappe
if (!shopStoreEmployeeService.save(shopStoreEmployee)) {
logger.error("生成店铺：新增店铺员工失败");
if (allowThrown) {
throw new ApiException(I18nUtil._("新增店铺员工失败"));
if (Boolean.TRUE.equals(allowThrown)) {
throw new ApiException("新增店铺员工失败");
}
return Pair.of(0, "新增店铺员工失败");
}
// 生成店铺的太阳码 2025-03-31
// 生成微信二维码
if (StrUtil.isBlank(shopStoreBase.getWx_qrcode())) {
Pair<String, String> resp = wxQrCodeService.genUnlimitedWxQrCode("pagesub/index/store", "store_id=" + storeId);
if (StrUtil.isNotBlank(resp.getFirst())) {
@ -3367,252 +3407,294 @@ public class ShopStoreBaseServiceImpl extends BaseServiceImpl<ShopStoreBaseMappe
}
}
// 注意：关联店铺到用户，给用户增加店铺管理员权限
// 初始化店铺额外信息
initStoreExtraInfo(userId, storeId, allowThrown);
// 更改店铺Id和状态
// 更新商家入驻状态和新建的店铺ID
if (shopMchEntry.getId() != null) {
shopMchEntryService.updateMerchEntryStoreStatus(shopMchEntry.getId(), storeId);
}
// 立即创建顺丰店铺，附带初始化同城配送默认设置
String[] areaNames = StrUtil.isNotBlank(shopMchEntry.getStore_area()) ? shopMchEntry.getStore_area().split("/") : new String[0];
String cityName = areaNames.length > 0 ? areaNames[areaNames.length - 1] : shopMchEntry.getStore_area().replace("/", "");
sfExpressApiService.createSfExpressShop(storeId, shopMchEntry.getStore_name(), cityName, shopMchEntry.getStore_address(), shopMchEntry.getContact_name(), contact_mobile, shopMchEntry.getStore_longitude(), shopMchEntry.getStore_longitude());
// 创建顺丰店铺（修复经纬度参数错误）
if (storeArea != null) {
String[] areaNames = storeArea.split("/");
String cityName = areaNames.length > 0 ? areaNames[areaNames.length - 1] : storeArea.replace("/", "");
sfExpressApiService.createSfExpressShop(storeId, shopMchEntry.getStore_name(),
cityName, shopMchEntry.getStore_address(), shopMchEntry.getContact_name(),
contact_mobile, shopMchEntry.getStore_longitude(), shopMchEntry.getStore_latitude());
}
return Pair.of(storeId, "新增成功");
} catch (Exception e) {
logger.error("店铺生成失败", e);
if (allowThrown) {
throw new ApiException(I18nUtil._("店铺生成失败"));
if (Boolean.TRUE.equals(allowThrown)) {
throw new ApiException("店铺生成失败");
}
return Pair.of(0, e.getMessage());
}
}
/**
* 初始化店长（店铺管理员）的权限组
*
* @param userId
* @param storeId
* @param userId 用户ID
* @param storeId 店铺ID
* @param allowThrown 是否允许抛出异常
*/
private void initStoreExtraInfo(Integer userId, Integer storeId, Boolean allowThrown) {
if (ObjectUtil.isNull(userId) || ObjectUtil.isNull(storeId)) {
log.warn("初始化店铺额外信息参数为空: userId={}, storeId={}", userId, storeId);
return;
}
Date today = new Date(); // 当前时间
try {
// 初始化时添加一条店铺分析信息
ShopStoreAnalytics storeAnalytics = shopStoreAnalyticsService.getByStoreId(storeId);
if (storeAnalytics == null) {
storeAnalytics = new ShopStoreAnalytics();
storeAnalytics.setStore_id(storeId);
if (!shopStoreAnalyticsService.add(storeAnalytics)) {
if (allowThrown) {
String errorMsg = "初始化店铺分析信息失败";
if (Boolean.TRUE.equals(allowThrown)) {
throw new ApiException(ResultCode.FAILED);
}
log.error("初始化店铺分析信息失败");
log.error(errorMsg);
return;
}
}
// 初始化店铺商品标签
QueryWrapper<ShopBaseProductTag> tagQueryWrapper = new QueryWrapper<>();
tagQueryWrapper.orderByAsc("product_tag_id");
Page<ShopBaseProductTag> base_product_tag_row = shopBaseProductTagService.lists(tagQueryWrapper, 1, 5);
List<ShopStoreProductTag> store_product_tag_row = new ArrayList<>();
for (ShopBaseProductTag teg : base_product_tag_row.getRecords()) {
Page<ShopBaseProductTag> baseProductTagPage = shopBaseProductTagService.lists(tagQueryWrapper, 1, 5);
if (baseProductTagPage != null && CollUtil.isNotEmpty(baseProductTagPage.getRecords())) {
List<ShopStoreProductTag> storeProductTagList = new ArrayList<>();
for (ShopBaseProductTag tag : baseProductTagPage.getRecords()) {
if (tag != null) {
ShopStoreProductTag shopStoreProductTag = new ShopStoreProductTag();
store_product_tag_row.add(shopStoreProductTag);
shopStoreProductTag.setProduct_tag_id(teg.getProduct_tag_id());
shopStoreProductTag.setProduct_tag_id(tag.getProduct_tag_id());
shopStoreProductTag.setStore_id(storeId);
shopStoreProductTag.setProduct_tag_time(today);
shopStoreProductTag.setStore_product_tag_buildin(1);
storeProductTagList.add(shopStoreProductTag);
}
}
if (CollUtil.isNotEmpty(store_product_tag_row)) {
if (!shopStoreProductTagService.saveOrUpdate(store_product_tag_row)) {
if (allowThrown) {
if (CollUtil.isNotEmpty(storeProductTagList)) {
if (!shopStoreProductTagService.saveOrUpdate(storeProductTagList)) {
String errorMsg = "初始化店铺商品标签失败";
if (Boolean.TRUE.equals(allowThrown)) {
throw new ApiException(ResultCode.FAILED);
}
log.error("初始化店铺商品标签失败");
log.error(errorMsg);
return;
}
}
}
// 初始化默认店铺仓库
InvoicingWarehouseBase invoicingWarehouseBase = new InvoicingWarehouseBase();
invoicingWarehouseBase.setWarehouse_name(I18nUtil._("默认"));
invoicingWarehouseBase.setWarehouse_name("默认");
invoicingWarehouseBase.setStore_id(storeId);
invoicingWarehouseBase.setWarehouse_address("");
invoicingWarehouseBase.setWarehouse_number("");
invoicingWarehouseBase.setWarehouse_contact("");
if (!invoicingWarehouseBaseService.saveOrUpdate(invoicingWarehouseBase)) {
if (allowThrown) {
String errorMsg = "初始化默认店铺仓库失败";
if (Boolean.TRUE.equals(allowThrown)) {
throw new ApiException(ResultCode.FAILED);
}
log.error("初始化默认店铺仓库失败");
log.error(errorMsg);
return;
}
// 初始化默认权限
Page<Serializable> page = shopStoreEmployeeRightsBaseService.listKey(new QueryWrapper<>(), 1, ConfigConstant.MAX_LIST_NUM);
List<Integer> rightsGroupRightsIds = new ArrayList<>();
if (page != null && CollUtil.isNotEmpty(page.getRecords())) {
rightsGroupRightsIds = Convert.toList(Integer.class, page.getRecords());
}
List<Integer> rights_group_rights_ids = Convert.toList(Integer.class, page.getRecords());
List<ShopStoreEmployeeRightsGroup> shopStoreEmployeeRightsGroups = new ArrayList<>();
String str_rights_group_rights_ids = CollUtil.join(rights_group_rights_ids, ",");
String strRightsGroupRightsIds = CollUtil.join(rightsGroupRightsIds, ",");
// 创建各种角色权限组
ShopStoreEmployeeRightsGroup shopManager = new ShopStoreEmployeeRightsGroup();
shopManager.setStore_id(storeId);
shopManager.setRights_group_rights_ids(str_rights_group_rights_ids);
shopManager.setRights_group_name(I18nUtil._("店铺管理员")); //Store Owner
shopManager.setRights_group_rights_ids(strRightsGroupRightsIds);
shopManager.setRights_group_name("店铺管理员"); // Store Owner
shopManager.setRights_group_rights_data(""); // Store Owner
shopStoreEmployeeRightsGroups.add(shopManager);
ShopStoreEmployeeRightsGroup operationsManager = new ShopStoreEmployeeRightsGroup();
operationsManager.setStore_id(storeId);
operationsManager.setRights_group_rights_ids(str_rights_group_rights_ids);
operationsManager.setRights_group_name(I18nUtil._("运营经理")); //Store Owner
operationsManager.setRights_group_rights_ids(strRightsGroupRightsIds);
operationsManager.setRights_group_name("运营经理"); // Store Owner
operationsManager.setRights_group_rights_data(""); // Store Owner
shopStoreEmployeeRightsGroups.add(operationsManager);
ShopStoreEmployeeRightsGroup orderReviewer = new ShopStoreEmployeeRightsGroup();
orderReviewer.setStore_id(storeId);
orderReviewer.setRights_group_rights_ids(str_rights_group_rights_ids);
orderReviewer.setRights_group_name(I18nUtil._("订单审核员")); //Store Owner
orderReviewer.setRights_group_rights_ids(strRightsGroupRightsIds);
orderReviewer.setRights_group_name("订单审核员"); // Store Owner
orderReviewer.setRights_group_rights_data(""); // Store Owner
shopStoreEmployeeRightsGroups.add(orderReviewer);
ShopStoreEmployeeRightsGroup financialAuditor = new ShopStoreEmployeeRightsGroup();
financialAuditor.setStore_id(storeId);
financialAuditor.setRights_group_rights_ids(str_rights_group_rights_ids);
financialAuditor.setRights_group_name(I18nUtil._("财务审核员")); //Store Owner
financialAuditor.setRights_group_rights_ids(strRightsGroupRightsIds);
financialAuditor.setRights_group_name("财务审核员"); // Store Owner
financialAuditor.setRights_group_rights_data(""); // Store Owner
shopStoreEmployeeRightsGroups.add(financialAuditor);
ShopStoreEmployeeRightsGroup shippingAuditor = new ShopStoreEmployeeRightsGroup();
shippingAuditor.setStore_id(storeId);
shippingAuditor.setRights_group_rights_ids(str_rights_group_rights_ids);
shippingAuditor.setRights_group_name(I18nUtil._("发货审核员")); //Store Owner
shippingAuditor.setRights_group_rights_ids(strRightsGroupRightsIds);
shippingAuditor.setRights_group_name("发货审核员"); // Store Owner
shippingAuditor.setRights_group_rights_data(""); // Store Owner
shopStoreEmployeeRightsGroups.add(shippingAuditor);
ShopStoreEmployeeRightsGroup businessManager = new ShopStoreEmployeeRightsGroup();
businessManager.setStore_id(storeId);
businessManager.setRights_group_rights_ids(str_rights_group_rights_ids);
businessManager.setRights_group_name(I18nUtil._("业务经理")); //Store Owner
businessManager.setRights_group_rights_ids(strRightsGroupRightsIds);
businessManager.setRights_group_name("业务经理"); // Store Owner
businessManager.setRights_group_rights_data(""); // Store Owner
shopStoreEmployeeRightsGroups.add(businessManager);
ShopStoreEmployeeRightsGroup warehouseManager = new ShopStoreEmployeeRightsGroup();
warehouseManager.setStore_id(storeId);
warehouseManager.setRights_group_rights_ids(str_rights_group_rights_ids);
warehouseManager.setRights_group_name(I18nUtil._("仓库管理员")); //Store Owner
warehouseManager.setRights_group_rights_ids(strRightsGroupRightsIds);
warehouseManager.setRights_group_name("仓库管理员"); // Store Owner
warehouseManager.setRights_group_rights_data(""); // Store Owner
shopStoreEmployeeRightsGroups.add(warehouseManager);
ShopStoreEmployeeRightsGroup dataMaintainer = new ShopStoreEmployeeRightsGroup();
dataMaintainer.setStore_id(storeId);
dataMaintainer.setRights_group_rights_ids(str_rights_group_rights_ids);
dataMaintainer.setRights_group_name(I18nUtil._("资料维护员")); //Store Owner
dataMaintainer.setRights_group_rights_ids(strRightsGroupRightsIds);
dataMaintainer.setRights_group_name("资料维护员"); // Store Owner
dataMaintainer.setRights_group_rights_data(""); // Store Owner
shopStoreEmployeeRightsGroups.add(dataMaintainer);
ShopStoreEmployeeRightsGroup customerService = new ShopStoreEmployeeRightsGroup();
customerService.setStore_id(storeId);
customerService.setRights_group_rights_ids(str_rights_group_rights_ids);
customerService.setRights_group_name(I18nUtil._("客服")); //Store Owner
customerService.setRights_group_rights_ids(strRightsGroupRightsIds);
customerService.setRights_group_name("客服"); // Store Owner
customerService.setRights_group_rights_data(""); // Store Owner
shopStoreEmployeeRightsGroups.add(customerService);
ShopStoreEmployeeRightsGroup extension1 = new ShopStoreEmployeeRightsGroup();
extension1.setStore_id(storeId);
extension1.setRights_group_rights_ids(str_rights_group_rights_ids);
extension1.setRights_group_name(I18nUtil._("扩展1")); //Store Owner
extension1.setRights_group_rights_ids(strRightsGroupRightsIds);
extension1.setRights_group_name("扩展1"); // Store Owner
extension1.setRights_group_rights_data(""); // Store Owner
shopStoreEmployeeRightsGroups.add(extension1);
ShopStoreEmployeeRightsGroup extension2 = new ShopStoreEmployeeRightsGroup();
extension2.setStore_id(storeId);
extension2.setRights_group_rights_ids(str_rights_group_rights_ids);
extension2.setRights_group_name(I18nUtil._("扩展2")); //Store Owner
extension2.setRights_group_rights_ids(strRightsGroupRightsIds);
extension2.setRights_group_name("扩展2"); // Store Owner
extension2.setRights_group_rights_data(""); // Store Owner
shopStoreEmployeeRightsGroups.add(extension2);
if (!shopStoreEmployeeRightsGroupService.saveOrUpdate(shopStoreEmployeeRightsGroups)) {
if (allowThrown) {
String errorMsg = "初始化店铺员工默认权限失败";
if (Boolean.TRUE.equals(allowThrown)) {
throw new ApiException(ResultCode.FAILED);
}
log.error("初始化店铺员工默认权限失败");
log.error(errorMsg);
return;
}
// 添加店铺到用户
AccountUserBase accountUserBase = new AccountUserBase();
List<Integer> rights_group_id = shopStoreEmployeeRightsGroups.stream().map(s -> s.getRights_group_id()).collect(Collectors.toList());
if (CollUtil.isNotEmpty(rights_group_id)) {
List<Integer> rightsGroupId = shopStoreEmployeeRightsGroups.stream()
.map(ShopStoreEmployeeRightsGroup::getRights_group_id)
.filter(Objects::nonNull)
.collect(Collectors.toList());
if (CollUtil.isNotEmpty(rightsGroupId)) {
// 初始化雇员信息
UpdateWrapper<ShopStoreEmployee> queryWrapper = new UpdateWrapper<>();
queryWrapper.eq("user_id", userId).eq("store_id", storeId)
.set("rights_group_id", CollUtil.join(rights_group_id, ","))
.set("rights_group_id", CollUtil.join(rightsGroupId, ","))
.set("employee_is_admin", CommonConstant.Enable)
.set("employee_is_kefu", CommonConstant.Enable);
if (!shopStoreEmployeeService.update(queryWrapper)) {
if (allowThrown) {
throw new ApiException(I18nUtil._("设置店铺管理员权限失败"));
String errorMsg = "设置店铺管理员权限失败";
if (Boolean.TRUE.equals(allowThrown)) {
throw new ApiException(errorMsg);
}
log.error("设置店铺管理员权限失败！");
log.error(errorMsg);
return;
}
// todo 初始化商家角色（默认 店铺管理员角色）
String user_rights_group_id = Convert.toStr(rights_group_id.get(0));
accountUserBase.setRights_group_id(StrUtil.join(",", user_rights_group_id, 2));
// 初始化商家角色（默认 店铺管理员角色）
String userRightsGroupId = Convert.toStr(rightsGroupId.get(0));
accountUserBase.setRights_group_id(StrUtil.join(",", userRightsGroupId, "2"));
}
// 用法人、小微个人的手机号注册商家账号，作为店铺的管理员
accountUserBase.setUser_id(userId);
// 修复：需要实现 appendStoreIdToAccount 方法或替换为正确的逻辑
String storeIds = appendStoreIdToAccount(userId, storeId);
accountUserBase.setStore_ids(storeIds); // 重要，给用户添加上这个店铺的归属权
if (!accountService.saveOrUpdateUserBase(accountUserBase)) {
if (allowThrown) {
throw new ApiException(I18nUtil._("店铺关联到用户失败"));
String errorMsg = "店铺关联到用户失败";
if (Boolean.TRUE.equals(allowThrown)) {
throw new ApiException(errorMsg);
}
log.error("店铺关联到用户失败！");
log.error(errorMsg);
return;
}
// 添加默认运输模板
ShopStoreTransportType shopStoreTransportType = new ShopStoreTransportType();
shopStoreTransportType.setTransport_type_name(I18nUtil._("通用全免")); // 模板名称
shopStoreTransportType.setTransport_type_name("通用全免"); // 模板名称
shopStoreTransportType.setStore_id(storeId); // 所属店铺
shopStoreTransportType.setTransport_type_pricing_method(1); // 计费规则(ENUM):1-按件数;2-按重量;3-按体积
shopStoreTransportType.setTransport_type_time(today);
shopStoreTransportType.setTransport_type_freight_free(BigDecimal.ZERO); // 免运费额度
shopStoreTransportType.setTransport_type_free(1);
if (!shopStoreTransportTypeService.saveOrUpdate(shopStoreTransportType)) {
if (allowThrown) {
throw new ApiException(I18nUtil._("添加运输模板失败"));
String errorMsg = "添加运输模板失败";
if (Boolean.TRUE.equals(allowThrown)) {
throw new ApiException(errorMsg);
}
log.error("添加运输模板失败！");
log.error(errorMsg);
return;
}
// 店铺配置
ShopStoreConfig shopStoreConfig = new ShopStoreConfig();
shopStoreConfig.setStore_id(storeId);
List<Integer> sc_order_process = Arrays.asList(
List<Integer> scOrderProcess = Arrays.asList(
StateCode.ORDER_PROCESS_PAY, // 支付
StateCode.ORDER_PROCESS_OUT, // 出库审核
StateCode.ORDER_PROCESS_SHIPPED, // 发货确认
StateCode.ORDER_PROCESS_RECEIVED);
String str_sc_order_process = CollUtil.join(sc_order_process, ",");
shopStoreConfig.setSc_order_process(str_sc_order_process);
List<Integer> sc_order_return_process = Arrays.asList(
StateCode.RETURN_PROCESS_SUBMIT,
//【客户】提交退单1ReturnReturn
StateCode.RETURN_PROCESS_CHECK,
//退单审核1ReturnReturn
StateCode.RETURN_PROCESS_FINISH
//完成1ReturnReturn3130-商家拒绝退货
StateCode.ORDER_PROCESS_RECEIVED // 收货确认
);
String str_sc_order_return_process = CollUtil.join(sc_order_return_process, ",");
shopStoreConfig.setSc_order_return_process(str_sc_order_return_process); // 退货流程设置(DOT)
String strScOrderProcess = CollUtil.join(scOrderProcess, ",");
shopStoreConfig.setSc_order_process(strScOrderProcess);
List<Integer> scOrderReturnProcess = Arrays.asList(
StateCode.RETURN_PROCESS_SUBMIT, // 【客户】提交退单
StateCode.RETURN_PROCESS_CHECK, // 退单审核
StateCode.RETURN_PROCESS_FINISH // 完成
);
String strScOrderReturnProcess = CollUtil.join(scOrderReturnProcess, ",");
shopStoreConfig.setSc_order_return_process(strScOrderReturnProcess); // 退货流程设置(DOT)
shopStoreConfig.setSc_settle_circle(30);
shopStoreConfig.setSc_settle_last_time(System.currentTimeMillis());
shopStoreConfig.setSc_settle_next_time(Convert.toLong(DateUtil.nextMonth()));
@ -3625,27 +3707,46 @@ public class ShopStoreBaseServiceImpl extends BaseServiceImpl<ShopStoreBaseMappe
shopStoreConfig.setSc_festival_amount_down(BigDecimal.ZERO);
shopStoreConfig.setSc_festival_amount_upper(BigDecimal.ZERO);
shopStoreConfig.setSc_festival_float_proportion(BigDecimal.ZERO);
if (!shopStoreConfigService.saveOrUpdate(shopStoreConfig)) {
if (allowThrown) {
throw new ApiException(I18nUtil._("添加订单流转配置失败"));
String errorMsg = "添加订单流转配置失败";
if (Boolean.TRUE.equals(allowThrown)) {
throw new ApiException(errorMsg);
}
log.error("添加订单流转配置失败！");
log.error(errorMsg);
return;
}
// 添加默认客户等级
InvoicingCustomerLevel invoicingCustomerLevel = new InvoicingCustomerLevel();
invoicingCustomerLevel.setCustomer_level_name(I18nUtil._("普通（系统默认，不可删除）"));
invoicingCustomerLevel.setCustomer_level_name("普通（系统默认，不可删除）");
invoicingCustomerLevel.setCustomer_level_discountrate(new BigDecimal(100));
invoicingCustomerLevel.setCustomer_level_is_buildin(1);
invoicingCustomerLevel.setCustomer_level_desc("");
if (!invoicingCustomerLevelService.saveOrUpdate(invoicingCustomerLevel)) {
if (allowThrown) {
throw new ApiException(I18nUtil._("添加默认客户等级失败"));
String errorMsg = "添加默认客户等级失败";
if (Boolean.TRUE.equals(allowThrown)) {
throw new ApiException(errorMsg);
}
log.error("添加默认客户等级失败！");
log.error(errorMsg);
return;
}
log.info("初始化店铺额外信息成功: userId={}, storeId={}", userId, storeId);
} catch (Exception e) {
log.error("初始化店铺额外信息异常: userId={}, storeId={}", userId, storeId, e);
if (Boolean.TRUE.equals(allowThrown)) {
if (e instanceof ApiException) {
throw e;
} else {
throw new ApiException("初始化店铺信息失败: " + e.getMessage());
}
}
}
}
/**
* 根据店铺名称判断店铺是否存在
@ -3996,14 +4097,14 @@ public class ShopStoreBaseServiceImpl extends BaseServiceImpl<ShopStoreBaseMappe
*
* @param userId 用户ID
* @param storeId 要追加的店铺ID
* @return 追加后的店铺ID字符串（格式：id1,id2,）或空字符串（参数无效/用户不存在）
* @return 追加后的店铺ID字符串（格式：id1,id2）或空字符串（参数无效/用户不存在）
* @throws IllegalArgumentException 当参数无效时抛出
*/
@Override
public String appendStoreIdToAccount(Integer userId, Integer storeId) {
// 参数校验
if (ObjectUtil.isNull(userId) || ObjectUtil.isNull(storeId)) {
log.error("用户ID和店铺ID不能为空，userId: {}, storeId: {}", userId, storeId);
if (CheckUtil.isEmpty(userId) || CheckUtil.isEmpty(storeId)) {
log.warn("用户ID和店铺ID不能为空，userId: {}, storeId: {}", userId, storeId);
return "";
}
@ -4011,16 +4112,20 @@ public class ShopStoreBaseServiceImpl extends BaseServiceImpl<ShopStoreBaseMappe
// 查询用户现有的店铺ID列表
AccountUserBase accountUserBase = accountService.getUserBase(userId);
// 用户不存在或没有店铺时返回空
// 用户不存在时返回空字符串
if (accountUserBase == null) {
log.warn("用户不存在，userId: {}", userId);
return "";
}
List<String> idList = new ArrayList<>();
String storeIds = accountUserBase.getStore_ids();
if (StrUtil.isBlank(storeIds)) {
// 用户当前没有店铺ID，直接添加新店铺ID
idList.add(storeId.toString());
} else {
// 用户已有店铺ID列表，解析并去重
idList = StrUtil.split(storeIds, ",");
if (!idList.contains(storeId.toString())) {
// 追加新店铺ID
@ -4028,8 +4133,14 @@ public class ShopStoreBaseServiceImpl extends BaseServiceImpl<ShopStoreBaseMappe
}
}
// 返回去重后的店铺ID列表，用逗号连接
return StrUtil.join(",", CollUtil.distinct(idList));
} catch (ApiException e) {
// 处理特定的API异常
log.error("调用账户服务异常，userId: {}, storeId: {}", userId, storeId, e);
return "";
} catch (Exception e) {
// 处理其他未预期的异常
log.error("追加店铺ID到用户失败，userId: {}, storeId: {}", userId, storeId, e);
return "";
}