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) .map(ConstraintViolation::getMessage)
.collect(Collectors.joining("; ")); .collect(Collectors.joining("; "));
logError(req, "约束违反异常", e); logError(req, "数据库约束违反异常", e);
return CommonResult.validateFailed("系统数据异常，请联系管理员！"); 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 @Slf4j
public class CheckUtil { 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 * 校验数据 不为null和0
* *
* @param param * @param param 待校验的Integer值
* @return * @return boolean 不为null且不为0返回true，否则返回false
*/ */
public static boolean isNotEmpty(Integer param) { public static boolean isNotEmpty(Integer param) {
return param != null && param != 0; return param != null && param != 0;
} }
/**
* 校验数据 不为null和0
*
* @param param 待校验的Long值
* @return boolean 不为null且不为0返回true，否则返回false
*/
public static boolean isNotEmpty(Long param) { 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) { 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) { 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) { 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) { 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) { 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 * @param mchId 商户ID
* @return * @return Pair<Boolean, String> 申请结果，第一个元素表示是否成功，第二个元素为结果信息
*/ */
@Override @Override
public Pair<Boolean, String> applyLedgerMerEc(Long mchId) { public Pair<Boolean, String> applyLedgerMerEc(Long mchId) {
log.debug("商家开始申请入网电子合同"); log.debug("商家开始申请入网电子合同，入驻编号: {}", mchId);
if (ObjectUtil.isEmpty(mchId)) {
return Pair.of(false, I18nUtil._("缺少商家必要参数！")); // 1. 参数校验
if (CheckUtil.isEmpty(mchId)) {
log.warn("商家申请入网电子合同失败：缺少商家必要参数，入驻编号: {}", mchId);
return Pair.of(false, "缺少商家入驻编号！");
} }
// 获取商家信息 // 2. 获取商家信息
ShopMchEntry shopMchEntry = shopMchEntryService.shopMerchEntryById(mchId); ShopMchEntry shopMchEntry = shopMchEntryService.shopMerchEntryById(mchId);
if (shopMchEntry == null) { if (ObjectUtil.isEmpty(shopMchEntry)) {
return Pair.of(false, I18nUtil._("缺少商家相关信息！")); log.warn("商家申请入网电子合同失败：缺少商家相关入驻信息，入驻编号: {}", mchId);
return Pair.of(false, "缺少商家相关入驻信息！");
} }
String contractMobile = shopMchEntry.getLegal_person_mobile(); 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); LklLedgerEc lklLedgerEc = lklLedgerEcService.getByMchId(shopMchEntry.getId(), "", CommonConstant.Enable);
if (lklLedgerEc != null if (lklLedgerEc != null && "COMPLETED".equals(lklLedgerEc.getEc_status())) {
&& "COMPLETED".equals(lklLedgerEc.getEc_status())) {
// TODO 电子合同已签署完成（但有一些错误的信息），这种情况，需要怎么处理？
// 办法：重新再签署合同，更新拉卡拉的电子合同信息到商家入驻表中
log.info("商户:{} 电子合同已签署过，重新提交将被覆盖！", mchId); log.info("商户:{} 电子合同已签署过，重新提交将被覆盖！", mchId);
} }
// 是企业类型商家 // 4. 判断商家类型（企业或个人）
Boolean isQy = CommonConstant.MCH_ENTITY_TYPE_QY.equals(shopMchEntry.getEntity_type()); Boolean isQy = CommonConstant.MCH_ENTITY_TYPE_QY.equals(shopMchEntry.getEntity_type());
log.debug("商家类型：{}，isQy: {}", isQy ? "企业" : "个人", isQy);
// 5. 装配请求数据
JSONObject reqData = new JSONObject(); JSONObject reqData = new JSONObject();
reqData.put("order_no", StringUtils.genLklOrderNo(8)); reqData.put("order_no", StringUtils.genLklOrderNo(8));
reqData.put("org_id", orgCode); reqData.put("org_id", orgCode);
@ -430,7 +437,7 @@ public class LakalaApiServiceImpl implements LakalaApiService {
reqData.put("acct_name", shopMchEntry.getAccount_holder_name()); reqData.put("acct_name", shopMchEntry.getAccount_holder_name());
reqData.put("remark", "申请入网电子合同"); reqData.put("remark", "申请入网电子合同");
// 正式上线的时候，调整 api 地址 // 6. 构建回调地址
String domain = projectDomain; String domain = projectDomain;
if (isProdProject()) { if (isProdProject()) {
domain += "/api"; domain += "/api";
@ -440,11 +447,11 @@ public class LakalaApiServiceImpl implements LakalaApiService {
String retUrl = domain + "/mobile/shop/lakala/ec/applyNotify"; String retUrl = domain + "/mobile/shop/lakala/ec/applyNotify";
reqData.put("ret_url", retUrl); reqData.put("ret_url", retUrl);
// 7. 构建合同参数
LocalDate today = LocalDate.now(); LocalDate today = LocalDate.now();
String signDate = DateTimeUtils.formatLocalDate(today, "yyyy-MM-dd"); String signDate = DateTimeUtils.formatLocalDate(today, "yyyy-MM-dd");
String platformName = "桂平发发网络有限公司"; String platformName = "桂平发发网络有限公司";
JSONObject ecParams = new JSONObject(); JSONObject ecParams = new JSONObject();
ecParams.put("A1", isQy ? shopMchEntry.getBiz_license_company() : shopMchEntry.getAccount_holder_name()); ecParams.put("A1", isQy ? shopMchEntry.getBiz_license_company() : shopMchEntry.getAccount_holder_name());
ecParams.put("A30", wxFee); // 测试环境微信费率0.6 ecParams.put("A30", wxFee); // 测试环境微信费率0.6
@ -507,6 +514,7 @@ public class LakalaApiServiceImpl implements LakalaApiService {
// 注：该字段是json字符串，不是json对象 // 注：该字段是json字符串，不是json对象
reqData.put("ec_content_parameters", ecParams.toString()); reqData.put("ec_content_parameters", ecParams.toString());
// 8. 构建请求体
JSONObject reqBody = new JSONObject(); JSONObject reqBody = new JSONObject();
reqBody.put("req_time", DateTimeUtils.formatDateTime(LocalDateTime.now(), "yyyyMMddHHmmss")); reqBody.put("req_time", DateTimeUtils.formatDateTime(LocalDateTime.now(), "yyyyMMddHHmmss"));
reqBody.put("version", "3.0"); reqBody.put("version", "3.0");
@ -521,25 +529,27 @@ public class LakalaApiServiceImpl implements LakalaApiService {
log.debug("申请入网电子合同请求参数：{}", JsonUtil.toJSONString(reqBody)); log.debug("申请入网电子合同请求参数：{}", JsonUtil.toJSONString(reqBody));
// 9. 发送请求
String errMsg = ""; String errMsg = "";
JSONObject response = RestTemplateHttpUtil.sendLklPost(reqUrl, header, reqBody, JSONObject.class); JSONObject response = RestTemplateHttpUtil.sendLklPost(reqUrl, header, reqBody, JSONObject.class);
log.debug("拉卡拉申请入网电子合同响应参数：{}", JsonUtil.toJSONString(response)); log.debug("拉卡拉申请入网电子合同响应参数：{}", JsonUtil.toJSONString(response));
if (ObjectUtil.isEmpty(response) || !lklSuccessCode.equals(response.getStr("retCode"))) { if (ObjectUtil.isEmpty(response) || !lklSuccessCode.equals(response.getStr("retCode"))) {
errMsg = "拉卡拉申请入网电子合同，" + response.getStr("retMsg"); errMsg = "拉卡拉申请入网电子合同，" + response.getStr("retMsg");
log.warn("拉卡拉申请入网电子合同失败：{}，商户ID: {}", errMsg, mchId);
shopMchEntryService.updateMerchEntryApprovalByMchId(shopMchEntry.getId(), CommonConstant.MCH_APPR_STA_LKL_NOPASS, errMsg); shopMchEntryService.updateMerchEntryApprovalByMchId(shopMchEntry.getId(), CommonConstant.MCH_APPR_STA_LKL_NOPASS, errMsg);
return Pair.of(false, errMsg); return Pair.of(false, errMsg);
} }
JSONObject respData = response.getJSONObject("respData"); JSONObject respData = response.getJSONObject("respData");
if (respData == null) { if (respData == null) {
errMsg = "拉卡拉申请入网电子合同，" + response.getStr("retMsg"); errMsg = "拉卡拉申请入网电子合同，响应数据为空";
log.warn("拉卡拉申请入网电子合同失败：{}，入驻编号: {}", errMsg, mchId);
shopMchEntryService.updateMerchEntryApprovalByMchId(shopMchEntry.getId(), CommonConstant.MCH_APPR_STA_LKL_NOPASS, errMsg); shopMchEntryService.updateMerchEntryApprovalByMchId(shopMchEntry.getId(), CommonConstant.MCH_APPR_STA_LKL_NOPASS, errMsg);
return Pair.of(false, errMsg); return Pair.of(false, errMsg);
} }
// 商家入网申请电子合同处理数据 // 10. 处理响应数据并保存到本地数据库
// 先写入本地数据库表中
LklLedgerEc record = new LklLedgerEc(); LklLedgerEc record = new LklLedgerEc();
record.setMch_id(mchId); record.setMch_id(mchId);
record.setMch_mobile(contractMobile); record.setMch_mobile(contractMobile);
@ -550,32 +560,31 @@ public class LakalaApiServiceImpl implements LakalaApiService {
String ecResultUrl = respData.getStr("result_url"); String ecResultUrl = respData.getStr("result_url");
record.setResult_url(ecResultUrl); record.setResult_url(ecResultUrl);
record.setResp_body(response.toString()); record.setResp_body(response.toString());
Boolean success = lklLedgerEcService.addOrUpdateByMchId(record); Boolean success = lklLedgerEcService.addOrUpdateByMchId(record);
if (!success) { if (!success) {
errMsg = "申请入网电子合同失败，数据保存失败"; 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); return Pair.of(false, errMsg);
} }
// 更新拉卡拉的电子合同信息到商家入驻表中 // 11. 更新拉卡拉的电子合同信息到商家入驻表中
shopMchEntryService.updateMerchEntryEcResultUrlByMchId(mchId, ecResultUrl); shopMchEntryService.updateMerchEntryEcResultUrlByMchId(mchId, ecResultUrl);
// 发短信给商家，及时签署合同 SMS_488465246 // 12. 发送短信通知商家及时签署合同
//
//恭喜您的开店入驻申请已审核通过！请尽快登录小发商家版APP平台签署电子合同，签署链接24小时内有效（逾期需重新提交申请）。如有疑问请联系客服，感谢您的支持！
// shopMessageTemplateService.aliyunSmsSend(contractMobile, "SMS_493160417", null);//SMS_479760276
// 恭喜！您的开店入驻申请已审核通过，点击链接 https://mall.gpxscs.cn/api/mobile/shop/lakala/sign/ec/${code}
// 或前往小发商家版APP完成电子合同签署，链接24小时内有效（逾期需重新提交申请）。如有疑问可联系客服，感谢您的支持！
shopMessageTemplateService.aliyunSmsSend(contractMobile, "SMS_494860064", null); shopMessageTemplateService.aliyunSmsSend(contractMobile, "SMS_494860064", null);
// 13. 发送推送消息通知商家签署电子合同
JSONObject payload = new JSONObject(); JSONObject payload = new JSONObject();
payload.put("category", CommonConstant.PUSH_MSG_CATE_EC); 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, "商家入网申请电子合同成功"); return Pair.of(true, "商家入网申请电子合同成功");
} }
/** /**
* 商户分账业务开通申请 * 商户分账业务开通申请
* *
@ -618,6 +627,10 @@ public class LakalaApiServiceImpl implements LakalaApiService {
if (!Boolean.TRUE.equals(forceReApply)) { if (!Boolean.TRUE.equals(forceReApply)) {
log.info("商户{}已申请过分账业务，无需重复申请", merCupNo); log.info("商户{}已申请过分账业务，无需重复申请", merCupNo);
// 检查绑定关系
return Pair.of(true, I18nUtil._("商家已经申请过了！")); return Pair.of(true, I18nUtil._("商家已经申请过了！"));
} }
} }
@ -893,83 +906,94 @@ public class LakalaApiServiceImpl implements LakalaApiService {
/** /**
* 商户入网电子合同申请回调通知 * 商户入网电子合同申请回调通知
* <p>
* 处理拉卡拉商户入网电子合同签署完成后的回调通知，更新合同状态并触发后续进件流程。
* 参考：https://o.lakala.com/#/home/document/detail?id=289 * 参考：https://o.lakala.com/#/home/document/detail?id=289
* *
* @param request * @param request HTTP请求对象，包含拉卡拉回调通知的参数
* @return * @return JSONObject 响应结果对象
*/ */
@Override @Override
public JSONObject applyLedgerMerEcNotify(HttpServletRequest request) { public JSONObject applyLedgerMerEcNotify(HttpServletRequest request) {
log.debug("商户入网电子合同申请回调通知开始"); log.debug("商户入网电子合同申请回调通知开始处理");
// 验签
// 1. 验签处理
Pair<Boolean, String> checkResult = LakalaUtil.chkLklApiNotifySign(request, lklNotifyCerPath, false); Pair<Boolean, String> checkResult = LakalaUtil.chkLklApiNotifySign(request, lklNotifyCerPath, false);
if (!checkResult.getFirst()) { if (!checkResult.getFirst()) {
log.warn("商户入网电子合同申请回调验签失败: {}", checkResult.getSecond());
return JSONUtil.createObj().set("code", "FAIL").set("retMsg", checkResult.getSecond()); return JSONUtil.createObj().set("code", "FAIL").set("retMsg", checkResult.getSecond());
} }
String errMsg = "入网电子合同申请回调:"; // 2. 初始化响应对象
JSONObject respData = new JSONObject(); JSONObject respData = new JSONObject();
respData.set("code", "FAIL").set("message", "返回数据转换异常！"); respData.set("code", "FAIL").set("message", "返回数据转换异常！");
// 3. 解析回调参数
JSONObject paramsJSON = JSONUtil.parseObj(checkResult.getSecond()); JSONObject paramsJSON = JSONUtil.parseObj(checkResult.getSecond());
if (paramsJSON == null) { if (paramsJSON == null) {
log.warn("商户入网电子合同申请回调参数解析失败");
return respData; return respData;
} }
// 4. 提取关键参数
Long ecApplyId = paramsJSON.getLong("ecApplyId"); Long ecApplyId = paramsJSON.getLong("ecApplyId");
String ecNo = paramsJSON.getStr("ecNo"); String ecNo = paramsJSON.getStr("ecNo");
String ecStatus = paramsJSON.getStr("ecStatus"); // COMPLETED String ecStatus = paramsJSON.getStr("ecStatus"); // COMPLETED
// 5. 合同状态校验
if (ecStatus == null || !ecStatus.equals("COMPLETED")) { if (ecStatus == null || !ecStatus.equals("COMPLETED")) {
log.debug("入网电子合同申请未签署完成！"); log.debug("入网电子合同申请未签署完成，当前状态: {}", ecStatus);
respData.put("message", "商户入网电子合同尚未签署，请稍候！"); respData.put("message", "商户入网电子合同尚未签署，请稍候！");
return respData; return respData;
} }
// 6. 必要参数校验
if (ecApplyId == null || StrUtil.isBlank(ecNo)) { if (ecApplyId == null || StrUtil.isBlank(ecNo)) {
log.error("入网电子合同申请回调：ecApplyId 为空"); log.error("入网电子合同申请回调参数缺失: ecApplyId={}, ecNo={}", ecApplyId, ecNo);
respData.put("message", "ecApplyId 返回空值！"); respData.put("message", "回调参数返回空值！");
return respData; return respData;
} }
// 7. 查询本地电子合同记录
LklLedgerEc lklLedgerEc = lklLedgerEcService.getByApplyId(ecApplyId, "", CommonConstant.Enable); LklLedgerEc lklLedgerEc = lklLedgerEcService.getByApplyId(ecApplyId, "", CommonConstant.Enable);
if (lklLedgerEc == null) { if (lklLedgerEc == null) {
log.error("入网电子合同申请回调：找不到对应入网lklLedgerEc电子合同记录"); log.error("入网电子合同申请回调找不到对应记录，ecApplyId: {}", ecApplyId);
respData.put("message", "找不到对应入网电子合同记录！"); respData.put("message", "找不到对应入网电子合同记录！");
return respData; return respData;
} }
// 8. 获取商户ID并校验
Long mchId = lklLedgerEc.getMch_id(); Long mchId = lklLedgerEc.getMch_id();
if (ObjectUtil.isEmpty(mchId)) { if (ObjectUtil.isEmpty(mchId)) {
log.error("入网电子合同申请回调：找不到商家关联数据"); log.error("入网电子合同申请回调商户ID为空，ecApplyId: {}", ecApplyId);
respData.put("message", "找不到商家关联数据！"); respData.put("message", "找不到商家关联数据！");
return respData; return respData;
} }
// if ("COMPLETED".equals(lklLedgerEc.getEc_status())) { // 9. 查询商户入驻信息
// ShopMchEntry shopMchEntry = shopMchEntryService.shopMerchEntryById(lklLedgerEc.getMch_id()); ShopMchEntry shopMchEntry = shopMchEntryService.shopMerchEntryById(mchId);
// if (shopMchEntry != null if (shopMchEntry == null) {
// ) { log.error("入网电子合同申请回调找不到商户入驻信息，mchId: {}", mchId);
// log.error("入网电子合同申请回调：找不到对应商户信息"); respData.put("message", "找不到商家入驻关联数据！");
// respData.put("message", "找不到对应商户信息！"); return respData;
// return respData; }
// }
//
// respData.put("code", "SUCCESS");
// respData.put("message", "操作成功！");
// log.info("商户入网电子合同申请回调：已处理成功，不需再重新处理");
// return respData;
// }
// 把 base64 合同文件，上传到 cos 服务器，返回 url 地址 try {
// 10. 下载并上传电子合同文件
log.debug("开始处理电子合同文件，ecApplyId: {}", ecApplyId);
Pair<String, String> ecFilePair = ledgerMerEcDownload(ecApplyId); Pair<String, String> ecFilePair = ledgerMerEcDownload(ecApplyId);
String ecCosFileUrl = ""; String ecCosFileUrl = "";
String eclklFilePath = ""; String eclklFilePath = "";
if (ecFilePair != null) { if (ecFilePair != null) {
ecCosFileUrl = ecFilePair.getFirst(); ecCosFileUrl = ecFilePair.getFirst();
eclklFilePath = ecFilePair.getSecond(); eclklFilePath = ecFilePair.getSecond();
log.debug("电子合同文件处理完成，COS地址: {}, 拉卡拉路径: {}", ecCosFileUrl, eclklFilePath);
} else {
log.warn("电子合同文件下载失败，ecApplyId: {}", ecApplyId);
} }
// 更改本地记录状态数据 // 11. 更新本地电子合同记录状态
LklLedgerEc updRecord = new LklLedgerEc(); LklLedgerEc updRecord = new LklLedgerEc();
updRecord.setEc_apply_id(ecApplyId); updRecord.setEc_apply_id(ecApplyId);
updRecord.setEc_no(ecNo); updRecord.setEc_no(ecNo);
@ -977,33 +1001,64 @@ public class LakalaApiServiceImpl implements LakalaApiService {
updRecord.setEc_file(ecCosFileUrl); // 合同本地文件COS URL链接 updRecord.setEc_file(ecCosFileUrl); // 合同本地文件COS URL链接
updRecord.setLkl_file_path(eclklFilePath); updRecord.setLkl_file_path(eclklFilePath);
updRecord.setEc_status(paramsJSON.getStr("ecStatus")); updRecord.setEc_status(paramsJSON.getStr("ecStatus"));
// 更新本地数据状态和合同编号、合同名字
Boolean success = lklLedgerEcService.updateByApplyId(updRecord); Boolean success = lklLedgerEcService.updateByApplyId(updRecord);
if (!success) { if (!success) {
shopMchEntryService.updateMerchEntryApprovalByMchId(mchId, CommonConstant.MCH_APPR_STA_LKL_NOPASS, "更新电子合同失败!"); String errorMsg = "更新电子合同记录失败";
respData.set("code", "FAIL").set("message", "更新电子合同失败！"); log.error("入网电子合同申请回调更新本地记录失败，mchId: {}", mchId);
shopMchEntryService.updateMerchEntryApprovalByMchId(mchId, CommonConstant.MCH_APPR_STA_LKL_NOPASS, errorMsg);
respData.set("code", "FAIL").set("message", errorMsg);
return respData; return respData;
} }
// 更新商家入驻表的合同编号，和签署地址，更改状态 // 12. 更新商家入驻表的合同信息
shopMchEntryService.updateMerchantLklEContractInfo(mchId, ecNo, paramsJSON.getStr("ecName"), lklLedgerEc.getResult_url(), ecCosFileUrl, eclklFilePath); 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); Pair<Boolean, String> resultPair = lklTkService.registrationMerchant(mchId);
if (!resultPair.getFirst()) { 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); shopMchEntryService.updateMerchEntryApprovalByMchId(mchId, CommonConstant.MCH_APPR_STA_LKL_NOPASS, errMsg);
log.error(errMsg);
throw new ApiException(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("code", "SUCCESS");
respData.put("message", "操作成功！"); 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; return respData;
} }
}
/** /**
* 商户入网盖章电子合同下载, 并上传到 cos 服务器 * 商户入网盖章电子合同下载, 并上传到 cos 服务器
@ -1444,23 +1499,24 @@ public class LakalaApiServiceImpl implements LakalaApiService {
// 1. 参数校验（提前失败） // 1. 参数校验（提前失败）
if (paramsJSON == null) { if (paramsJSON == null) {
log.warn("商家绑定分账接收方申请失败：绑定参数为空"); log.warn("商家绑定分账接收方申请失败：绑定参数为空");
return Pair.of(false, I18nUtil._("绑定参数为空")); return Pair.of(false, "绑定参数为空");
} }
String merCupNo = paramsJSON.getStr("merCupNo"); String merCupNo = paramsJSON.getStr("merCupNo");
if (StrUtil.isBlank(merCupNo)) { if (StrUtil.isBlank(merCupNo)) {
log.warn("商家绑定分账接收方申请失败：商户号（merCupNo）为空"); log.warn("商家绑定分账接收方申请失败：商户号（merCupNo）为空");
return Pair.of(false, I18nUtil._("商户号（merCupNo）为空")); return Pair.of(false, "商户号（merCupNo）为空");
} }
log.debug("商家绑定分账接收方申请参数：{}", paramsJSON); log.debug("商家绑定分账接收方申请参数：{}", paramsJSON);
try {
// 2. 基础数据查询（提前失败） // 2. 基础数据查询（提前失败）
log.debug("开始查询商户入驻信息，商户号: {}", merCupNo); log.debug("开始查询商户入驻信息，商户号: {}", merCupNo);
ShopMchEntry shopMchEntry = shopMchEntryService.getShopMerchEntryByMerCupNo(merCupNo); ShopMchEntry shopMchEntry = shopMchEntryService.getShopMerchEntryByMerCupNo(merCupNo);
if (shopMchEntry == null) { if (shopMchEntry == null) {
log.warn("商家绑定分账接收方申请失败：商户入驻记录不存在，商户号: {}", merCupNo); 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); LklLedgerMember lklLedgerMember = lklLedgerMemberService.getByMerCupNo(merCupNo);
if (lklLedgerMember == null || !CommonConstant.Enable.equals(lklLedgerMember.getAudit_status())) { if (lklLedgerMember == null || !CommonConstant.Enable.equals(lklLedgerMember.getAudit_status())) {
log.warn("商家绑定分账接收方申请失败：商家尚未申请分账业务或审核未通过，商户号: {}", merCupNo); 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(); List<LklLedgerReceiver> receiverList = lklLedgerReceiverService.selectPlatformAnDistributorList();
if (CollectionUtil.isEmpty(receiverList)) { if (CollectionUtil.isEmpty(receiverList)) {
log.warn("商家绑定分账接收方申请失败：分账接收方信息为空"); log.warn("商家绑定分账接收方申请失败：分账接收方信息为空");
return Pair.of(false, I18nUtil._("分账接收方信息为空")); return Pair.of(false, "分账接收方信息为空");
} }
log.info("获取到 {} 个分账接收方，开始处理绑定申请", receiverList.size()); log.info("获取到 {} 个分账接收方，开始处理绑定申请", receiverList.size());
@ -1493,6 +1555,12 @@ public class LakalaApiServiceImpl implements LakalaApiService {
String entrustFileName = "小发同城合作协议书.pdf"; String entrustFileName = "小发同城合作协议书.pdf";
String entrustFilePath = shopMchEntry.getLkl_ec_file_path(); // 拉卡拉的文件路径 String entrustFilePath = shopMchEntry.getLkl_ec_file_path(); // 拉卡拉的文件路径
// 检查文件路径
if (StrUtil.isBlank(entrustFilePath)) {
log.warn("商家绑定分账接收方申请失败：电子合同文件路径为空，商户号: {}", merCupNo);
return Pair.of(false, "电子合同文件路径为空");
}
int successCount = 0; int successCount = 0;
int totalCount = receiverList.size(); int totalCount = receiverList.size();
@ -1506,6 +1574,12 @@ public class LakalaApiServiceImpl implements LakalaApiService {
// 5. 循环处理接收方绑定 // 5. 循环处理接收方绑定
for (LklLedgerReceiver receiver : receiverList) { for (LklLedgerReceiver receiver : receiverList) {
try { try {
// 检查接收方编号
if (receiver == null || StrUtil.isBlank(receiver.getReceiver_no())) {
log.warn("接收方信息不完整或接收方编号为空，跳过处理，商户号: {}", merCupNo);
continue;
}
log.debug("开始处理分账接收方绑定，接收方编号: {}", receiver.getReceiver_no()); log.debug("开始处理分账接收方绑定，接收方编号: {}", receiver.getReceiver_no());
String receiverNo = receiver.getReceiver_no(); String receiverNo = receiver.getReceiver_no();
@ -1543,17 +1617,17 @@ public class LakalaApiServiceImpl implements LakalaApiService {
JSONObject respJson = JSONUtil.parseObj(responseStr); JSONObject respJson = JSONUtil.parseObj(responseStr);
if (respJson == null || !lklSuccessCode.equals(respJson.getStr("retCode"))) { 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); log.error("绑定接收方拉卡拉响应失败，订单号: {}，错误信息: {}", orderNo, errorMsg);
continue; // 单个失败不影响其他接收方处理 continue; // 单个失败不影响其他接收方处理
} }
String applyId = (String) respJson.getByPath("respData.applyId"); Object applyId = respJson.getByPath("respData.applyId");
log.info("拉卡拉分账接收方绑定申请提交成功，订单号: {}，商户号: {}，接收方: {}，申请ID: {}", log.info("拉卡拉分账接收方绑定申请提交成功，订单号: {}，商户号: {}，接收方: {}，申请ID: {}",
orderNo, merCupNo, receiverNo, applyId); orderNo, merCupNo, receiverNo, applyId);
if (StrUtil.isBlank(applyId)) { if (ObjectUtil.isEmpty(applyId)) {
log.error("拉卡拉分账接收方绑定申请提交失败，订单号: {}，订单号: {}，商户号: {}，接收方: {} 申请ID为空", orderNo, merCupNo, receiverNo); log.error("拉卡拉分账接收方绑定申请提交失败，订单号: {}，商户号: {}，接收方: {} 申请ID为空", orderNo, merCupNo, receiverNo);
continue; continue;
} }
@ -1564,7 +1638,8 @@ public class LakalaApiServiceImpl implements LakalaApiService {
paramsJSON.set("receiver_no", receiverNo); paramsJSON.set("receiver_no", receiverNo);
paramsJSON.set("ret_url", retUrl); paramsJSON.set("ret_url", retUrl);
paramsJSON.set("remark", respJson.getStr("retMsg")); 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()); paramsJSON.set("mch_id", shopMchEntry.getId());
// 转换JSON键名格式并保存 // 转换JSON键名格式并保存
@ -1574,14 +1649,14 @@ public class LakalaApiServiceImpl implements LakalaApiService {
log.debug("准备保存分账绑定记录"); log.debug("准备保存分账绑定记录");
if (lklLedgerMerReceiverBindService.addOrUpdateByMerCupNoReceiverNo(bindRecord)) { if (lklLedgerMerReceiverBindService.addOrUpdateByMerCupNoReceiverNo(bindRecord)) {
successCount++; successCount++;
log.info("分账绑定记录保存成功，，订单号: {}，商户号: {}，接收方: {}", orderNo, merCupNo, receiverNo); log.info("分账绑定记录保存成功，订单号: {}，商户号: {}，接收方: {}", orderNo, merCupNo, receiverNo);
} else { } else {
log.warn("分账绑定记录保存失败，订单号: {}，商户号: {}，接收方: {}", log.warn("分账绑定记录保存失败，订单号: {}，商户号: {}，接收方: {}",
orderNo, merCupNo, receiverNo); orderNo, merCupNo, receiverNo);
} }
} catch (Exception e) { } 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); log.info(message);
return Pair.of(true, 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); Pair<Boolean, String> checkResult = LakalaUtil.chkLklApiNotifySign(request, lklNotifyCerPath, false);
if (!checkResult.getFirst()) { if (!checkResult.getFirst()) {
log.warn("验签失败: {}", checkResult.getSecond()); 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. 解析回调参数 // 2. 解析回调参数
JSONObject paramsJSON = JSONUtil.parseObj(checkResult.getSecond()); JSONObject paramsJSON = JSONUtil.parseObj(checkResult.getSecond());
log.debug("##### 商家绑定接收方回调参数：{} ####", paramsJSON); log.debug("##### 商家绑定接收方回调参数：{} ####", paramsJSON);
// 检查参数是否包含必要的applyId // 3. 参数校验
if (paramsJSON == null || StrUtil.isBlank(paramsJSON.getStr("applyId"))) { if (paramsJSON == null) {
log.error("商家绑定分账接收方通知数据有误"); log.error("商家绑定分账接收方通知数据有误: 参数为空");
return JSONUtil.createObj().set("code", "FAIL").set("message", "商家绑定分账接收方通知数据有误！"); return JSONUtil.createObj().set("code", "FAIL").set("message", "商家绑定分账接收方通知数据有误！");
} }
// 3. 提取核心参数
String merCupNo = paramsJSON.getStr("merCupNo");
String applyId = paramsJSON.getStr("applyId"); String applyId = paramsJSON.getStr("applyId");
String merCupNo = paramsJSON.getStr("merCupNo");
String auditStatus = paramsJSON.getStr("auditStatus"); String auditStatus = paramsJSON.getStr("auditStatus");
if (StrUtil.isBlank(applyId)) {
log.error("商家绑定分账接收方通知数据有误: applyId为空");
return JSONUtil.createObj().set("code", "FAIL").set("message", "商家绑定分账接收方通知数据有误！");
}
// 4. 根据申请ID获取绑定记录 // 4. 根据申请ID获取绑定记录
LklLedgerMerReceiverBind lklLedgerMerReceiverBind = lklLedgerMerReceiverBindService.getMerReceiverByApplyId(applyId); LklLedgerMerReceiverBind lklLedgerMerReceiverBind = lklLedgerMerReceiverBindService.getMerReceiverByApplyId(applyId);
if (lklLedgerMerReceiverBind == null || CheckUtil.isEmpty(lklLedgerMerReceiverBind.getMch_id())) { if (lklLedgerMerReceiverBind == null) {
log.warn("无法获取到绑定记录，applyId: {}", applyId); log.warn("无法获取到绑定记录，applyId: {}", applyId);
return JSONUtil.createObj().set("code", "FAIL").set("message", "无法获取到绑定记录！"); 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. 参数校验（防止空值） // 5. 参数校验（防止空值）
if (StrUtil.hasBlank(merCupNo, applyId, auditStatus)) { if (StrUtil.hasBlank(merCupNo, applyId, auditStatus)) {
String errorMsg = String.format("关键参数缺失：merCupNo=%s, applyId=%s, auditStatus=%s", 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. 更新绑定记录的状态信息 // 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( Boolean updateSuccess = lklLedgerMerReceiverBindService.updateAuditResult(
applyId, applyId,
paramsJSON.getStr("merInnerNo"), merInnerNo,
merCupNo, merCupNo,
paramsJSON.getStr("receiverNo"), receiverNo,
paramsJSON.getStr("entrustFileName"), entrustFileName,
paramsJSON.getStr("entrustFilePath"), entrustFilePath,
auditStatus, auditStatus,
paramsJSON.getStr("auditStatusText"), auditStatusText,
paramsJSON.getStr("remark") remark
); );
if (!Boolean.TRUE.equals(updateSuccess)) { if (!Boolean.TRUE.equals(updateSuccess)) {
@ -1685,24 +1780,31 @@ public class LakalaApiServiceImpl implements LakalaApiService {
return JSONUtil.createObj().set("code", "FAIL").set("message", "更新绑定状态失败"); return JSONUtil.createObj().set("code", "FAIL").set("message", "更新绑定状态失败");
} }
Long mchId = lklLedgerMerReceiverBind.getMch_id();
// 8. 成功后更新商户绑定状态为已绑定 // 8. 成功后更新商户绑定状态为已绑定
shopMchEntryService.updateMulStatus(mchId, merCupNo, 0, 0, 0, 0, 0, 1, CommonConstant.MCH_APPR_STA_PASS); shopMchEntryService.updateMulStatus(mchId, merCupNo, 0, 0, 0, 0, 0, 1, CommonConstant.MCH_APPR_STA_PASS);
// 9. 创建店铺，并初始化 try {
// 9. 判断是否可以创建店铺了？
if (shopMchEntryService.canBuildingShopStore(mchId)) {
// 创建店铺，并初始化
// 新建一个正式的已审核通过的店铺，不要抛异常，使用补偿机制，可以独立初始化店铺 // 新建一个正式的已审核通过的店铺，不要抛异常，使用补偿机制，可以独立初始化店铺
// 重要：包含了更改 merchEntryInfo 的状态， 使用法人、小微个人的手机号注册商家账号，作为店铺的管理员 // 重要：包含了更改 merchEntryInfo 的状态， 使用法人、小微个人的手机号注册商家账号，作为店铺的管理员
Pair<Integer, String> retPair = shopStoreBaseService.covMerchEntryInfo2StoreInfo(mchId, false); Pair<Integer, String> retPair = shopStoreBaseService.covMerchEntryInfo2StoreInfo(mchId, false);
if (retPair.getFirst() <= 0) { if (retPair.getFirst() <= 0) {
shopMchEntryService.updateMerchEntryApprovalByMchId(mchId, null, "创建初始化店铺失败：" + retPair.getSecond()); shopMchEntryService.updateMerchEntryApprovalByMchId(mchId, null, "创建并初始化店铺失败：" + retPair.getSecond());
log.error("进件成功，但初始化店铺失败: mchId={}, reason={}", mchId, retPair.getSecond()); log.error("进件成功，但初始化店铺失败: mchId={}, reason={}", mchId, retPair.getSecond());
} else { } else {
shopMchEntryService.updateMulStatus(mchId, merCupNo, 0, 0, 1, 0, 0, 0, 0); shopMchEntryService.updateMulStatus(mchId, merCupNo, 0, 0, 1, 0, 0, 0, 0);
log.info("进件成功，创建并初始化店铺成功！mchId={}", mchId); log.info("进件成功，创建并初始化店铺成功！mchId={}", mchId);
} }
}
// 10. 检查商户绑定状态是否完成， 更改总的审核状态 // 10. 检查商户绑定状态是否完成， 更改总的审核状态
shopMchEntryService.checkMerchEntryFinished(mchId); shopMchEntryService.checkMerchEntryFinished(mchId);
} catch (Exception e) {
log.error("处理商户店铺创建或状态检查时发生异常，mchId: {}", mchId, e);
// 不中断主流程，继续返回成功
}
// 11. 日志记录并返回成功响应 // 11. 日志记录并返回成功响应
log.info("商家绑定分账接收方异步通知处理完成，mchId:{} merCupNo：{}", mchId, merCupNo); 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 userId
* @param payload * @param payload
* @param isFinishNotice 是签署完成通知？
* @return * @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 @Async
@Override @Override
public CompletableFuture<Boolean> noticeMerchantSignEcContract(Integer userId, JSONObject payload) { public CompletableFuture<Boolean> noticeMerchantSignEcContract(Integer userId, JSONObject payload, Boolean isFinishNotice) {
try { try {
// 获取商家的 cid 列表，确保用户 ID 有效 // 获取商家的 cid 列表，确保用户 ID 有效
if (userId == null || userId <= 0) { if (userId == null || userId <= 0) {
@ -137,9 +137,12 @@ public class PushMessageServiceImpl implements PushMessageService {
return CompletableFuture.completedFuture(false); // 无有效 cid 无需推送 return CompletableFuture.completedFuture(false); // 无有效 cid 无需推送
} }
String title = isFinishNotice ? "通知您合同已签署完毕" : "邀请您签署入驻合同";
String content = isFinishNotice ? "您的开店入驻合同已签署完成！" : "恭喜您！您的开店入驻申请已初步审核通过！请尽快登录小发商家 APP 平台签署电子合同，签署链接24小时内有效（逾期需重新提交申请）。如有疑问请联系客服，感谢您的支持！";
Pair<Boolean, String> result = uniCloudPushService.sendPushMessageBatch(cidList, Pair<Boolean, String> result = uniCloudPushService.sendPushMessageBatch(cidList,
appName + "邀请您签署入驻合同", appName + title,
"恭喜您的开店入驻申请已审核通过！请尽快登录小发商家 APP 平台签署电子合同，签署链接24小时内有效（逾期需重新提交申请）。如有疑问请联系客服，感谢您的支持！", content,
payload); payload);
if (!result.getFirst()) { 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 = "查询顺丰同城订单状态流") @ApiOperation(value = "查询顺丰同城订单状态流", notes = "查询顺丰同城订单状态流")
@RequestMapping(value = "/list-order-feed", method = RequestMethod.POST) @RequestMapping(value = "/list-order-feed", method = RequestMethod.POST)
public ThirdApiRes listOrderFeed(@RequestParam(name = "order_id", defaultValue = "") String orderId) { public ThirdApiRes listOrderFeed(@RequestParam(name = "order_id", defaultValue = "") String orderId) {
if (StrUtil.isBlank(orderId) || orderId == "undefined" || orderId == "null") { if (StrUtil.isBlank(orderId) || "undefined".equals(orderId) || "null".equals(orderId) || "none".equals(orderId)) {
return new ThirdApiRes().fail(1003, "请求参数有误！"); return new ThirdApiRes().fail(1003, "缺少参数或参数有误！");
} }
Map<String, Object> params = new HashMap<>(); 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); 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("请指定店铺或银行的省市区！"); return CommonResult.failed("请指定店铺或银行的省市区！");
} }
if (!PhoneNumberUtils.checkPhoneNumber(loginMobile)) { if (!PhoneNumberUtils.checkPhoneNumber(loginMobile)) {
log.warn("申请人手机号码格式错误，手机号: {}", loginMobile); log.warn("申请人手机号码格式错误，手机号: {}", loginMobile);
return CommonResult.failed("申请人手机号码有误！"); return CommonResult.failed("申请人手机号码有误！");
@ -1042,7 +1041,7 @@ public class ShopMchEntryServiceImpl extends BaseServiceImpl<ShopMchEntryMapper,
if (StrUtil.isBlank(contactMobile)) { if (StrUtil.isBlank(contactMobile)) {
return Pair.of(false, "联系人手机号不能为空"); return Pair.of(false, "联系人手机号不能为空");
} }
queryWrapper.eq("legal_person_mobile", contactMobile); queryWrapper.eq("legal_person_mobile", contactMobile); // 企业和个人公用该字段（联系人手机号）
String msg = ""; String msg = "";
// 4. 根据主体类型设置额外查询条件和提示信息 // 4. 根据主体类型设置额外查询条件和提示信息
@ -1067,7 +1066,6 @@ public class ShopMchEntryServiceImpl extends BaseServiceImpl<ShopMchEntryMapper,
return Pair.of(false, msg); return Pair.of(false, msg);
} }
log.info("可以申请入驻，准备申请入驻"); log.info("可以申请入驻，准备申请入驻");
return Pair.of(true, "可以申请入驻，准备下一个流程"); return Pair.of(true, "可以申请入驻，准备下一个流程");
@ -1738,6 +1736,7 @@ public class ShopMchEntryServiceImpl extends BaseServiceImpl<ShopMchEntryMapper,
log.error("更新商户入驻信息状态失败, mchId={}", mchId); log.error("更新商户入驻信息状态失败, mchId={}", mchId);
return false; return false;
} }
return true; // 返回 true，表示入驻流程已全部完成 return true; // 返回 true，表示入驻流程已全部完成
} catch (Exception e) { } 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 @Override
@Transactional @Transactional
public CommonResult storeSetUp() { public CommonResult storeSetUp() {
UserDto user = getCurrentUser(); UserDto user = getCurrentUser();
ShopStoreBase base = new ShopStoreBase(); if (user == null) {
logger.warn("用户未登录，无法设置店铺信息");
return CommonResult.failed("用户未登录");
}
ShopStoreBase base = new ShopStoreBase();
if (user.isPlatform()) { if (user.isPlatform()) {
// 平台方 // 平台方
Integer store_id = getParameter("store_id", Integer.class); 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); base.setStore_id(store_id);
ShopStoreInfo info = new ShopStoreInfo(); ShopStoreInfo info = new ShopStoreInfo();
@ -2330,7 +2337,6 @@ public class ShopStoreBaseServiceImpl extends BaseServiceImpl<ShopStoreBaseMappe
base.setStore_circle(store_circle); base.setStore_circle(store_circle);
} }
String store_area = getParameter("store_area"); String store_area = getParameter("store_area");
if (StrUtil.isNotBlank(store_area)) { if (StrUtil.isNotBlank(store_area)) {
base.setStore_area(store_area); base.setStore_area(store_area);
@ -2379,17 +2385,29 @@ public class ShopStoreBaseServiceImpl extends BaseServiceImpl<ShopStoreBaseMappe
} }
if (packingFee.compareTo(new BigDecimal("10")) > 0) { if (packingFee.compareTo(new BigDecimal("10")) > 0) {
logger.warn("打包费超出范围: {}", packingFee);
return CommonResult.failed("打包费请控制在0到10元范围"); return CommonResult.failed("打包费请控制在0到10元范围");
} }
base.setPacking_fee(packingFee); base.setPacking_fee(packingFee);
// 铃声开关
Integer ringtoneIsEnable = Convert.toInt(getParameter("ringtone_is_enable")); Integer ringtoneIsEnable = Convert.toInt(getParameter("ringtone_is_enable"));
if (ringtoneIsEnable == null || ringtoneIsEnable <= 0) { if (ringtoneIsEnable == null || ringtoneIsEnable <= 0) {
ringtoneIsEnable = CommonConstant.Enable; ringtoneIsEnable = CommonConstant.Enable;
} }
base.setRingtone_is_enable(ringtoneIsEnable); 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经纬度，所以需要转换 ） // 百度坐标系BD09经纬度 转出 火星坐标系GCJ02经纬度 （因为数据库保存的经纬度统一是GCJ02经纬度，所以需要转换 ）
base = bd09ToGcj02Gps(base); base = bd09ToGcj02Gps(base);
@ -2397,10 +2415,20 @@ public class ShopStoreBaseServiceImpl extends BaseServiceImpl<ShopStoreBaseMappe
AccountUserBase userInfo = new AccountUserBase(); AccountUserBase userInfo = new AccountUserBase();
userInfo.setUser_id(getParameter("user_id", Integer.class)); userInfo.setUser_id(getParameter("user_id", Integer.class));
userInfo.setUser_password(getParameter("user_password")); 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()) { } else if (user.isStore()) {
// 店铺 // 店铺
Integer store_id = Convert.toInt(user.getStore_id()); Integer store_id = Convert.toInt(user.getStore_id());
if (store_id == null) {
logger.warn("商户用户无关联店铺，用户ID: {}", user.getId());
return CommonResult.failed("用户无关联店铺");
}
ShopStoreInfo info = new ShopStoreInfo(); ShopStoreInfo info = new ShopStoreInfo();
String store_slogan = getParameter("store_slogan"); String store_slogan = getParameter("store_slogan");
@ -2457,15 +2485,6 @@ public class ShopStoreBaseServiceImpl extends BaseServiceImpl<ShopStoreBaseMappe
if (StrUtil.isNotBlank(store_o2o_tags)) { if (StrUtil.isNotBlank(store_o2o_tags)) {
base.setStore_o2o_tags(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"); String store_banner = getParameter("store_banner");
if (StrUtil.isNotBlank(store_banner)) { if (StrUtil.isNotBlank(store_banner)) {
@ -2538,6 +2557,7 @@ public class ShopStoreBaseServiceImpl extends BaseServiceImpl<ShopStoreBaseMappe
shopStoreConfig.setStore_id(store_id); shopStoreConfig.setStore_id(store_id);
shopStoreConfig.setSc_is_enabled_invoice(Convert.toInt(sc_is_enabled_invoice)); shopStoreConfig.setSc_is_enabled_invoice(Convert.toInt(sc_is_enabled_invoice));
if (!shopStoreConfigService.edit(shopStoreConfig)) { if (!shopStoreConfigService.edit(shopStoreConfig)) {
logger.error("保存店铺参数失败，店铺ID: {}", store_id);
throw new ApiException(I18nUtil._("保存店铺参数失败")); throw new ApiException(I18nUtil._("保存店铺参数失败"));
} }
} }
@ -2549,6 +2569,7 @@ public class ShopStoreBaseServiceImpl extends BaseServiceImpl<ShopStoreBaseMappe
} }
if (packingFee.compareTo(new BigDecimal("10")) > 0) { if (packingFee.compareTo(new BigDecimal("10")) > 0) {
logger.warn("打包费超出范围: {}", packingFee);
return CommonResult.failed("打包费请控制在0到10元范围"); return CommonResult.failed("打包费请控制在0到10元范围");
} }
base.setPacking_fee(packingFee); base.setPacking_fee(packingFee);
@ -2564,14 +2585,19 @@ public class ShopStoreBaseServiceImpl extends BaseServiceImpl<ShopStoreBaseMappe
base = bd09ToGcj02Gps(base); base = bd09ToGcj02Gps(base);
if (!saveInfo(base, info, null, company)) { if (!saveInfo(base, info, null, company)) {
logger.error("商户保存店铺信息失败，店铺ID: {}", store_id);
throw new ApiException(I18nUtil._("保存店铺信息失败")); throw new ApiException(I18nUtil._("保存店铺信息失败"));
} }
} else {
logger.warn("用户无操作权限，用户ID: {}", user.getId());
return CommonResult.failed("无操作权限");
} }
return CommonResult.success(); return CommonResult.success();
} }
public Integer getSubsiteId(String store_district_id) { public Integer getSubsiteId(String store_district_id) {
int[] area = StrUtil.splitToInt(store_district_id, "/"); int[] area = StrUtil.splitToInt(store_district_id, "/");
String city = Convert.toStr(area[1]); String city = Convert.toStr(area[1]);
@ -3125,138 +3151,145 @@ public class ShopStoreBaseServiceImpl extends BaseServiceImpl<ShopStoreBaseMappe
return covMerchEntryInfo2StoreInfo(mchId, allowThrown); return covMerchEntryInfo2StoreInfo(mchId, allowThrown);
} }
/**
* （重要）入驻审批通过并且合同盖章完结之后，把商家入驻信息转换成店铺信息，正式生成店铺所需的数据
*
* @param mchId
* @param allowThrown 是否允许抛出异常？
* @return
*/
@Override @Override
public Pair<Integer, String> covMerchEntryInfo2StoreInfo(Long mchId, Boolean allowThrown) { public Pair<Integer, String> covMerchEntryInfo2StoreInfo(Long mchId, Boolean allowThrown) {
// 参数校验
// TODO 用法人、小微个人的手机号注册商家账号，作为店铺的管理员
if (ObjectUtil.isEmpty(mchId)) { if (ObjectUtil.isEmpty(mchId)) {
logger.error("生成店铺：入驻商家自增Id不能为空"); logger.error("生成店铺：入驻商家自增Id不能为空");
return Pair.of(0, "入驻商家自增Id不能为空"); return Pair.of(0, "入驻商家自增Id不能为空");
} }
try { try {
// 获取入驻信息
ShopMchEntry shopMchEntry = shopMchEntryService.shopMerchEntryById(mchId); ShopMchEntry shopMchEntry = shopMchEntryService.shopMerchEntryById(mchId);
if (shopMchEntry == null) { if (shopMchEntry == null) {
logger.error("生成店铺：入驻信息不能为空"); logger.error("生成店铺：入驻信息不能为空");
return Pair.of(0, "入驻信息不能为空"); return Pair.of(0, "入驻信息不能为空");
} }
// 如果 还没有签署入网电子合同且没有进件成功，则提示前置条件未满足 // 前置条件检查
if (!CommonConstant.Enable.equals(shopMchEntry.getHas_ec_signed()) if (!CommonConstant.Enable.equals(shopMchEntry.getHas_ec_signed())
&& !CommonConstant.Enable.equals(shopMchEntry.getHas_apply_mer())) { && !CommonConstant.Enable.equals(shopMchEntry.getHas_apply_mer())) {
return Pair.of(0, "请先签署电子合同和商家进件，再创建店铺。"); return Pair.of(0, "请先签署电子合同和商家进件，再创建店铺。");
} }
// TODO 判断要不要给入驻的企业法人手机、小微联系人手机注册一个账号？ // 获取用户ID
Integer userId = accountService.getUserBindConnectUserIdByCondition(
// 从绑定关系中，获取入驻商家注册账号信息 shopMchEntry.getLogin_mobile(), BindCode.MOBILE, CommonConstant.USER_TYPE_MCH);
Integer userId = accountService.getUserBindConnectUserIdByCondition(shopMchEntry.getLogin_mobile(), BindCode.MOBILE, CommonConstant.USER_TYPE_MCH);
if (userId == null) { if (userId == null) {
logger.error("生成店铺：{}手机未注册商家账号", shopMchEntry.getLogin_mobile()); logger.error("生成店铺：{}手机未注册商家账号", shopMchEntry.getLogin_mobile());
return Pair.of(0, "手机未注册商家账号！"); return Pair.of(0, "手机未注册商家账号！");
} }
// 入驻时已经检查过店铺名称了，此处忽略 // 检查店铺名称
ShopStoreBase shopStoreBase = findOneByStoreName(shopMchEntry.getStore_name()); ShopStoreBase shopStoreBase = findOneByStoreName(shopMchEntry.getStore_name());
if (shopStoreBase != null if (shopStoreBase != null
&& StrUtil.isNotBlank(shopStoreBase.getLkl_merchant_no()) && StrUtil.isNotBlank(shopStoreBase.getLkl_merchant_no())
&& StrUtil.isNotBlank(shopStoreBase.getLkl_term_no()) && StrUtil.isNotBlank(shopStoreBase.getLkl_term_no())
&& shopMchEntry.getStore_id() != null // 添加null检查
&& !shopStoreBase.getStore_id().toString().equals(shopMchEntry.getStore_id())) { && !shopStoreBase.getStore_id().toString().equals(shopMchEntry.getStore_id())) {
// 如果店铺名称已存在，且店铺已经进件，且不等于当前入驻商家的店铺Id，提示店铺名称已存在
logger.error("生成店铺：店铺名称已存在"); logger.error("生成店铺：店铺名称已存在");
return Pair.of(0, "店铺名称已存在，请使用另一名称"); return Pair.of(0, "店铺名称已存在，请使用另一名称");
} }
// 新增 shop_store_base，shop_store_info，shop_store_company, shop_store_employee 待补充 // 创建或更新店铺基础信息
// shop_store_base
if (shopStoreBase == null) { if (shopStoreBase == null) {
shopStoreBase = new ShopStoreBase(); shopStoreBase = new ShopStoreBase();
} }
shopStoreBase.setUser_id(userId); // 店铺管理员用户Id // 设置店铺基础信息（添加null检查）
shopStoreBase.setUser_id(userId);
shopStoreBase.setStore_name(shopMchEntry.getStore_name()); shopStoreBase.setStore_name(shopMchEntry.getStore_name());
shopStoreBase.setStore_category_id(shopMchEntry.getBiz_category()); // 重要，店铺分类id，对应 shop_base_store_category 表的分类 shopStoreBase.setStore_category_id(shopMchEntry.getBiz_category());
shopStoreBase.setStore_2nd_category_id(shopMchEntry.getBiz_second_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 storeFacadeImage = shopMchEntry.getFront_facade_image();
String storeLogoImage = shopMchEntry.getStore_logo(); String storeLogoImage = shopMchEntry.getStore_logo();
if (StrUtil.isBlank(storeLogoImage)) { if (StrUtil.isBlank(storeLogoImage)) {
storeLogoImage = storeFacadeImage; 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_address(shopMchEntry.getStore_address());
shopStoreBase.setStore_longitude(shopMchEntry.getStore_longitude()); shopStoreBase.setStore_longitude(shopMchEntry.getStore_longitude());
shopStoreBase.setStore_latitude(shopMchEntry.getStore_latitude()); shopStoreBase.setStore_latitude(shopMchEntry.getStore_latitude());
shopStoreBase.setStore_grade_id(1001); // 店铺等级，默认为普通店铺 shopStoreBase.setStore_grade_id(1001);
shopStoreBase.setStore_type(1);//店铺类型(ENUM): 1-卖家店铺; 2-供应商店铺 shopStoreBase.setStore_type(1);
shopStoreBase.setStore_is_open(1); shopStoreBase.setStore_is_open(1);
shopStoreBase.setStore_is_selfsupport(0); shopStoreBase.setStore_is_selfsupport(0);
shopStoreBase.setStore_o2o_flag(0); shopStoreBase.setStore_o2o_flag(0);
shopStoreBase.setSubsite_id(0); shopStoreBase.setSubsite_id(0);
// 拉卡拉外部商户号 // 设置拉卡拉信息
shopStoreBase.setLkl_merchant_no(shopMchEntry.getLkl_mer_cup_no()); shopStoreBase.setLkl_merchant_no(shopMchEntry.getLkl_mer_cup_no());
// 拉卡拉分配的终端号
shopStoreBase.setLkl_term_no(shopMchEntry.getLkl_term_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_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)) { if (!save(shopStoreBase)) {
logger.error("生成店铺：新增或更改店铺基本信息失败"); logger.error("生成店铺：新增或更改店铺基本信息失败");
if (allowThrown) { if (Boolean.TRUE.equals(allowThrown)) {
throw new ApiException(I18nUtil._("新增或更改店铺基本信息失败")); throw new ApiException("新增或更改店铺基本信息失败");
} }
return Pair.of(0, "新增或更改店铺基础信息失败"); return Pair.of(0, "新增或更改店铺基础信息失败");
} }
// 保存后店铺Id // 获取店铺ID
Integer storeId = shopStoreBase.getStore_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 shopStoreInfo = new ShopStoreInfo();
shopStoreInfo.setStore_id(storeId); shopStoreInfo.setStore_id(storeId);
shopStoreInfo.setStore_start_time(DateUtil.date()); shopStoreInfo.setStore_start_time(DateUtil.date());
shopStoreInfo.setStore_end_time(DateUtil.offsetDay(DateUtil.date(), 365 * 5)); shopStoreInfo.setStore_end_time(DateUtil.offsetDay(DateUtil.date(), 365 * 5));
shopStoreInfo.setStore_opening_hours("08:00"); shopStoreInfo.setStore_opening_hours("07:30");
shopStoreInfo.setStore_close_hours("22:00"); shopStoreInfo.setStore_close_hours("23:00");
shopStoreInfo.setStore_discount(BigDecimal.valueOf(10));// 原价 shopStoreInfo.setStore_discount(BigDecimal.valueOf(10));
shopStoreInfo.setStore_banner(storeFacadeImage); 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.setStore_tel(contact_mobile);
shopStoreInfo.setContact_mobile(contact_mobile); shopStoreInfo.setContact_mobile(contact_mobile);
shopStoreInfo.setContact_name(shopMchEntry.getContact_name()); shopStoreInfo.setContact_name(shopMchEntry.getContact_name());
String websiteXFTC = "https://www.gpxscs.cn"; // 构建幻灯片
JSONArray list = new JSONArray(); JSONArray list = new JSONArray();
if (StrUtil.isNotBlank(storeFacadeImage)) { if (StrUtil.isNotBlank(storeFacadeImage)) {
JSONObject slide = new JSONObject(); JSONObject slide = new JSONObject();
slide.put("img", storeFacadeImage); slide.put("img", storeFacadeImage);
slide.put("name", "店铺门面照片"); slide.put("name", "店铺门面照片");
slide.put("check", true); slide.put("check", true);
slide.put("url", websiteXFTC); slide.put("url", "https://www.gpxscs.cn");
list.put(slide); list.put(slide);
} }
if (StrUtil.isNotBlank(shopMchEntry.getEnvironment_image())) { if (StrUtil.isNotBlank(shopMchEntry.getEnvironment_image())) {
@ -3264,54 +3297,64 @@ public class ShopStoreBaseServiceImpl extends BaseServiceImpl<ShopStoreBaseMappe
slide.put("img", shopMchEntry.getEnvironment_image()); slide.put("img", shopMchEntry.getEnvironment_image());
slide.put("name", "店铺环境照片"); slide.put("name", "店铺环境照片");
slide.put("check", true); slide.put("check", true);
slide.put("url", websiteXFTC); slide.put("url", "https://www.gpxscs.cn");
list.put(slide); list.put(slide);
} }
shopStoreInfo.setStore_slide(list.toString()); 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); shopStoreInfo.setStore_state_id(StateCode.STORE_STATE_YES);
if (!shopStoreInfoService.save(shopStoreInfo)) { if (!shopStoreInfoService.save(shopStoreInfo)) {
logger.error("生成店铺：新增店铺info失败"); logger.error("生成店铺：新增店铺info失败");
if (allowThrown) { if (Boolean.TRUE.equals(allowThrown)) {
throw new ApiException(I18nUtil._("新增店铺信息失败")); throw new ApiException("新增店铺信息失败");
} }
return Pair.of(0, "新增店铺信息失败"); return Pair.of(0, "新增店铺信息失败");
} }
// 初始化默认公司信息，避免商家编辑不了，申请入驻即使是个人类型的，也需要保存相关应有信息，公司信息不能空着 // 创建店铺公司信息
// shop_store_company
ShopStoreCompany shopStoreCompany = shopStoreCompanyService.getCompany(storeId); ShopStoreCompany shopStoreCompany = shopStoreCompanyService.getCompany(storeId);
if (shopStoreCompany == null) { if (shopStoreCompany == null) {
shopStoreCompany = new ShopStoreCompany();
}
shopStoreCompany.setUser_id(userId); shopStoreCompany.setUser_id(userId);
shopStoreCompany.setStore_id(storeId); shopStoreCompany.setStore_id(storeId);
// 联系人 // 设置联系人信息
shopStoreCompany.setContacts_name(shopMchEntry.getContact_name()); shopStoreCompany.setContacts_name(shopMchEntry.getContact_name());
shopStoreCompany.setContacts_phone(contact_mobile); 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_name(companyName);
shopStoreCompany.setCompany_area(shopStoreBase.getStore_area());
if (storeArea != null) {
shopStoreCompany.setCompany_area(storeArea);
}
shopStoreCompany.setCompany_address(shopMchEntry.getStore_address()); shopStoreCompany.setCompany_address(shopMchEntry.getStore_address());
// 营业执照 // 设置营业执照信息
shopStoreCompany.setBusiness_id(shopMchEntry.getBiz_license_number()); shopStoreCompany.setBusiness_id(shopMchEntry.getBiz_license_number());
shopStoreCompany.setBusiness_license_electronic(shopMchEntry.getBiz_license_image()); shopStoreCompany.setBusiness_license_electronic(shopMchEntry.getBiz_license_image());
// 企业法人 // 设置法人信息
shopStoreCompany.setLegal_person(shopMchEntry.getLegal_person_name()); shopStoreCompany.setLegal_person(shopMchEntry.getLegal_person_name());
shopStoreCompany.setLegal_person_number(shopMchEntry.getLegal_person_id_number()); shopStoreCompany.setLegal_person_number(shopMchEntry.getLegal_person_id_number());
shopStoreCompany.setLegal_person_electronic(shopMchEntry.getLegal_person_id_images()); shopStoreCompany.setLegal_person_electronic(shopMchEntry.getLegal_person_id_images());
// 银行对公账号 // 设置银行信息
shopStoreCompany.setBank_account_name(shopMchEntry.getAccount_holder_name()); shopStoreCompany.setBank_account_name(shopMchEntry.getAccount_holder_name());
shopStoreCompany.setBank_account_number(shopMchEntry.getAccount_number()); shopStoreCompany.setBank_account_number(shopMchEntry.getAccount_number());
shopStoreCompany.setBank_name(shopMchEntry.getBank_name()); shopStoreCompany.setBank_name(shopMchEntry.getBank_name());
Date today = new Date(); // 当前时间 Date today = new Date();
shopStoreCompany.setOrganization_code_start(today); 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.setEstablish_date(today);
shopStoreCompany.setBusiness_licence_start(today); shopStoreCompany.setBusiness_licence_start(today);
shopStoreCompany.setBusiness_licence_end(DateUtil.offsetDay(today, 365 * 10)); shopStoreCompany.setBusiness_licence_end(DateUtil.offsetDay(today, 365 * 10));
@ -3323,26 +3366,24 @@ public class ShopStoreBaseServiceImpl extends BaseServiceImpl<ShopStoreBaseMappe
if (!shopStoreCompanyService.save(shopStoreCompany)) { if (!shopStoreCompanyService.save(shopStoreCompany)) {
logger.error("生成店铺：新增店铺公司失败"); logger.error("生成店铺：新增店铺公司失败");
if (allowThrown) { if (Boolean.TRUE.equals(allowThrown)) {
throw new ApiException(I18nUtil._("新增店铺公司失败")); throw new ApiException("新增店铺公司失败");
} }
return Pair.of(0, "新增店铺公司失败"); return Pair.of(0, "新增店铺公司失败");
} }
}
// 创建店铺员工信息
List<ShopStoreEmployee> shopStoreEmployees = shopStoreEmployeeService.selectEmployeeByCondition(storeId, null, null); List<ShopStoreEmployee> shopStoreEmployees = shopStoreEmployeeService.selectEmployeeByCondition(storeId, null, null);
ShopStoreEmployee shopStoreEmployee = new ShopStoreEmployee(); ShopStoreEmployee shopStoreEmployee = new ShopStoreEmployee();
shopStoreEmployee.setStore_id(storeId); shopStoreEmployee.setStore_id(storeId);
shopStoreEmployee.setUser_id(userId); shopStoreEmployee.setUser_id(userId);
shopStoreEmployee.setRights_group_id(""); // 店铺管理员,店铺 shopStoreEmployee.setRights_group_id("");
shopStoreEmployee.setEmployee_is_kefu(CommonConstant.Enable); shopStoreEmployee.setEmployee_is_kefu(CommonConstant.Enable);
if (CollUtil.isEmpty(shopStoreEmployees)) { // 添加管理员 if (CollUtil.isEmpty(shopStoreEmployees)) {
// shop_store_employee 店铺员工，添加管理员
shopStoreEmployee.setEmployee_is_admin(CommonConstant.Enable); shopStoreEmployee.setEmployee_is_admin(CommonConstant.Enable);
} else { // 添加店员或管理员 } else {
shopStoreEmployees = shopStoreEmployeeService.selectEmployeeByCondition(storeId, userId, null); shopStoreEmployees = shopStoreEmployeeService.selectEmployeeByCondition(storeId, userId, null);
if (CollUtil.isEmpty(shopStoreEmployees)) { if (CollUtil.isEmpty(shopStoreEmployees)) {
shopStoreEmployee.setEmployee_is_admin(CommonConstant.Disable); shopStoreEmployee.setEmployee_is_admin(CommonConstant.Disable);
@ -3353,13 +3394,13 @@ public class ShopStoreBaseServiceImpl extends BaseServiceImpl<ShopStoreBaseMappe
if (!shopStoreEmployeeService.save(shopStoreEmployee)) { if (!shopStoreEmployeeService.save(shopStoreEmployee)) {
logger.error("生成店铺：新增店铺员工失败"); logger.error("生成店铺：新增店铺员工失败");
if (allowThrown) { if (Boolean.TRUE.equals(allowThrown)) {
throw new ApiException(I18nUtil._("新增店铺员工失败")); throw new ApiException("新增店铺员工失败");
} }
return Pair.of(0, "新增店铺员工失败"); return Pair.of(0, "新增店铺员工失败");
} }
// 生成店铺的太阳码 2025-03-31 // 生成微信二维码
if (StrUtil.isBlank(shopStoreBase.getWx_qrcode())) { if (StrUtil.isBlank(shopStoreBase.getWx_qrcode())) {
Pair<String, String> resp = wxQrCodeService.genUnlimitedWxQrCode("pagesub/index/store", "store_id=" + storeId); Pair<String, String> resp = wxQrCodeService.genUnlimitedWxQrCode("pagesub/index/store", "store_id=" + storeId);
if (StrUtil.isNotBlank(resp.getFirst())) { if (StrUtil.isNotBlank(resp.getFirst())) {
@ -3367,252 +3408,294 @@ public class ShopStoreBaseServiceImpl extends BaseServiceImpl<ShopStoreBaseMappe
} }
} }
// 注意：关联店铺到用户，给用户增加店铺管理员权限 // 初始化店铺额外信息
initStoreExtraInfo(userId, storeId, allowThrown); initStoreExtraInfo(userId, storeId, allowThrown);
// 更改店铺Id和状态 // 更新商家入驻状态
if (shopMchEntry.getId() != null) {
shopMchEntryService.updateMerchEntryStoreStatus(shopMchEntry.getId(), storeId); shopMchEntryService.updateMerchEntryStoreStatus(shopMchEntry.getId(), storeId);
}
// 立即创建顺丰店铺，附带初始化同城配送默认设置 // 创建顺丰店铺（修复经纬度参数错误）
String[] areaNames = StrUtil.isNotBlank(shopMchEntry.getStore_area()) ? shopMchEntry.getStore_area().split("/") : new String[0]; if (storeArea != null) {
String cityName = areaNames.length > 0 ? areaNames[areaNames.length - 1] : shopMchEntry.getStore_area().replace("/", ""); String[] areaNames = storeArea.split("/");
sfExpressApiService.createSfExpressShop(storeId, shopMchEntry.getStore_name(), cityName, shopMchEntry.getStore_address(), shopMchEntry.getContact_name(), contact_mobile, shopMchEntry.getStore_longitude(), shopMchEntry.getStore_longitude()); 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, "新增成功"); return Pair.of(storeId, "新增成功");
} catch (Exception e) { } catch (Exception e) {
logger.error("店铺生成失败", e); logger.error("店铺生成失败", e);
if (allowThrown) { if (Boolean.TRUE.equals(allowThrown)) {
throw new ApiException(I18nUtil._("店铺生成失败")); throw new ApiException("店铺生成失败");
} }
return Pair.of(0, e.getMessage()); return Pair.of(0, e.getMessage());
} }
} }
/** /**
* 初始化店长（店铺管理员）的权限组 * 初始化店长（店铺管理员）的权限组
* *
* @param userId * @param userId 用户ID
* @param storeId * @param storeId 店铺ID
* @param allowThrown 是否允许抛出异常
*/ */
private void initStoreExtraInfo(Integer userId, Integer storeId, Boolean allowThrown) { private void initStoreExtraInfo(Integer userId, Integer storeId, Boolean allowThrown) {
if (ObjectUtil.isNull(userId) || ObjectUtil.isNull(storeId)) { if (ObjectUtil.isNull(userId) || ObjectUtil.isNull(storeId)) {
log.warn("初始化店铺额外信息参数为空: userId={}, storeId={}", userId, storeId);
return; return;
} }
Date today = new Date(); // 当前时间 Date today = new Date(); // 当前时间
try {
// 初始化时添加一条店铺分析信息 // 初始化时添加一条店铺分析信息
ShopStoreAnalytics storeAnalytics = shopStoreAnalyticsService.getByStoreId(storeId); ShopStoreAnalytics storeAnalytics = shopStoreAnalyticsService.getByStoreId(storeId);
if (storeAnalytics == null) { if (storeAnalytics == null) {
storeAnalytics = new ShopStoreAnalytics(); storeAnalytics = new ShopStoreAnalytics();
storeAnalytics.setStore_id(storeId); storeAnalytics.setStore_id(storeId);
if (!shopStoreAnalyticsService.add(storeAnalytics)) { if (!shopStoreAnalyticsService.add(storeAnalytics)) {
if (allowThrown) { String errorMsg = "初始化店铺分析信息失败";
if (Boolean.TRUE.equals(allowThrown)) {
throw new ApiException(ResultCode.FAILED); throw new ApiException(ResultCode.FAILED);
} }
log.error("初始化店铺分析信息失败"); log.error(errorMsg);
return;
} }
} }
// 初始化店铺商品标签 // 初始化店铺商品标签
QueryWrapper<ShopBaseProductTag> tagQueryWrapper = new QueryWrapper<>(); QueryWrapper<ShopBaseProductTag> tagQueryWrapper = new QueryWrapper<>();
tagQueryWrapper.orderByAsc("product_tag_id"); tagQueryWrapper.orderByAsc("product_tag_id");
Page<ShopBaseProductTag> base_product_tag_row = shopBaseProductTagService.lists(tagQueryWrapper, 1, 5); Page<ShopBaseProductTag> baseProductTagPage = shopBaseProductTagService.lists(tagQueryWrapper, 1, 5);
List<ShopStoreProductTag> store_product_tag_row = new ArrayList<>();
for (ShopBaseProductTag teg : base_product_tag_row.getRecords()) { if (baseProductTagPage != null && CollUtil.isNotEmpty(baseProductTagPage.getRecords())) {
List<ShopStoreProductTag> storeProductTagList = new ArrayList<>();
for (ShopBaseProductTag tag : baseProductTagPage.getRecords()) {
if (tag != null) {
ShopStoreProductTag shopStoreProductTag = new ShopStoreProductTag(); ShopStoreProductTag shopStoreProductTag = new ShopStoreProductTag();
store_product_tag_row.add(shopStoreProductTag); shopStoreProductTag.setProduct_tag_id(tag.getProduct_tag_id());
shopStoreProductTag.setProduct_tag_id(teg.getProduct_tag_id());
shopStoreProductTag.setStore_id(storeId); shopStoreProductTag.setStore_id(storeId);
shopStoreProductTag.setProduct_tag_time(today); shopStoreProductTag.setProduct_tag_time(today);
shopStoreProductTag.setStore_product_tag_buildin(1); shopStoreProductTag.setStore_product_tag_buildin(1);
storeProductTagList.add(shopStoreProductTag);
}
} }
if (CollUtil.isNotEmpty(store_product_tag_row)) { if (CollUtil.isNotEmpty(storeProductTagList)) {
if (!shopStoreProductTagService.saveOrUpdate(store_product_tag_row)) { if (!shopStoreProductTagService.saveOrUpdate(storeProductTagList)) {
if (allowThrown) { String errorMsg = "初始化店铺商品标签失败";
if (Boolean.TRUE.equals(allowThrown)) {
throw new ApiException(ResultCode.FAILED); throw new ApiException(ResultCode.FAILED);
} }
log.error("初始化店铺商品标签失败"); log.error(errorMsg);
return;
}
} }
} }
//初始化默认店铺仓库 // 初始化默认店铺仓库
InvoicingWarehouseBase invoicingWarehouseBase = new InvoicingWarehouseBase(); InvoicingWarehouseBase invoicingWarehouseBase = new InvoicingWarehouseBase();
invoicingWarehouseBase.setWarehouse_name(I18nUtil._("默认")); invoicingWarehouseBase.setWarehouse_name("默认");
invoicingWarehouseBase.setStore_id(storeId); invoicingWarehouseBase.setStore_id(storeId);
invoicingWarehouseBase.setWarehouse_address(""); invoicingWarehouseBase.setWarehouse_address("");
invoicingWarehouseBase.setWarehouse_number(""); invoicingWarehouseBase.setWarehouse_number("");
invoicingWarehouseBase.setWarehouse_contact(""); invoicingWarehouseBase.setWarehouse_contact("");
if (!invoicingWarehouseBaseService.saveOrUpdate(invoicingWarehouseBase)) { if (!invoicingWarehouseBaseService.saveOrUpdate(invoicingWarehouseBase)) {
if (allowThrown) { String errorMsg = "初始化默认店铺仓库失败";
if (Boolean.TRUE.equals(allowThrown)) {
throw new ApiException(ResultCode.FAILED); throw new ApiException(ResultCode.FAILED);
} }
log.error("初始化默认店铺仓库失败"); log.error(errorMsg);
return;
} }
//初始化默认权限 // 初始化默认权限
Page<Serializable> page = shopStoreEmployeeRightsBaseService.listKey(new QueryWrapper<>(), 1, ConfigConstant.MAX_LIST_NUM); 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<>(); 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(); ShopStoreEmployeeRightsGroup shopManager = new ShopStoreEmployeeRightsGroup();
shopManager.setStore_id(storeId); shopManager.setStore_id(storeId);
shopManager.setRights_group_rights_ids(str_rights_group_rights_ids); shopManager.setRights_group_rights_ids(strRightsGroupRightsIds);
shopManager.setRights_group_name(I18nUtil._("店铺管理员")); //Store Owner shopManager.setRights_group_name("店铺管理员"); // Store Owner
shopManager.setRights_group_rights_data(""); //Store Owner shopManager.setRights_group_rights_data(""); // Store Owner
shopStoreEmployeeRightsGroups.add(shopManager); shopStoreEmployeeRightsGroups.add(shopManager);
ShopStoreEmployeeRightsGroup operationsManager = new ShopStoreEmployeeRightsGroup(); ShopStoreEmployeeRightsGroup operationsManager = new ShopStoreEmployeeRightsGroup();
operationsManager.setStore_id(storeId); operationsManager.setStore_id(storeId);
operationsManager.setRights_group_rights_ids(str_rights_group_rights_ids); operationsManager.setRights_group_rights_ids(strRightsGroupRightsIds);
operationsManager.setRights_group_name(I18nUtil._("运营经理")); //Store Owner operationsManager.setRights_group_name("运营经理"); // Store Owner
operationsManager.setRights_group_rights_data(""); //Store Owner operationsManager.setRights_group_rights_data(""); // Store Owner
shopStoreEmployeeRightsGroups.add(operationsManager); shopStoreEmployeeRightsGroups.add(operationsManager);
ShopStoreEmployeeRightsGroup orderReviewer = new ShopStoreEmployeeRightsGroup(); ShopStoreEmployeeRightsGroup orderReviewer = new ShopStoreEmployeeRightsGroup();
orderReviewer.setStore_id(storeId); orderReviewer.setStore_id(storeId);
orderReviewer.setRights_group_rights_ids(str_rights_group_rights_ids); orderReviewer.setRights_group_rights_ids(strRightsGroupRightsIds);
orderReviewer.setRights_group_name(I18nUtil._("订单审核员")); //Store Owner orderReviewer.setRights_group_name("订单审核员"); // Store Owner
orderReviewer.setRights_group_rights_data(""); //Store Owner orderReviewer.setRights_group_rights_data(""); // Store Owner
shopStoreEmployeeRightsGroups.add(orderReviewer); shopStoreEmployeeRightsGroups.add(orderReviewer);
ShopStoreEmployeeRightsGroup financialAuditor = new ShopStoreEmployeeRightsGroup(); ShopStoreEmployeeRightsGroup financialAuditor = new ShopStoreEmployeeRightsGroup();
financialAuditor.setStore_id(storeId); financialAuditor.setStore_id(storeId);
financialAuditor.setRights_group_rights_ids(str_rights_group_rights_ids); financialAuditor.setRights_group_rights_ids(strRightsGroupRightsIds);
financialAuditor.setRights_group_name(I18nUtil._("财务审核员")); //Store Owner financialAuditor.setRights_group_name("财务审核员"); // Store Owner
financialAuditor.setRights_group_rights_data(""); //Store Owner financialAuditor.setRights_group_rights_data(""); // Store Owner
shopStoreEmployeeRightsGroups.add(financialAuditor); shopStoreEmployeeRightsGroups.add(financialAuditor);
ShopStoreEmployeeRightsGroup shippingAuditor = new ShopStoreEmployeeRightsGroup(); ShopStoreEmployeeRightsGroup shippingAuditor = new ShopStoreEmployeeRightsGroup();
shippingAuditor.setStore_id(storeId); shippingAuditor.setStore_id(storeId);
shippingAuditor.setRights_group_rights_ids(str_rights_group_rights_ids); shippingAuditor.setRights_group_rights_ids(strRightsGroupRightsIds);
shippingAuditor.setRights_group_name(I18nUtil._("发货审核员")); //Store Owner shippingAuditor.setRights_group_name("发货审核员"); // Store Owner
shippingAuditor.setRights_group_rights_data(""); //Store Owner shippingAuditor.setRights_group_rights_data(""); // Store Owner
shopStoreEmployeeRightsGroups.add(shippingAuditor); shopStoreEmployeeRightsGroups.add(shippingAuditor);
ShopStoreEmployeeRightsGroup businessManager = new ShopStoreEmployeeRightsGroup(); ShopStoreEmployeeRightsGroup businessManager = new ShopStoreEmployeeRightsGroup();
businessManager.setStore_id(storeId); businessManager.setStore_id(storeId);
businessManager.setRights_group_rights_ids(str_rights_group_rights_ids); businessManager.setRights_group_rights_ids(strRightsGroupRightsIds);
businessManager.setRights_group_name(I18nUtil._("业务经理")); //Store Owner businessManager.setRights_group_name("业务经理"); // Store Owner
businessManager.setRights_group_rights_data(""); //Store Owner businessManager.setRights_group_rights_data(""); // Store Owner
shopStoreEmployeeRightsGroups.add(businessManager); shopStoreEmployeeRightsGroups.add(businessManager);
ShopStoreEmployeeRightsGroup warehouseManager = new ShopStoreEmployeeRightsGroup(); ShopStoreEmployeeRightsGroup warehouseManager = new ShopStoreEmployeeRightsGroup();
warehouseManager.setStore_id(storeId); warehouseManager.setStore_id(storeId);
warehouseManager.setRights_group_rights_ids(str_rights_group_rights_ids); warehouseManager.setRights_group_rights_ids(strRightsGroupRightsIds);
warehouseManager.setRights_group_name(I18nUtil._("仓库管理员")); //Store Owner warehouseManager.setRights_group_name("仓库管理员"); // Store Owner
warehouseManager.setRights_group_rights_data(""); //Store Owner warehouseManager.setRights_group_rights_data(""); // Store Owner
shopStoreEmployeeRightsGroups.add(warehouseManager); shopStoreEmployeeRightsGroups.add(warehouseManager);
ShopStoreEmployeeRightsGroup dataMaintainer = new ShopStoreEmployeeRightsGroup(); ShopStoreEmployeeRightsGroup dataMaintainer = new ShopStoreEmployeeRightsGroup();
dataMaintainer.setStore_id(storeId); dataMaintainer.setStore_id(storeId);
dataMaintainer.setRights_group_rights_ids(str_rights_group_rights_ids); dataMaintainer.setRights_group_rights_ids(strRightsGroupRightsIds);
dataMaintainer.setRights_group_name(I18nUtil._("资料维护员")); //Store Owner dataMaintainer.setRights_group_name("资料维护员"); // Store Owner
dataMaintainer.setRights_group_rights_data(""); //Store Owner dataMaintainer.setRights_group_rights_data(""); // Store Owner
shopStoreEmployeeRightsGroups.add(dataMaintainer); shopStoreEmployeeRightsGroups.add(dataMaintainer);
ShopStoreEmployeeRightsGroup customerService = new ShopStoreEmployeeRightsGroup(); ShopStoreEmployeeRightsGroup customerService = new ShopStoreEmployeeRightsGroup();
customerService.setStore_id(storeId); customerService.setStore_id(storeId);
customerService.setRights_group_rights_ids(str_rights_group_rights_ids); customerService.setRights_group_rights_ids(strRightsGroupRightsIds);
customerService.setRights_group_name(I18nUtil._("客服")); //Store Owner customerService.setRights_group_name("客服"); // Store Owner
customerService.setRights_group_rights_data(""); //Store Owner customerService.setRights_group_rights_data(""); // Store Owner
shopStoreEmployeeRightsGroups.add(customerService); shopStoreEmployeeRightsGroups.add(customerService);
ShopStoreEmployeeRightsGroup extension1 = new ShopStoreEmployeeRightsGroup(); ShopStoreEmployeeRightsGroup extension1 = new ShopStoreEmployeeRightsGroup();
extension1.setStore_id(storeId); extension1.setStore_id(storeId);
extension1.setRights_group_rights_ids(str_rights_group_rights_ids); extension1.setRights_group_rights_ids(strRightsGroupRightsIds);
extension1.setRights_group_name(I18nUtil._("扩展1")); //Store Owner extension1.setRights_group_name("扩展1"); // Store Owner
extension1.setRights_group_rights_data(""); //Store Owner extension1.setRights_group_rights_data(""); // Store Owner
shopStoreEmployeeRightsGroups.add(extension1); shopStoreEmployeeRightsGroups.add(extension1);
ShopStoreEmployeeRightsGroup extension2 = new ShopStoreEmployeeRightsGroup(); ShopStoreEmployeeRightsGroup extension2 = new ShopStoreEmployeeRightsGroup();
extension2.setStore_id(storeId); extension2.setStore_id(storeId);
extension2.setRights_group_rights_ids(str_rights_group_rights_ids); extension2.setRights_group_rights_ids(strRightsGroupRightsIds);
extension2.setRights_group_name(I18nUtil._("扩展2")); //Store Owner extension2.setRights_group_name("扩展2"); // Store Owner
extension2.setRights_group_rights_data(""); //Store Owner extension2.setRights_group_rights_data(""); // Store Owner
shopStoreEmployeeRightsGroups.add(extension2); shopStoreEmployeeRightsGroups.add(extension2);
if (!shopStoreEmployeeRightsGroupService.saveOrUpdate(shopStoreEmployeeRightsGroups)) { if (!shopStoreEmployeeRightsGroupService.saveOrUpdate(shopStoreEmployeeRightsGroups)) {
if (allowThrown) { String errorMsg = "初始化店铺员工默认权限失败";
if (Boolean.TRUE.equals(allowThrown)) {
throw new ApiException(ResultCode.FAILED); throw new ApiException(ResultCode.FAILED);
} }
log.error("初始化店铺员工默认权限失败"); log.error(errorMsg);
return;
} }
// 添加店铺到用户 // 添加店铺到用户
AccountUserBase accountUserBase = new AccountUserBase(); AccountUserBase accountUserBase = new AccountUserBase();
List<Integer> rights_group_id = shopStoreEmployeeRightsGroups.stream().map(s -> s.getRights_group_id()).collect(Collectors.toList()); List<Integer> rightsGroupId = shopStoreEmployeeRightsGroups.stream()
if (CollUtil.isNotEmpty(rights_group_id)) { .map(ShopStoreEmployeeRightsGroup::getRights_group_id)
.filter(Objects::nonNull)
.collect(Collectors.toList());
if (CollUtil.isNotEmpty(rightsGroupId)) {
// 初始化雇员信息 // 初始化雇员信息
UpdateWrapper<ShopStoreEmployee> queryWrapper = new UpdateWrapper<>(); UpdateWrapper<ShopStoreEmployee> queryWrapper = new UpdateWrapper<>();
queryWrapper.eq("user_id", userId).eq("store_id", storeId) 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_admin", CommonConstant.Enable)
.set("employee_is_kefu", CommonConstant.Enable); .set("employee_is_kefu", CommonConstant.Enable);
if (!shopStoreEmployeeService.update(queryWrapper)) { if (!shopStoreEmployeeService.update(queryWrapper)) {
if (allowThrown) { String errorMsg = "设置店铺管理员权限失败";
throw new ApiException(I18nUtil._("设置店铺管理员权限失败")); 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)); String userRightsGroupId = Convert.toStr(rightsGroupId.get(0));
accountUserBase.setRights_group_id(StrUtil.join(",", user_rights_group_id, 2)); accountUserBase.setRights_group_id(StrUtil.join(",", userRightsGroupId, "2"));
} }
// 用法人、小微个人的手机号注册商家账号，作为店铺的管理员 // 用法人、小微个人的手机号注册商家账号，作为店铺的管理员
accountUserBase.setUser_id(userId); accountUserBase.setUser_id(userId);
// 修复：需要实现 appendStoreIdToAccount 方法或替换为正确的逻辑
String storeIds = appendStoreIdToAccount(userId, storeId); String storeIds = appendStoreIdToAccount(userId, storeId);
accountUserBase.setStore_ids(storeIds); // 重要，给用户添加上这个店铺的归属权 accountUserBase.setStore_ids(storeIds); // 重要，给用户添加上这个店铺的归属权
if (!accountService.saveOrUpdateUserBase(accountUserBase)) { if (!accountService.saveOrUpdateUserBase(accountUserBase)) {
if (allowThrown) { String errorMsg = "店铺关联到用户失败";
throw new ApiException(I18nUtil._("店铺关联到用户失败")); if (Boolean.TRUE.equals(allowThrown)) {
throw new ApiException(errorMsg);
} }
log.error("店铺关联到用户失败！"); log.error(errorMsg);
return;
} }
// 添加默认运输模板 // 添加默认运输模板
ShopStoreTransportType shopStoreTransportType = new ShopStoreTransportType(); ShopStoreTransportType shopStoreTransportType = new ShopStoreTransportType();
shopStoreTransportType.setTransport_type_name(I18nUtil._("通用全免")); // 模板名称 shopStoreTransportType.setTransport_type_name("通用全免"); // 模板名称
shopStoreTransportType.setStore_id(storeId); // 所属店铺 shopStoreTransportType.setStore_id(storeId); // 所属店铺
shopStoreTransportType.setTransport_type_pricing_method(1); // 计费规则(ENUM):1-按件数;2-按重量;3-按体积 shopStoreTransportType.setTransport_type_pricing_method(1); // 计费规则(ENUM):1-按件数;2-按重量;3-按体积
shopStoreTransportType.setTransport_type_time(today); shopStoreTransportType.setTransport_type_time(today);
shopStoreTransportType.setTransport_type_freight_free(BigDecimal.ZERO); // 免运费额度 shopStoreTransportType.setTransport_type_freight_free(BigDecimal.ZERO); // 免运费额度
shopStoreTransportType.setTransport_type_free(1); shopStoreTransportType.setTransport_type_free(1);
if (!shopStoreTransportTypeService.saveOrUpdate(shopStoreTransportType)) { if (!shopStoreTransportTypeService.saveOrUpdate(shopStoreTransportType)) {
if (allowThrown) { String errorMsg = "添加运输模板失败";
throw new ApiException(I18nUtil._("添加运输模板失败")); if (Boolean.TRUE.equals(allowThrown)) {
throw new ApiException(errorMsg);
} }
log.error("添加运输模板失败！"); log.error(errorMsg);
return;
} }
// 店铺配置 // 店铺配置
ShopStoreConfig shopStoreConfig = new ShopStoreConfig(); ShopStoreConfig shopStoreConfig = new ShopStoreConfig();
shopStoreConfig.setStore_id(storeId); shopStoreConfig.setStore_id(storeId);
List<Integer> sc_order_process = Arrays.asList( List<Integer> scOrderProcess = Arrays.asList(
StateCode.ORDER_PROCESS_PAY,//支付 StateCode.ORDER_PROCESS_PAY, // 支付
StateCode.ORDER_PROCESS_OUT, //出库审核 StateCode.ORDER_PROCESS_OUT, // 出库审核
StateCode.ORDER_PROCESS_SHIPPED,//发货确认 StateCode.ORDER_PROCESS_SHIPPED, // 发货确认
StateCode.ORDER_PROCESS_RECEIVED); 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-商家拒绝退货
); );
String str_sc_order_return_process = CollUtil.join(sc_order_return_process, ","); String strScOrderProcess = CollUtil.join(scOrderProcess, ",");
shopStoreConfig.setSc_order_return_process(str_sc_order_return_process); // 退货流程设置(DOT) 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_circle(30);
shopStoreConfig.setSc_settle_last_time(System.currentTimeMillis()); shopStoreConfig.setSc_settle_last_time(System.currentTimeMillis());
shopStoreConfig.setSc_settle_next_time(Convert.toLong(DateUtil.nextMonth())); 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_down(BigDecimal.ZERO);
shopStoreConfig.setSc_festival_amount_upper(BigDecimal.ZERO); shopStoreConfig.setSc_festival_amount_upper(BigDecimal.ZERO);
shopStoreConfig.setSc_festival_float_proportion(BigDecimal.ZERO); shopStoreConfig.setSc_festival_float_proportion(BigDecimal.ZERO);
if (!shopStoreConfigService.saveOrUpdate(shopStoreConfig)) { if (!shopStoreConfigService.saveOrUpdate(shopStoreConfig)) {
if (allowThrown) { String errorMsg = "添加订单流转配置失败";
throw new ApiException(I18nUtil._("添加订单流转配置失败")); if (Boolean.TRUE.equals(allowThrown)) {
throw new ApiException(errorMsg);
} }
log.error("添加订单流转配置失败！"); log.error(errorMsg);
return;
} }
// 添加默认客户等级 // 添加默认客户等级
InvoicingCustomerLevel invoicingCustomerLevel = new InvoicingCustomerLevel(); InvoicingCustomerLevel invoicingCustomerLevel = new InvoicingCustomerLevel();
invoicingCustomerLevel.setCustomer_level_name(I18nUtil._("普通（系统默认，不可删除）")); invoicingCustomerLevel.setCustomer_level_name("普通（系统默认，不可删除）");
invoicingCustomerLevel.setCustomer_level_discountrate(new BigDecimal(100)); invoicingCustomerLevel.setCustomer_level_discountrate(new BigDecimal(100));
invoicingCustomerLevel.setCustomer_level_is_buildin(1); invoicingCustomerLevel.setCustomer_level_is_buildin(1);
invoicingCustomerLevel.setCustomer_level_desc(""); invoicingCustomerLevel.setCustomer_level_desc("");
if (!invoicingCustomerLevelService.saveOrUpdate(invoicingCustomerLevel)) { if (!invoicingCustomerLevelService.saveOrUpdate(invoicingCustomerLevel)) {
if (allowThrown) { String errorMsg = "添加默认客户等级失败";
throw new ApiException(I18nUtil._("添加默认客户等级失败")); 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 userId 用户ID
* @param storeId 要追加的店铺ID * @param storeId 要追加的店铺ID
* @return 追加后的店铺ID字符串（格式：id1,id2,）或空字符串（参数无效/用户不存在） * @return 追加后的店铺ID字符串（格式：id1,id2）或空字符串（参数无效/用户不存在）
* @throws IllegalArgumentException 当参数无效时抛出 * @throws IllegalArgumentException 当参数无效时抛出
*/ */
@Override @Override
public String appendStoreIdToAccount(Integer userId, Integer storeId) { public String appendStoreIdToAccount(Integer userId, Integer storeId) {
// 参数校验 // 参数校验
if (ObjectUtil.isNull(userId) || ObjectUtil.isNull(storeId)) { if (CheckUtil.isEmpty(userId) || CheckUtil.isEmpty(storeId)) {
log.error("用户ID和店铺ID不能为空，userId: {}, storeId: {}", userId, storeId); log.warn("用户ID和店铺ID不能为空，userId: {}, storeId: {}", userId, storeId);
return ""; return "";
} }
@ -4011,16 +4113,20 @@ public class ShopStoreBaseServiceImpl extends BaseServiceImpl<ShopStoreBaseMappe
// 查询用户现有的店铺ID列表 // 查询用户现有的店铺ID列表
AccountUserBase accountUserBase = accountService.getUserBase(userId); AccountUserBase accountUserBase = accountService.getUserBase(userId);
// 用户不存在或没有店铺时返回空 // 用户不存在时返回空字符串
if (accountUserBase == null) { if (accountUserBase == null) {
log.warn("用户不存在，userId: {}", userId);
return ""; return "";
} }
List<String> idList = new ArrayList<>(); List<String> idList = new ArrayList<>();
String storeIds = accountUserBase.getStore_ids(); String storeIds = accountUserBase.getStore_ids();
if (StrUtil.isBlank(storeIds)) { if (StrUtil.isBlank(storeIds)) {
// 用户当前没有店铺ID，直接添加新店铺ID
idList.add(storeId.toString()); idList.add(storeId.toString());
} else { } else {
// 用户已有店铺ID列表，解析并去重
idList = StrUtil.split(storeIds, ","); idList = StrUtil.split(storeIds, ",");
if (!idList.contains(storeId.toString())) { if (!idList.contains(storeId.toString())) {
// 追加新店铺ID // 追加新店铺ID
@ -4028,8 +4134,14 @@ public class ShopStoreBaseServiceImpl extends BaseServiceImpl<ShopStoreBaseMappe
} }
} }
// 返回去重后的店铺ID列表，用逗号连接
return StrUtil.join(",", CollUtil.distinct(idList)); return StrUtil.join(",", CollUtil.distinct(idList));
} catch (ApiException e) {
// 处理特定的API异常
log.error("调用账户服务异常，userId: {}, storeId: {}", userId, storeId, e);
return "";
} catch (Exception e) { } catch (Exception e) {
// 处理其他未预期的异常
log.error("追加店铺ID到用户失败，userId: {}, storeId: {}", userId, storeId, e); log.error("追加店铺ID到用户失败，userId: {}, storeId: {}", userId, storeId, e);
return ""; return "";
} }