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

fix 入驻潜在空指针问题

Browse Source
This commit is contained in:
Jack 2025-09-24 21:57:02 +08:00
parent 52eead2229
commit a25e511404
9 changed files with 960 additions and 649 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) {

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

@ -377,36 +377,43 @@ public class LakalaApiServiceImpl implements LakalaApiService {
/**
* 商家申请入网电子合同（给到商家签署合同）
*
* @param mchId
* @return
* @param mchId 商户ID
* @return Pair<Boolean, String> 申请结果，第一个元素表示是否成功，第二个元素为结果信息
*/
@Override
public Pair<Boolean, String> applyLedgerMerEc(Long mchId) {
log.debug("商家开始申请入网电子合同");
if (ObjectUtil.isEmpty(mchId)) {
return Pair.of(false, I18nUtil._("缺少商家必要参数！"));
log.debug("商家开始申请入网电子合同，入驻编号: {}", mchId);
// 1. 参数校验
if (CheckUtil.isEmpty(mchId)) {
log.warn("商家申请入网电子合同失败：缺少商家必要参数，入驻编号: {}", mchId);
return Pair.of(false, "缺少商家入驻编号！");
}
// 获取商家信息
// 2. 获取商家信息
ShopMchEntry shopMchEntry = shopMchEntryService.shopMerchEntryById(mchId);
if (shopMchEntry == null) {
return Pair.of(false, I18nUtil._("缺少商家相关信息！"));
if (ObjectUtil.isEmpty(shopMchEntry)) {
log.warn("商家申请入网电子合同失败：缺少商家相关入驻信息，入驻编号: {}", mchId);
return Pair.of(false, "缺少商家相关入驻信息！");
}
String contractMobile = shopMchEntry.getLegal_person_mobile();
if (StrUtil.isBlank(contractMobile)) {
log.warn("商家申请入网电子合同失败：联系人手机号为空，入驻编号: {}", mchId);
return Pair.of(false, "联系人手机号不能为空！");
}
// 3. 检查是否已存在已完成的电子合同
LklLedgerEc lklLedgerEc = lklLedgerEcService.getByMchId(shopMchEntry.getId(), "", CommonConstant.Enable);
if (lklLedgerEc != null
&& "COMPLETED".equals(lklLedgerEc.getEc_status())) {
// TODO 电子合同已签署完成（但有一些错误的信息），这种情况，需要怎么处理？
// 办法：重新再签署合同，更新拉卡拉的电子合同信息到商家入驻表中
if (lklLedgerEc != null && "COMPLETED".equals(lklLedgerEc.getEc_status())) {
log.info("商户:{} 电子合同已签署过，重新提交将被覆盖！", mchId);
}
// 是企业类型商家
// 4. 判断商家类型（企业或个人）
Boolean isQy = CommonConstant.MCH_ENTITY_TYPE_QY.equals(shopMchEntry.getEntity_type());
log.debug("商家类型：{}，isQy: {}", isQy ? "企业" : "个人", isQy);
// 5. 装配请求数据
JSONObject reqData = new JSONObject();
reqData.put("order_no", StringUtils.genLklOrderNo(8));
reqData.put("org_id", orgCode);
@ -430,7 +437,7 @@ public class LakalaApiServiceImpl implements LakalaApiService {
reqData.put("acct_name", shopMchEntry.getAccount_holder_name());
reqData.put("remark", "申请入网电子合同");
// 正式上线的时候，调整 api 地址
// 6. 构建回调地址
String domain = projectDomain;
if (isProdProject()) {
domain += "/api";
@ -440,11 +447,11 @@ public class LakalaApiServiceImpl implements LakalaApiService {
String retUrl = domain + "/mobile/shop/lakala/ec/applyNotify";
reqData.put("ret_url", retUrl);
// 7. 构建合同参数
LocalDate today = LocalDate.now();
String signDate = DateTimeUtils.formatLocalDate(today, "yyyy-MM-dd");
String platformName = "桂平发发网络有限公司";
JSONObject ecParams = new JSONObject();
ecParams.put("A1", isQy ? shopMchEntry.getBiz_license_company() : shopMchEntry.getAccount_holder_name());
ecParams.put("A30", wxFee); // 测试环境微信费率0.6
@ -507,6 +514,7 @@ public class LakalaApiServiceImpl implements LakalaApiService {
// 注：该字段是json字符串，不是json对象
reqData.put("ec_content_parameters", ecParams.toString());
// 8. 构建请求体
JSONObject reqBody = new JSONObject();
reqBody.put("req_time", DateTimeUtils.formatDateTime(LocalDateTime.now(), "yyyyMMddHHmmss"));
reqBody.put("version", "3.0");
@ -521,25 +529,27 @@ public class LakalaApiServiceImpl implements LakalaApiService {
log.debug("申请入网电子合同请求参数：{}", JsonUtil.toJSONString(reqBody));
// 9. 发送请求
String errMsg = "";
JSONObject response = RestTemplateHttpUtil.sendLklPost(reqUrl, header, reqBody, JSONObject.class);
log.debug("拉卡拉申请入网电子合同响应参数：{}", JsonUtil.toJSONString(response));
if (ObjectUtil.isEmpty(response) || !lklSuccessCode.equals(response.getStr("retCode"))) {
errMsg = "拉卡拉申请入网电子合同，" + response.getStr("retMsg");
log.warn("拉卡拉申请入网电子合同失败：{}，商户ID: {}", errMsg, mchId);
shopMchEntryService.updateMerchEntryApprovalByMchId(shopMchEntry.getId(), CommonConstant.MCH_APPR_STA_LKL_NOPASS, errMsg);
return Pair.of(false, errMsg);
}
JSONObject respData = response.getJSONObject("respData");
if (respData == null) {
errMsg = "拉卡拉申请入网电子合同，" + response.getStr("retMsg");
errMsg = "拉卡拉申请入网电子合同，响应数据为空";
log.warn("拉卡拉申请入网电子合同失败：{}，入驻编号: {}", errMsg, mchId);
shopMchEntryService.updateMerchEntryApprovalByMchId(shopMchEntry.getId(), CommonConstant.MCH_APPR_STA_LKL_NOPASS, errMsg);
return Pair.of(false, errMsg);
}
// 商家入网申请电子合同处理数据
// 先写入本地数据库表中
// 10. 处理响应数据并保存到本地数据库
LklLedgerEc record = new LklLedgerEc();
record.setMch_id(mchId);
record.setMch_mobile(contractMobile);
@ -550,32 +560,31 @@ public class LakalaApiServiceImpl implements LakalaApiService {
String ecResultUrl = respData.getStr("result_url");
record.setResult_url(ecResultUrl);
record.setResp_body(response.toString());
Boolean success = lklLedgerEcService.addOrUpdateByMchId(record);
if (!success) {
errMsg = "申请入网电子合同失败，数据保存失败";
shopMchEntryService.updateMerchEntryApprovalByMchId(shopMchEntry.getId(), CommonConstant.MCH_APPR_STA_NOPASS, errMsg);
log.error("申请入网电子合同失败：数据保存失败，商户ID: {}", mchId);
shopMchEntryService.updateMerchEntryApprovalByMchId(shopMchEntry.getId(), CommonConstant.MCH_APPR_STA_LKL_NOPASS, errMsg);
return Pair.of(false, errMsg);
}
// 更新拉卡拉的电子合同信息到商家入驻表中
// 11. 更新拉卡拉的电子合同信息到商家入驻表中
shopMchEntryService.updateMerchEntryEcResultUrlByMchId(mchId, ecResultUrl);
// 发短信给商家，及时签署合同 SMS_488465246
//
//恭喜您的开店入驻申请已审核通过！请尽快登录小发商家版APP平台签署电子合同，签署链接24小时内有效（逾期需重新提交申请）。如有疑问请联系客服，感谢您的支持！
// shopMessageTemplateService.aliyunSmsSend(contractMobile, "SMS_493160417", null);//SMS_479760276
// 恭喜！您的开店入驻申请已审核通过，点击链接 https://mall.gpxscs.cn/api/mobile/shop/lakala/sign/ec/${code}
// 或前往小发商家版APP完成电子合同签署，链接24小时内有效（逾期需重新提交申请）。如有疑问可联系客服，感谢您的支持！
// 12. 发送短信通知商家及时签署合同
shopMessageTemplateService.aliyunSmsSend(contractMobile, "SMS_494860064", null);
// 13. 发送推送消息通知商家签署电子合同
JSONObject payload = new JSONObject();
payload.put("category", CommonConstant.PUSH_MSG_CATE_EC);
pushMessageService.noticeMerchantSignEcContract(shopMchEntry.getCreated_by(), payload);
pushMessageService.noticeMerchantSignEcContract(shopMchEntry.getCreated_by(), payload, false);
log.info("商家入网申请电子合同成功，入驻编号: {}", mchId);
return Pair.of(true, "商家入网申请电子合同成功");
}
/**
* 商户分账业务开通申请
*
@ -618,6 +627,10 @@ public class LakalaApiServiceImpl implements LakalaApiService {
if (!Boolean.TRUE.equals(forceReApply)) {
log.info("商户{}已申请过分账业务，无需重复申请", merCupNo);
// 检查绑定关系
return Pair.of(true, I18nUtil._("商家已经申请过了！"));
}
}
@ -893,83 +906,94 @@ public class LakalaApiServiceImpl implements LakalaApiService {
/**
* 商户入网电子合同申请回调通知
* <p>
* 处理拉卡拉商户入网电子合同签署完成后的回调通知，更新合同状态并触发后续进件流程。
* 参考：https://o.lakala.com/#/home/document/detail?id=289
*
* @param request
* @return
* @param request HTTP请求对象，包含拉卡拉回调通知的参数
* @return JSONObject 响应结果对象
*/
@Override
public JSONObject applyLedgerMerEcNotify(HttpServletRequest request) {
log.debug("商户入网电子合同申请回调通知开始");
// 验签
log.debug("商户入网电子合同申请回调通知开始处理");
// 1. 验签处理
Pair<Boolean, String> checkResult = LakalaUtil.chkLklApiNotifySign(request, lklNotifyCerPath, false);
if (!checkResult.getFirst()) {
log.warn("商户入网电子合同申请回调验签失败: {}", checkResult.getSecond());
return JSONUtil.createObj().set("code", "FAIL").set("retMsg", checkResult.getSecond());
}
String errMsg = "入网电子合同申请回调:";
// 2. 初始化响应对象
JSONObject respData = new JSONObject();
respData.set("code", "FAIL").set("message", "返回数据转换异常！");
// 3. 解析回调参数
JSONObject paramsJSON = JSONUtil.parseObj(checkResult.getSecond());
if (paramsJSON == null) {
log.warn("商户入网电子合同申请回调参数解析失败");
return respData;
}
// 4. 提取关键参数
Long ecApplyId = paramsJSON.getLong("ecApplyId");
String ecNo = paramsJSON.getStr("ecNo");
String ecStatus = paramsJSON.getStr("ecStatus"); // COMPLETED
// 5. 合同状态校验
if (ecStatus == null || !ecStatus.equals("COMPLETED")) {
log.debug("入网电子合同申请未签署完成！");
log.debug("入网电子合同申请未签署完成，当前状态: {}", ecStatus);
respData.put("message", "商户入网电子合同尚未签署，请稍候！");
return respData;
}
// 6. 必要参数校验
if (ecApplyId == null || StrUtil.isBlank(ecNo)) {
log.error("入网电子合同申请回调：ecApplyId 为空");
respData.put("message", "ecApplyId 返回空值！");
log.error("入网电子合同申请回调参数缺失: ecApplyId={}, ecNo={}", ecApplyId, ecNo);
respData.put("message", "回调参数返回空值！");
return respData;
}
// 7. 查询本地电子合同记录
LklLedgerEc lklLedgerEc = lklLedgerEcService.getByApplyId(ecApplyId, "", CommonConstant.Enable);
if (lklLedgerEc == null) {
log.error("入网电子合同申请回调：找不到对应入网lklLedgerEc电子合同记录");
log.error("入网电子合同申请回调找不到对应记录，ecApplyId: {}", ecApplyId);
respData.put("message", "找不到对应入网电子合同记录！");
return respData;
}
// 8. 获取商户ID并校验
Long mchId = lklLedgerEc.getMch_id();
if (ObjectUtil.isEmpty(mchId)) {
log.error("入网电子合同申请回调：找不到商家关联数据");
log.error("入网电子合同申请回调商户ID为空，ecApplyId: {}", ecApplyId);
respData.put("message", "找不到商家关联数据！");
return respData;
}
// if ("COMPLETED".equals(lklLedgerEc.getEc_status())) {
// ShopMchEntry shopMchEntry = shopMchEntryService.shopMerchEntryById(lklLedgerEc.getMch_id());
// if (shopMchEntry != null
// ) {
// log.error("入网电子合同申请回调：找不到对应商户信息");
// respData.put("message", "找不到对应商户信息！");
// return respData;
// }
//
// respData.put("code", "SUCCESS");
// respData.put("message", "操作成功！");
// log.info("商户入网电子合同申请回调：已处理成功，不需再重新处理");
// return respData;
// }
// 9. 查询商户入驻信息
ShopMchEntry shopMchEntry = shopMchEntryService.shopMerchEntryById(mchId);
if (shopMchEntry == null) {
log.error("入网电子合同申请回调找不到商户入驻信息，mchId: {}", mchId);
respData.put("message", "找不到商家入驻关联数据！");
return respData;
}
// 把 base64 合同文件，上传到 cos 服务器，返回 url 地址
try {
// 10. 下载并上传电子合同文件
log.debug("开始处理电子合同文件，ecApplyId: {}", ecApplyId);
Pair<String, String> ecFilePair = ledgerMerEcDownload(ecApplyId);
String ecCosFileUrl = "";
String eclklFilePath = "";
if (ecFilePair != null) {
ecCosFileUrl = ecFilePair.getFirst();
eclklFilePath = ecFilePair.getSecond();
log.debug("电子合同文件处理完成，COS地址: {}, 拉卡拉路径: {}", ecCosFileUrl, eclklFilePath);
} else {
log.warn("电子合同文件下载失败，ecApplyId: {}", ecApplyId);
}
// 更改本地记录状态数据
// 11. 更新本地电子合同记录状态
LklLedgerEc updRecord = new LklLedgerEc();
updRecord.setEc_apply_id(ecApplyId);
updRecord.setEc_no(ecNo);
@ -977,33 +1001,64 @@ public class LakalaApiServiceImpl implements LakalaApiService {
updRecord.setEc_file(ecCosFileUrl); // 合同本地文件COS URL链接
updRecord.setLkl_file_path(eclklFilePath);
updRecord.setEc_status(paramsJSON.getStr("ecStatus"));
// 更新本地数据状态和合同编号、合同名字
Boolean success = lklLedgerEcService.updateByApplyId(updRecord);
if (!success) {
shopMchEntryService.updateMerchEntryApprovalByMchId(mchId, CommonConstant.MCH_APPR_STA_LKL_NOPASS, "更新电子合同失败!");
respData.set("code", "FAIL").set("message", "更新电子合同失败！");
String errorMsg = "更新电子合同记录失败";
log.error("入网电子合同申请回调更新本地记录失败，mchId: {}", mchId);
shopMchEntryService.updateMerchEntryApprovalByMchId(mchId, CommonConstant.MCH_APPR_STA_LKL_NOPASS, errorMsg);
respData.set("code", "FAIL").set("message", errorMsg);
return respData;
}
// 更新商家入驻表的合同编号，和签署地址，更改状态
shopMchEntryService.updateMerchantLklEContractInfo(mchId, ecNo, paramsJSON.getStr("ecName"), lklLedgerEc.getResult_url(), ecCosFileUrl, eclklFilePath);
// 12. 更新商家入驻表的合同信息
shopMchEntryService.updateMerchantLklEContractInfo(
mchId,
ecNo,
paramsJSON.getStr("ecName"),
lklLedgerEc.getResult_url(),
ecCosFileUrl,
eclklFilePath
);
log.debug("商家入驻表电子合同信息更新完成，mchId: {}", mchId);
// 商家电子合同签署完毕后，收到异步通知，触发拉卡拉商家进件（重要环节）
// 13. 触发拉卡拉商家进件流程
log.info("开始触发拉卡拉商家进件流程，mchId: {}", mchId);
Pair<Boolean, String> resultPair = lklTkService.registrationMerchant(mchId);
if (!resultPair.getFirst()) {
errMsg = resultPair.getSecond();
String errMsg = resultPair.getSecond();
log.error("拉卡拉商家进件失败: {}，mchId: {}", errMsg, mchId);
shopMchEntryService.updateMerchEntryApprovalByMchId(mchId, CommonConstant.MCH_APPR_STA_LKL_NOPASS, errMsg);
log.error(errMsg);
throw new ApiException(errMsg);
}
shopMchEntryService.updateMerchEntryApprovalByMchId(mchId, CommonConstant.MCH_APPR_STA_LKL_PADDING, "已提交进件申请，请等待机构审核！");
// 14. 更新商户审批状态
shopMchEntryService.updateMerchEntryApprovalByMchId(
mchId,
CommonConstant.MCH_APPR_STA_LKL_PADDING,
"已提交进件申请，请等待机构审核！"
);
log.debug("商户审批状态更新完成，mchId: {}", mchId);
// 15. 发送推送消息通知商家
JSONObject payload = new JSONObject();
payload.put("category", CommonConstant.PUSH_MSG_CATE_EC);
pushMessageService.noticeMerchantSignEcContract(shopMchEntry.getCreated_by(), payload, true);
log.debug("商家推送消息发送完成，userId: {}", shopMchEntry.getCreated_by());
// 16. 返回成功响应
respData.put("code", "SUCCESS");
respData.put("message", "操作成功！");
log.info("商户入网电子合同申请回调：处理成功");
log.info("商户入网电子合同申请回调处理成功，mchId: {}, ecApplyId: {}", mchId, ecApplyId);
return respData;
} catch (Exception e) {
log.error("商户入网电子合同申请回调处理异常，mchId: {}", mchId, e);
respData.put("message", "系统处理异常: " + e.getMessage());
return respData;
}
}
/**
* 商户入网盖章电子合同下载, 并上传到 cos 服务器
@ -1444,23 +1499,24 @@ public class LakalaApiServiceImpl implements LakalaApiService {
// 1. 参数校验（提前失败）
if (paramsJSON == null) {
log.warn("商家绑定分账接收方申请失败：绑定参数为空");
return Pair.of(false, I18nUtil._("绑定参数为空"));
return Pair.of(false, "绑定参数为空");
}
String merCupNo = paramsJSON.getStr("merCupNo");
if (StrUtil.isBlank(merCupNo)) {
log.warn("商家绑定分账接收方申请失败：商户号（merCupNo）为空");
return Pair.of(false, I18nUtil._("商户号（merCupNo）为空"));
return Pair.of(false, "商户号（merCupNo）为空");
}
log.debug("商家绑定分账接收方申请参数：{}", paramsJSON);
try {
// 2. 基础数据查询（提前失败）
log.debug("开始查询商户入驻信息，商户号: {}", merCupNo);
ShopMchEntry shopMchEntry = shopMchEntryService.getShopMerchEntryByMerCupNo(merCupNo);
if (shopMchEntry == null) {
log.warn("商家绑定分账接收方申请失败：商户入驻记录不存在，商户号: {}", merCupNo);
return Pair.of(false, I18nUtil._("商户入驻记录不存在"));
return Pair.of(false, "商户入驻记录不存在");
}
// 进件记录
@ -1468,7 +1524,13 @@ public class LakalaApiServiceImpl implements LakalaApiService {
LklLedgerMember lklLedgerMember = lklLedgerMemberService.getByMerCupNo(merCupNo);
if (lklLedgerMember == null || !CommonConstant.Enable.equals(lklLedgerMember.getAudit_status())) {
log.warn("商家绑定分账接收方申请失败：商家尚未申请分账业务或审核未通过，商户号: {}", merCupNo);
return Pair.of(false, I18nUtil._("商家尚未申请分账业务"));
return Pair.of(false, "商家尚未申请分账业务");
}
// 检查必要字段
if (StrUtil.isBlank(lklLedgerMember.getMer_inner_no())) {
log.warn("商家绑定分账接收方申请失败：商户内部号mer_inner_no为空，商户号: {}", merCupNo);
lklLedgerMember.setMer_inner_no("");
}
// 分账接收方列表
@ -1476,7 +1538,7 @@ public class LakalaApiServiceImpl implements LakalaApiService {
List<LklLedgerReceiver> receiverList = lklLedgerReceiverService.selectPlatformAnDistributorList();
if (CollectionUtil.isEmpty(receiverList)) {
log.warn("商家绑定分账接收方申请失败：分账接收方信息为空");
return Pair.of(false, I18nUtil._("分账接收方信息为空"));
return Pair.of(false, "分账接收方信息为空");
}
log.info("获取到 {} 个分账接收方，开始处理绑定申请", receiverList.size());
@ -1493,6 +1555,12 @@ public class LakalaApiServiceImpl implements LakalaApiService {
String entrustFileName = "小发同城合作协议书.pdf";
String entrustFilePath = shopMchEntry.getLkl_ec_file_path(); // 拉卡拉的文件路径
// 检查文件路径
if (StrUtil.isBlank(entrustFilePath)) {
log.warn("商家绑定分账接收方申请失败：电子合同文件路径为空，商户号: {}", merCupNo);
return Pair.of(false, "电子合同文件路径为空");
}
int successCount = 0;
int totalCount = receiverList.size();
@ -1506,6 +1574,12 @@ public class LakalaApiServiceImpl implements LakalaApiService {
// 5. 循环处理接收方绑定
for (LklLedgerReceiver receiver : receiverList) {
try {
// 检查接收方编号
if (receiver == null || StrUtil.isBlank(receiver.getReceiver_no())) {
log.warn("接收方信息不完整或接收方编号为空，跳过处理，商户号: {}", merCupNo);
continue;
}
log.debug("开始处理分账接收方绑定，接收方编号: {}", receiver.getReceiver_no());
String receiverNo = receiver.getReceiver_no();
@ -1543,17 +1617,17 @@ public class LakalaApiServiceImpl implements LakalaApiService {
JSONObject respJson = JSONUtil.parseObj(responseStr);
if (respJson == null || !lklSuccessCode.equals(respJson.getStr("retCode"))) {
String errorMsg = respJson != null ? respJson.getStr("retMsg") : "无响应数据";
String errorMsg = respJson != null ? respJson.getStr("retMsg", "未知错误") : "无响应数据";
log.error("绑定接收方拉卡拉响应失败，订单号: {}，错误信息: {}", orderNo, errorMsg);
continue; // 单个失败不影响其他接收方处理
}
String applyId = (String) respJson.getByPath("respData.applyId");
Object applyId = respJson.getByPath("respData.applyId");
log.info("拉卡拉分账接收方绑定申请提交成功，订单号: {}，商户号: {}，接收方: {}，申请ID: {}",
orderNo, merCupNo, receiverNo, applyId);
if (StrUtil.isBlank(applyId)) {
log.error("拉卡拉分账接收方绑定申请提交失败，订单号: {}，订单号: {}，商户号: {}，接收方: {} 申请ID为空", orderNo, merCupNo, receiverNo);
if (ObjectUtil.isEmpty(applyId)) {
log.error("拉卡拉分账接收方绑定申请提交失败，订单号: {}，商户号: {}，接收方: {} 申请ID为空", orderNo, merCupNo, receiverNo);
continue;
}
@ -1564,7 +1638,8 @@ public class LakalaApiServiceImpl implements LakalaApiService {
paramsJSON.set("receiver_no", receiverNo);
paramsJSON.set("ret_url", retUrl);
paramsJSON.set("remark", respJson.getStr("retMsg"));
paramsJSON.set("platform_id", receiver.getPlatform_id());
// 处理可能为null的platform_id
paramsJSON.set("platform_id", receiver.getPlatform_id() != null ? receiver.getPlatform_id().toString() : "");
paramsJSON.set("mch_id", shopMchEntry.getId());
// 转换JSON键名格式并保存
@ -1574,14 +1649,14 @@ public class LakalaApiServiceImpl implements LakalaApiService {
log.debug("准备保存分账绑定记录");
if (lklLedgerMerReceiverBindService.addOrUpdateByMerCupNoReceiverNo(bindRecord)) {
successCount++;
log.info("分账绑定记录保存成功，，订单号: {}，商户号: {}，接收方: {}", orderNo, merCupNo, receiverNo);
log.info("分账绑定记录保存成功，订单号: {}，商户号: {}，接收方: {}", orderNo, merCupNo, receiverNo);
} else {
log.warn("分账绑定记录保存失败，订单号: {}，商户号: {}，接收方: {}",
orderNo, merCupNo, receiverNo);
}
} catch (Exception e) {
log.error("处理分账绑定异常，商户号: {}，接收方: {}", merCupNo, receiver.getReceiver_no(), e);
log.error("处理分账绑定异常，商户号: {}，接收方: {}", merCupNo, receiver != null ? receiver.getReceiver_no() : "未知", e);
// 单个接收方处理失败，继续处理其他接收方
}
}
@ -1605,6 +1680,10 @@ public class LakalaApiServiceImpl implements LakalaApiService {
log.info(message);
return Pair.of(true, message);
}
} catch (Exception e) {
log.error("商家绑定分账接收方申请异常，商户号: {}", merCupNo, e);
return Pair.of(false, "系统处理异常: " + e.getMessage());
}
}
@ -1625,32 +1704,41 @@ public class LakalaApiServiceImpl implements LakalaApiService {
Pair<Boolean, String> checkResult = LakalaUtil.chkLklApiNotifySign(request, lklNotifyCerPath, false);
if (!checkResult.getFirst()) {
log.warn("验签失败: {}", checkResult.getSecond());
return JSONUtil.createObj().set("code", "FAIL").set("retMsg", checkResult.getSecond());
return JSONUtil.createObj().set("code", "FAIL").set("message", checkResult.getSecond());
}
// 2. 解析回调参数
JSONObject paramsJSON = JSONUtil.parseObj(checkResult.getSecond());
log.debug("##### 商家绑定接收方回调参数：{} ####", paramsJSON);
// 检查参数是否包含必要的applyId
if (paramsJSON == null || StrUtil.isBlank(paramsJSON.getStr("applyId"))) {
log.error("商家绑定分账接收方通知数据有误");
// 3. 参数校验
if (paramsJSON == null) {
log.error("商家绑定分账接收方通知数据有误: 参数为空");
return JSONUtil.createObj().set("code", "FAIL").set("message", "商家绑定分账接收方通知数据有误！");
}
// 3. 提取核心参数
String merCupNo = paramsJSON.getStr("merCupNo");
String applyId = paramsJSON.getStr("applyId");
String merCupNo = paramsJSON.getStr("merCupNo");
String auditStatus = paramsJSON.getStr("auditStatus");
if (StrUtil.isBlank(applyId)) {
log.error("商家绑定分账接收方通知数据有误: applyId为空");
return JSONUtil.createObj().set("code", "FAIL").set("message", "商家绑定分账接收方通知数据有误！");
}
// 4. 根据申请ID获取绑定记录
LklLedgerMerReceiverBind lklLedgerMerReceiverBind = lklLedgerMerReceiverBindService.getMerReceiverByApplyId(applyId);
if (lklLedgerMerReceiverBind == null || CheckUtil.isEmpty(lklLedgerMerReceiverBind.getMch_id())) {
if (lklLedgerMerReceiverBind == null) {
log.warn("无法获取到绑定记录，applyId: {}", applyId);
return JSONUtil.createObj().set("code", "FAIL").set("message", "无法获取到绑定记录！");
}
Long mchId = lklLedgerMerReceiverBind.getMch_id();
if (CheckUtil.isEmpty(mchId)) {
log.warn("绑定记录中商户ID为空，applyId: {}", applyId);
return JSONUtil.createObj().set("code", "FAIL").set("message", "绑定记录数据异常！");
}
// 5. 参数校验（防止空值）
if (StrUtil.hasBlank(merCupNo, applyId, auditStatus)) {
String errorMsg = String.format("关键参数缺失：merCupNo=%s, applyId=%s, auditStatus=%s", merCupNo, applyId, auditStatus);
@ -1668,16 +1756,23 @@ public class LakalaApiServiceImpl implements LakalaApiService {
}
// 7. 更新绑定记录的状态信息
String merInnerNo = paramsJSON.getStr("merInnerNo");
String receiverNo = paramsJSON.getStr("receiverNo");
String entrustFileName = paramsJSON.getStr("entrustFileName");
String entrustFilePath = paramsJSON.getStr("entrustFilePath");
String auditStatusText = paramsJSON.getStr("auditStatusText");
String remark = paramsJSON.getStr("remark");
Boolean updateSuccess = lklLedgerMerReceiverBindService.updateAuditResult(
applyId,
paramsJSON.getStr("merInnerNo"),
merInnerNo,
merCupNo,
paramsJSON.getStr("receiverNo"),
paramsJSON.getStr("entrustFileName"),
paramsJSON.getStr("entrustFilePath"),
receiverNo,
entrustFileName,
entrustFilePath,
auditStatus,
paramsJSON.getStr("auditStatusText"),
paramsJSON.getStr("remark")
auditStatusText,
remark
);
if (!Boolean.TRUE.equals(updateSuccess)) {
@ -1685,24 +1780,31 @@ public class LakalaApiServiceImpl implements LakalaApiService {
return JSONUtil.createObj().set("code", "FAIL").set("message", "更新绑定状态失败");
}
Long mchId = lklLedgerMerReceiverBind.getMch_id();
// 8. 成功后更新商户绑定状态为已绑定
shopMchEntryService.updateMulStatus(mchId, merCupNo, 0, 0, 0, 0, 0, 1, CommonConstant.MCH_APPR_STA_PASS);
// 9. 创建店铺，并初始化
try {
// 9. 判断是否可以创建店铺了？
if (shopMchEntryService.canBuildingShopStore(mchId)) {
// 创建店铺，并初始化
// 新建一个正式的已审核通过的店铺，不要抛异常，使用补偿机制，可以独立初始化店铺
// 重要：包含了更改 merchEntryInfo 的状态， 使用法人、小微个人的手机号注册商家账号，作为店铺的管理员
Pair<Integer, String> retPair = shopStoreBaseService.covMerchEntryInfo2StoreInfo(mchId, false);
if (retPair.getFirst() <= 0) {
shopMchEntryService.updateMerchEntryApprovalByMchId(mchId, null, "创建初始化店铺失败：" + retPair.getSecond());
shopMchEntryService.updateMerchEntryApprovalByMchId(mchId, null, "创建并初始化店铺失败：" + retPair.getSecond());
log.error("进件成功，但初始化店铺失败: mchId={}, reason={}", mchId, retPair.getSecond());
} else {
shopMchEntryService.updateMulStatus(mchId, merCupNo, 0, 0, 1, 0, 0, 0, 0);
log.info("进件成功，创建并初始化店铺成功！mchId={}", mchId);
}
}
// 10. 检查商户绑定状态是否完成， 更改总的审核状态
shopMchEntryService.checkMerchEntryFinished(mchId);
} catch (Exception e) {
log.error("处理商户店铺创建或状态检查时发生异常，mchId: {}", mchId, e);
// 不中断主流程，继续返回成功
}
// 11. 日志记录并返回成功响应
log.info("商家绑定分账接收方异步通知处理完成，mchId:{} merCupNo：{}", mchId, merCupNo);

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);
/**
* 检查更新商户入驻店铺初始化状态
*

50
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("申请人手机号码有误！");
@ -1042,7 +1041,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 +1066,6 @@ public class ShopMchEntryServiceImpl extends BaseServiceImpl<ShopMchEntryMapper,
return Pair.of(false, msg);
}
log.info("可以申请入驻，准备申请入驻");
return Pair.of(true, "可以申请入驻，准备下一个流程");
@ -1738,6 +1736,7 @@ public class ShopMchEntryServiceImpl extends BaseServiceImpl<ShopMchEntryMapper,
log.error("更新商户入驻信息状态失败, mchId={}", mchId);
return false;
}
return true; // 返回 true，表示入驻流程已全部完成
} catch (Exception e) {
@ -1747,6 +1746,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;
}
}
/**
* 根据商户号或商家手机号修改商户入驻信息多个状态

510
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,145 @@ 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())
&& shopMchEntry.getStore_id() != null // 添加null检查
&& !shopStoreBase.getStore_id().toString().equals(shopMchEntry.getStore_id())) {
// 如果店铺名称已存在，且店铺已经进件，且不等于当前入驻商家的店铺Id，提示店铺名称已存在
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 (storeId == null) {
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 +3297,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 +3366,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 +3394,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 +3408,294 @@ public class ShopStoreBaseServiceImpl extends BaseServiceImpl<ShopStoreBaseMappe
}
}
// 注意：关联店铺到用户，给用户增加店铺管理员权限
// 初始化店铺额外信息
initStoreExtraInfo(userId, storeId, allowThrown);
// 更改店铺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_data(""); //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_data(""); //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_data(""); //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_data(""); //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_data(""); //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_data(""); //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_data(""); //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_data(""); //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_data(""); //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_data(""); //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_data(""); //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(
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-商家拒绝退货
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_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 +3708,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 +4098,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 +4113,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 +4134,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 "";
}