fix:修改商户端证书更换逻辑

alien-entity/src/main/java/shop/alien/entity/storePlatform/StoreLicenseHistory.java

@@ -34,7 +34,7 @@ public class StoreLicenseHistory extends Model<StoreLicenseHistory> {
     @TableField("license_status")
     private Integer licenseStatus;
 
-    @ApiModelProperty(value = "审核状态: 1-审核中, 2-审核拒绝, 3-审核通过")
+    @ApiModelProperty(value = "审核状态: 1-审核通过, 2-审核中, 3-审核拒绝")
     @TableField("license_execute_status")
     private Integer licenseExecuteStatus;
 

alien-store/src/main/java/shop/alien/store/service/impl/LicenseAuditAsyncService.java

@@ -203,22 +203,57 @@ public class LicenseAuditAsyncService {
                     log.info("{}AI审核拒绝，已删除store_img记录，门店ID：{}，图片URL：{}", licenseTypeName, storeId, imageUrl);
                 } else if (needApprove) {
                     // 审核通过：需要检查所有图片是否都审核通过
-                    // 先查询当前记录，获取所有图片URL
+                    // 先查询当前记录，获取所有图片URL（查询状态为2或1的记录，因为第一张图片审核通过后状态会变为1）
                     StoreLicenseHistory currentHistory = licenseHistoryMapper.selectOne(
                             new LambdaQueryWrapper<StoreLicenseHistory>()
                                     .eq(StoreLicenseHistory::getStoreId, storeId)
                                     .eq(StoreLicenseHistory::getLicenseStatus, licenseStatus)
-                                    .eq(StoreLicenseHistory::getLicenseExecuteStatus, 2)
+                                    .in(StoreLicenseHistory::getLicenseExecuteStatus, 1, 2) // 查询状态为1或2的记录
                                     .like(StoreLicenseHistory::getImgUrl, imageUrl)
                                     .eq(StoreLicenseHistory::getDeleteFlag, 0)
+                                    .orderByDesc(StoreLicenseHistory::getCreatedTime) // 按创建时间倒序，获取最新的记录
                                     .last("LIMIT 1")
                     );
                     
                     if (currentHistory != null && StringUtils.isNotEmpty(currentHistory.getImgUrl())) {
-                        // 检查是否所有图片都已审核通过
-                        // 由于是异步审核，每张图片都会调用此方法，所以这里只记录单张图片的审核通过
-                        // 如果需要等所有图片都审核通过才更新状态，需要额外的机制来跟踪
+                        // 如果状态还是2（审核中），更新为1（审核通过）
+                        if (currentHistory.getLicenseExecuteStatus() == 2) {
+                            updateWrapper.set(StoreLicenseHistory::getLicenseExecuteStatus, 1); // 1-审核通过
+                            licenseHistoryMapper.update(null, updateWrapper);
+                        }
                         log.info("{}AI审核通过，门店ID：{}，图片URL：{}", licenseTypeName, storeId, imageUrl);
+                        
+                        // 审核通过后，插入store_img表（检查是否已存在，避免重复插入）
+                        StoreImg existingImg = storeImgMapper.selectOne(
+                                new LambdaQueryWrapper<StoreImg>()
+                                        .eq(StoreImg::getStoreId, storeId)
+                                        .eq(StoreImg::getImgType, 35)
+                                        .eq(StoreImg::getImgUrl, imageUrl)
+                                        .eq(StoreImg::getDeleteFlag, 0)
+                        );
+                        if (existingImg == null) {
+                            // 根据imgUrl在allImgUrls中的位置确定imgSort
+                            String[] allImgUrls = currentHistory.getImgUrl().split(",");
+                            int imgSort = 1;
+                            for (int i = 0; i < allImgUrls.length; i++) {
+                                if (allImgUrls[i].equals(imageUrl)) {
+                                    imgSort = i + 1;
+                                    break;
+                                }
+                            }
+                            
+                            StoreImg storeImg = new StoreImg();
+                            storeImg.setStoreId(storeId);
+                            storeImg.setImgType(35); // 其他资质证明对应35
+                            storeImg.setImgDescription("其他资质证明");
+                            storeImg.setImgSort(imgSort);
+                            storeImg.setImgUrl(imageUrl);
+                            storeImg.setDeleteFlag(0);
+                            storeImgMapper.insert(storeImg);
+                            log.info("其他资质证明审核通过，已插入store_img表，门店ID：{}，图片URL：{}，排序：{}", storeId, imageUrl, imgSort);
+                        } else {
+                            log.info("其他资质证明审核通过，store_img表已存在该记录，门店ID：{}，图片URL：{}", storeId, imageUrl);
+                        }
                     }
                 }
             } else {
@@ -251,6 +286,28 @@ public class LicenseAuditAsyncService {
                     updateWrapper.set(StoreLicenseHistory::getLicenseExecuteStatus, 1); // 1-审核通过
                     licenseHistoryMapper.update(null, updateWrapper);
                     log.info("{}AI审核通过，门店ID：{}，图片URL：{}", licenseTypeName, storeId, imageUrl);
+                    
+                    // 审核通过后，插入store_img表（检查是否已存在，避免重复插入）
+                    StoreImg existingImg = storeImgMapper.selectOne(
+                            new LambdaQueryWrapper<StoreImg>()
+                                    .eq(StoreImg::getStoreId, storeId)
+                                    .eq(StoreImg::getImgType, 14)
+                                    .eq(StoreImg::getImgUrl, imageUrl)
+                                    .eq(StoreImg::getDeleteFlag, 0)
+                    );
+                    if (existingImg == null) {
+                        StoreImg storeImg = new StoreImg();
+                        storeImg.setStoreId(storeId);
+                        storeImg.setImgType(14); // 营业执照对应14
+                        storeImg.setImgDescription("营业执照");
+                        storeImg.setImgSort(0);
+                        storeImg.setImgUrl(imageUrl);
+                        storeImg.setDeleteFlag(0);
+                        storeImgMapper.insert(storeImg);
+                        log.info("营业执照审核通过，已插入store_img表，门店ID：{}，图片URL：{}", storeId, imageUrl);
+                    } else {
+                        log.info("营业执照审核通过，store_img表已存在该记录，门店ID：{}，图片URL：{}", storeId, imageUrl);
+                    }
                 }
             }
         } catch (Exception e) {

alien-store/src/main/java/shop/alien/store/service/impl/StoreInfoServiceImpl.java

@@ -5636,18 +5636,20 @@ public class StoreInfoServiceImpl extends ServiceImpl<StoreInfoMapper, StoreInfo
         Integer totalCount = 0;
         double storeScore;
         Object ratingObj =  commonRatingService.getRatingCount(storeInfo.getId(), 1);
-        if (ratingObj != null) {
+        if (ratingObj != null && ratingObj instanceof Map) {
             Map<String, Object> ratingMap = (Map<String, Object>) ratingObj;
-            Object totalCountObj = ratingMap.get("totalCount");
-            if (totalCountObj != null) {
-                // 安全转换为整数
-                try {
-                    totalCount = Integer.parseInt(totalCountObj.toString().trim());
-                } catch (NumberFormatException e) {
-                    totalCount = 0; // 转换失败时默认值
+
+            // 校验外层状态（success、code）
+            Boolean isSuccess = (Boolean) ratingMap.get("success");
+            Integer code = (Integer) ratingMap.get("code");
+            if (isSuccess != null && isSuccess && code != null && code == 200) {
+                // 提取核心数据层data
+                Map<String, Object> dataMap = (Map<String, Object>) ratingMap.get("data");
+                if (dataMap != null) {
+                    // 解析各字段（非空校验+类型转换）
+                    storeScore = dataMap.get("storeScore") != null ? Double.parseDouble(dataMap.get("storeScore").toString()) : 0.0;
+                    totalCount = dataMap.get("totalCount") != null ? Integer.parseInt(dataMap.get("totalCount").toString()) : 0;
                 }
-            } else {
-                totalCount = 0;
             }
         }
 
@@ -5861,27 +5863,19 @@ public class StoreInfoServiceImpl extends ServiceImpl<StoreInfoMapper, StoreInfo
                             );
 
                             boolean isInBusiness;
-                            // 判断是否是全天营业（00:00到00:00）
-                            LocalTime midnight = LocalTime.of(0, 0);
-                            if (start.equals(midnight) && end.equals(midnight)) {
-                                // 全天营业
-                                isInBusiness = true;
-                                log.info("特殊日期营业时间判断 - 全天营业（00:00-00:00），当前时间: {}，是否在营业时间内: true", currentTime);
+                            // 处理跨天营业
+                            if (start.isBefore(end) || start.equals(end)) {
+                                // 同一天营业：包含边界值
+                                isInBusiness = (currentTime.isAfter(start) || currentTime.equals(start))
+                                        && (currentTime.isBefore(end) || currentTime.equals(end));
                             } else {
-                                // 处理跨天营业
-                                if (start.isBefore(end) || start.equals(end)) {
-                                    // 同一天营业：包含边界值
-                                    isInBusiness = (currentTime.isAfter(start) || currentTime.equals(start))
-                                            && (currentTime.isBefore(end) || currentTime.equals(end));
-                                } else {
-                                    // 跨天营业：包含边界值
-                                    isInBusiness = (currentTime.isAfter(start) || currentTime.equals(start))
-                                            || (currentTime.isBefore(end) || currentTime.equals(end));
-                                }
-                                log.info("特殊日期营业时间判断 - 开始时间: {}, 结束时间: {}, 当前时间: {}, 是否在营业时间内: {}",
-                                        start, end, currentTime, isInBusiness);
+                                // 跨天营业：包含边界值
+                                isInBusiness = (currentTime.isAfter(start) || currentTime.equals(start))
+                                        || (currentTime.isBefore(end) || currentTime.equals(end));
                             }
 
+                            log.info("特殊日期营业时间判断 - 开始时间: {}, 结束时间: {}, 当前时间: {}, 是否在营业时间内: {}",
+                                    start, end, currentTime, isInBusiness);
                             result.setYyFlag(isInBusiness ? 1 : 0);
                             isCurrentSpecialBusinessTime = isInBusiness;
                         } else {
@@ -5948,27 +5942,19 @@ public class StoreInfoServiceImpl extends ServiceImpl<StoreInfoMapper, StoreInfo
                                     );
 
                                     boolean isInBusiness;
-                                    // 判断是否是全天营业（00:00到00:00）
-                                    LocalTime midnight = LocalTime.of(0, 0);
-                                    if (start.equals(midnight) && end.equals(midnight)) {
-                                        // 全天营业
-                                        isInBusiness = true;
-                                        log.info("正常营业时间判断 - 全天营业（00:00-00:00），当前时间: {}，是否在营业时间内: true", currentTime);
+                                    // 处理跨天营业
+                                    if (start.isBefore(end) || start.equals(end)) {
+                                        // 同一天营业：包含边界值
+                                        isInBusiness = (currentTime.isAfter(start) || currentTime.equals(start))
+                                                && (currentTime.isBefore(end) || currentTime.equals(end));
                                     } else {
-                                        // 处理跨天营业
-                                        if (start.isBefore(end) || start.equals(end)) {
-                                            // 同一天营业：包含边界值
-                                            isInBusiness = (currentTime.isAfter(start) || currentTime.equals(start))
-                                                    && (currentTime.isBefore(end) || currentTime.equals(end));
-                                        } else {
-                                            // 跨天营业：包含边界值
-                                            isInBusiness = (currentTime.isAfter(start) || currentTime.equals(start))
-                                                    || (currentTime.isBefore(end) || currentTime.equals(end));
-                                        }
-                                        log.info("正常营业时间判断 - 开始时间: {}, 结束时间: {}, 当前时间: {}, 是否在营业时间内: {}",
-                                                start, end, currentTime, isInBusiness);
+                                        // 跨天营业：包含边界值
+                                        isInBusiness = (currentTime.isAfter(start) || currentTime.equals(start))
+                                                || (currentTime.isBefore(end) || currentTime.equals(end));
                                     }
 
+                                    log.info("正常营业时间判断 - 开始时间: {}, 结束时间: {}, 当前时间: {}, 是否在营业时间内: {}",
+                                            start, end, currentTime, isInBusiness);
                                     result.setYyFlag(isInBusiness ? 1 : 0);
                                 } else {
                                     log.warn("正常营业时间格式错误 - 开始时间: {}, 结束时间: {}",
@@ -6401,13 +6387,7 @@ public class StoreInfoServiceImpl extends ServiceImpl<StoreInfoMapper, StoreInfo
                 .set(StoreImg::getDeleteFlag, 1);
         storeImgMapper.update(null, deleteWrapper);
         
-        // 插入新的营业执照图片
-        storeImg.setImgType(14);
-        storeImg.setImgDescription("营业执照");
-        storeImg.setImgSort(0);
-        storeImg.setDeleteFlag(0);
-        storeImgMapper.insert(storeImg);
-        
+        // 不再立即插入新的营业执照图片，等审核通过后再插入
         // 插入营业执照历史记录（licenseStatus=1表示营业执照，licenseExecuteStatus=2表示审核中）
         StoreLicenseHistory licenseHistory = new StoreLicenseHistory();
         licenseHistory.setStoreId(storeImg.getStoreId());
@@ -6422,7 +6402,7 @@ public class StoreInfoServiceImpl extends ServiceImpl<StoreInfoMapper, StoreInfo
         storeInfo.setId(storeImg.getStoreId());
         storeInfo.setBusinessLicenseStatus(2); // 2-待审核
         storeInfo.setUpdateBusinessLicenseTime(new Date());
-        
+
         storeInfoMapper.updateById(storeInfo);
         
         // 异步调用证照审核AI接口并处理审核结果
@@ -6503,18 +6483,11 @@ public class StoreInfoServiceImpl extends ServiceImpl<StoreInfoMapper, StoreInfo
         
         // 收集所有图片URL
         List<String> imgUrlList = new ArrayList<>();
-        
-        // 插入新的其他资质证明图片（最多9张）
+
+        // 不再立即插入新的其他资质证明图片，等审核通过后再插入
+        // 收集图片URL
         for (int i = 0; i < maxCount; i++) {
             StoreImg storeImg = storeImgList.get(i);
-            storeImg.setStoreId(storeId);
-            storeImg.setImgType(35); // 其他资质证明图片
-            storeImg.setImgDescription("其他资质证明");
-            storeImg.setImgSort(i + 1);
-            storeImg.setDeleteFlag(0);
-            storeImgMapper.insert(storeImg);
-            
-            // 收集图片URL
             if (StringUtils.isNotEmpty(storeImg.getImgUrl())) {
                 imgUrlList.add(storeImg.getImgUrl());
             }