b端小程序设备管理费+佣金

device-api-service/src/main/java/com/xy/service/DeviceChargingServiceImpl.java

@@ -13,8 +13,10 @@ import com.xy.collections.map.JMap;
 import com.xy.config.DeviceThreadPoolConfig;
 import com.xy.device.*;
 import com.xy.dto.*;
+import com.xy.dto.be.MercDto;
 import com.xy.entity.*;
 import com.xy.mapper.DeviceChargingMapper;
+import com.xy.service.be.MercService;
 import com.xy.utils.*;
 import io.swagger.annotations.Api;
 import io.swagger.annotations.ApiOperation;
@@ -70,6 +72,8 @@ public class DeviceChargingServiceImpl extends ServiceImpl<DeviceChargingMapper,
 
     private MercFeeConfigService mercFeeConfigService;
 
+    private MercService mercService;
+
     @PostMapping("updateTimeout")
     @ApiOperation("修改过期时间")
     public R updateTimeout(@RequestBody @Validated DeviceChargingDto.UpdateTimeout updateTimeout) {
@@ -103,27 +107,27 @@ public class DeviceChargingServiceImpl extends ServiceImpl<DeviceChargingMapper,
         if (cover.size() > 1) {
             return R.fail("设备类型必须一致");
         }
-        //佣金配置查询
+        // 佣金配置查询
         MercFeeConfigDto.FeeConfigByMercVO mercFeeConfig = R.feignCheckData(mercFeeConfigService.getFeeConfigByMerc(new MercFeeConfigDto.FeeConfigByMerc().setMercCode(list.get(0).getMercCode())));
 
-        //查询设备状态信息
+        // 查询设备状态信息
         List<DeviceStatus> deviceStatuses = deviceStatusService.list(new LambdaQueryWrapper<DeviceStatus>().in(DeviceStatus::getDeviceId, deviceIds));
         JMap<Long, DeviceStatus> deviceStatusesJMaps = new JArrayList<>(deviceStatuses).toMap(DeviceStatus::getDeviceId).cover();
         List<String> mercCodes = new ArrayList<>();
         deviceAlgorithmChargingService.getMercCodes(list.get(0).getMercCode(), mercCodes);
-        //查询设备计费配置表  设备管理费
+        // 查询设备计费配置表  设备管理费
         List<DeviceChargingConfig> deviceChargingConfigs = deviceChargingConfigService.list(new LambdaQueryWrapper<DeviceChargingConfig>()
                 .in(DeviceChargingConfig::getMercCode, mercCodes)
                 .eq(DeviceChargingConfig::getType, SysDictUtils.getValue(EnumDeviceChargingConfigType.Code.CODE.getCode(), EnumDeviceChargingConfigType.N_2.getCode(), Integer.class))
                 .eq(DeviceChargingConfig::getDeviceType, list.get(0).getDeviceType())
                 .orderByDesc(DeviceChargingConfig::getMercCode)
         );
-        //设备管理费
+        // 设备管理费
         int standard = Emptys.check(deviceChargingConfigs) ? (deviceChargingConfigs.get(0).getConfigValue())
                 : SysDictUtils.getValue(EnumDeviceCharging.Code.CODE.getCode(), String.valueOf(list.get(0).getDeviceType()), Integer.class);
         standard = mercFeeConfig.getFeeDevice() + standard;
         String deviceTypeName = SysDictUtils.get(EnumDeviceType.Code.CODE.getCode(), String.valueOf(list.get(0).getDeviceType())).getMsg();
-        //查询算法预充配置  设备激活
+        // 查询算法预充配置  设备激活
         JList<DeviceInfo> values = cover.getValues();
         List<DeviceTypeAlgorithmBeforConfig> deviceTypeAlgorithmBeforConfigs = deviceTypeAlgorithmBeforConfigService.list(new LambdaQueryWrapper<DeviceTypeAlgorithmBeforConfig>()
                 .eq(DeviceTypeAlgorithmBeforConfig::getDeviceType, list.get(0).getDeviceType())
@@ -132,7 +136,7 @@ public class DeviceChargingServiceImpl extends ServiceImpl<DeviceChargingMapper,
         );
         JMap<Long, DeviceTypeAlgorithmBeforConfig> deviceTypeAlgorithmBeforConfigsJMaps = Emptys.check(deviceTypeAlgorithmBeforConfigs) ? new JArrayList<>(deviceTypeAlgorithmBeforConfigs).toMap(DeviceTypeAlgorithmBeforConfig::getAlgorithmId).cover()
                 : new JHashMap<>();
-        //查询默认算法信息
+        // 查询默认算法信息
         JList<Long> algorithmIds = deviceInfos.getProperty(DeviceInfo::getAlgorithmId);
         Map<Long, String> moonAlgorithmTypesMap = new HashMap<>();
         Map<Long, String> algorithmPayConfigMap = new HashMap<>();
@@ -148,31 +152,31 @@ public class DeviceChargingServiceImpl extends ServiceImpl<DeviceChargingMapper,
         }
 
         for (DeviceInfo deviceInfo : list) {
-            //封装设备信息
+            // 封装设备信息
             DeviceChargingDto.PayCheckVo payCheckVo = new DeviceChargingDto.PayCheckVo();
             DeviceStatus deviceStatus = deviceStatusesJMaps.get(deviceInfo.getDeviceId());
             DeviceChargingDto.PayCheckVo.DeviceInfo deviceInfoObj = Beans.copy(Beans.copy(DeviceChargingDto.PayCheckVo.DeviceInfo.class, deviceInfo), deviceStatus)
                     .setDeviceTypeName(deviceTypeName)
                     .setStandard(BigDecimal.valueOf(standard).divide(BigDecimal.valueOf(100), 2, BigDecimal.ROUND_DOWN).doubleValue() + "元/年")
                     .setMoney(standard);
-            //封装算法购买信息
+            // 封装算法购买信息
             DeviceTypeAlgorithmBeforConfig deviceTypeAlgorithmBeforConfig = deviceTypeAlgorithmBeforConfigsJMaps.get(deviceInfo.getAlgorithmId());
             String algorithmName = moonAlgorithmTypesMap.get(deviceInfo.getAlgorithmId());
             String algorithmPayConfig = algorithmPayConfigMap.get(deviceInfo.getAlgorithmId());
             DeviceAlgorithmChargingDto.AlgorithmMoonConfig algorithmMoonConfig = JSONUtil.parseObj(algorithmPayConfig).toBean(DeviceAlgorithmChargingDto.AlgorithmMoonConfig.class);
             DeviceAlgorithmChargingDto.AlgorithmMoonConfig.Inf inf = algorithmMoonConfig.getInf();
 
-            //单笔算法费用 代理商额外收取
+            // 单笔算法费用 代理商额外收取
             int extraSingleMoney = mercFeeConfig.getFeeAlgorithm();
             DeviceChargingDto.PayCheckVo.DeviceAlgorithmCharging infDeviceAlgorithmCharging = Beans.copy(DeviceChargingDto.PayCheckVo.DeviceAlgorithmCharging.class, deviceInfo)
                     .setDeviceTypeName(deviceTypeName)
                     .setAlgorithmId(deviceInfo.getAlgorithmId())
                     .setAlgorithmName(algorithmName)
-                    //算法计费标准
+                    // 算法计费标准
                     .setStandard(BigDecimal.valueOf(algorithmMoonConfig.getPrice() + extraSingleMoney).divide(BigDecimal.valueOf(100), 2, BigDecimal.ROUND_DOWN).doubleValue() + "元/每笔(" + inf.getSize() + "笔)")
-                    //设备激活 代理商费用 deviceTypeAlgorithmBeforConfig.getExtraMoney()
+                    // 设备激活 代理商费用 deviceTypeAlgorithmBeforConfig.getExtraMoney()
                     .setMoney(deviceTypeAlgorithmBeforConfig == null ? inf.getMoney() + mercFeeConfig.getFeeActive() : deviceTypeAlgorithmBeforConfig.getMoney() + mercFeeConfig.getFeeActive());
-            //封装算法包月信息
+            // 封装算法包月信息
             DeviceAlgorithmChargingDto.AlgorithmMoonConfig.Moon moon = algorithmMoonConfig.getMoon();
             DeviceChargingDto.PayCheckVo.DeviceAlgorithmCharging moonDeviceAlgorithmCharging = Beans.copy(DeviceChargingDto.PayCheckVo.DeviceAlgorithmCharging.class, deviceInfo)
                     .setDeviceTypeName(deviceTypeName)
@@ -194,9 +198,9 @@ public class DeviceChargingServiceImpl extends ServiceImpl<DeviceChargingMapper,
     public R check(@RequestBody @Validated DeviceChargingDto.Check check) {
         LocalDateTime now = LocalDateTime.now();
         DeviceCharging deviceCharging = getById(check.getDeviceId());
-        //不存在则新增
+        // 不存在则新增
         if (deviceCharging == null) {
-            //查询设备计费配置表
+            // 查询设备计费配置表
             DeviceInfoDto.Vo deviceInfo = deviceInfoService.obj(new DeviceInfoDto.Obj().setDeviceId(check.getDeviceId())).getData();
             List<String> mercCodes = new ArrayList<>();
             deviceAlgorithmChargingService.getMercCodes(deviceInfo.getMercCode(), mercCodes);
@@ -206,10 +210,10 @@ public class DeviceChargingServiceImpl extends ServiceImpl<DeviceChargingMapper,
                     .eq(DeviceChargingConfig::getDeviceType, deviceInfo.getDeviceType())
                     .orderByDesc(DeviceChargingConfig::getMercCode)
             );
-            //有则使用，无则使用默认字典
+            // 有则使用，无则使用默认字典
             int chargingX = Emptys.check(deviceChargingConfigs) ? deviceChargingConfigs.get(0).getConfigValue()
                     : SysDictUtils.getValue(EnumDeviceCharging.Code.CODE.getCode(), EnumDeviceCharging.N_X.getCode(), Integer.class);
-            //新增
+            // 新增
             String timeout = DataTime.getStringAround(0, 0, chargingX, 0, 0, 0);
             deviceCharging = new DeviceCharging()
                     .setDeviceId(check.getDeviceId())
@@ -217,7 +221,7 @@ public class DeviceChargingServiceImpl extends ServiceImpl<DeviceChargingMapper,
                     .setCreateTime(now);
             save(deviceCharging);
         }
-        //验证过期时间
+        // 验证过期时间
         int contrast = DataTime.stringContrast(DataTime.toString(deviceCharging.getTimeout()), DataTime.toString(now));
         if (contrast <= 0) {
             return R.fail(R.Enum.CHARGING.getCode(), R.Enum.CHARGING.getMsg());
@@ -236,8 +240,14 @@ public class DeviceChargingServiceImpl extends ServiceImpl<DeviceChargingMapper,
         List<DeviceChargingDto.PageVo> records = iPage.getRecords();
         if (Emptys.check(records)) {
             Map<String, SysDictRedis> stringSysDictRedisMap = SysDictUtils.get(EnumDeviceCharging.Code.CODE.getCode());
+            Long mercId = page.getMercId();
+            MercDto.Vo merc = mercService.obj(new MercDto.Vo().setId(mercId)).getData();
+            // 佣金配置查询
+            MercFeeConfigDto.FeeConfigByMercVO mercFeeConfig = R.feignCheckData(mercFeeConfigService.getFeeConfigByMerc(new MercFeeConfigDto.FeeConfigByMerc().setMercCode(merc.getMercCode())));
+            // 设备管理费佣金
+            Integer feeDevice = mercFeeConfig.getFeeDevice();
             for (DeviceChargingDto.PageVo record : records) {
-                //封装过期状态说明
+                // 封装过期状态说明
                 String timeoutStatus;
                 DeviceChargingDto.Vo deviceCharging = record.getDeviceCharging();
                 LocalDateTime timeout = deviceCharging.getTimeout();
@@ -249,21 +259,21 @@ public class DeviceChargingServiceImpl extends ServiceImpl<DeviceChargingMapper,
                 }
                 record.getDeviceCharging().setTimeoutStatus(timeoutStatus);
                 DeviceInfoDto.Vo deviceInfo = record.getDeviceInfo();
-                //查询设备计费配置
+                // 查询设备计费配置
                 DeviceChargingConfigDto.SelectList selectList = new DeviceChargingConfigDto.SelectList()
                         .setDeviceType(deviceInfo.getDeviceType())
                         .setMercId(deviceInfo.getMercId());
                 selectList.setType(prep);
                 List<DeviceChargingConfigDto.Vo> deviceChargingConfigs = deviceChargingConfigService.list2(selectList).getData();
                 if (Emptys.check(deviceChargingConfigs)) {
-                    //获取自定义配置计费标准
+                    // 获取自定义配置计费标准
                     DeviceChargingConfigDto.Vo deviceChargingConfig = deviceChargingConfigs.get(0);
-                    record.setChargingMoney(deviceChargingConfig.getConfigValue());
+                    record.setChargingMoney(deviceChargingConfig.getConfigValue() + feeDevice);
                 } else {
-                    //获取默认计费标准
+                    // 获取默认计费标准
                     SysDictRedis sysDictRedis = stringSysDictRedisMap.get(deviceInfo.getDeviceType().toString());
                     if (sysDictRedis != null) {
-                        record.setChargingMoney(Integer.valueOf(sysDictRedis.getValue()));
+                        record.setChargingMoney(Integer.valueOf(sysDictRedis.getValue()) + feeDevice);
                     }
                 }
             }
@@ -295,7 +305,7 @@ public class DeviceChargingServiceImpl extends ServiceImpl<DeviceChargingMapper,
         if (!Emptys.check(deviceChargingHistories)) {
             return R.fail();
         }
-        //添加设备计费历史表
+        // 添加设备计费历史表
         deviceChargingHistoryService.saveBatch(deviceChargingHistories);
         return R.ok();
     }
@@ -303,7 +313,7 @@ public class DeviceChargingServiceImpl extends ServiceImpl<DeviceChargingMapper,
     @Override
     @ApiOperation("购买回调")
     public R payNotice(DeviceChargingDto.PayNotice payNotice) {
-        //查询设备计费历史表
+        // 查询设备计费历史表
         List<DeviceChargingHistory> list = deviceChargingHistoryService.list(new LambdaQueryWrapper<DeviceChargingHistory>().eq(DeviceChargingHistory::getOrderId, payNotice.getOrderId()));
         if (!Emptys.check(list)) {
             return R.ok();
@@ -311,16 +321,16 @@ public class DeviceChargingServiceImpl extends ServiceImpl<DeviceChargingMapper,
         LocalDateTime now = LocalDateTime.now();
         JList<DeviceChargingHistory> deviceChargingHistories = new JArrayList<>(list);
         int aliDeviceType = SysDictUtils.getValue(EnumDeviceType.Code.CODE.getCode(), EnumDeviceType.N_5.getCode(), Integer.class);
-        //查询设备信息
+        // 查询设备信息
         List<DeviceInfo> deviceInfos = deviceInfoService.list(new LambdaQueryWrapper<DeviceInfo>().in(DeviceInfo::getDeviceId, deviceChargingHistories.getProperty(DeviceChargingHistory::getDeviceId)));
         JMap<Long, DeviceInfo> deviceInfoJMap = new JArrayList<>(deviceInfos).toMap(DeviceInfo::getDeviceId).cover();
-        //查询设备系统信息
+        // 查询设备系统信息
         List<DeviceSysinfoDto.Vo> deviceSysinfos = deviceSysinfoService.list(new DeviceSysinfoDto.SelectList().setDeviceIds(deviceChargingHistories.getProperty(DeviceChargingHistory::getDeviceId))).getData();
         JMap<Long, DeviceSysinfoDto.Vo> deviceSysinfosJMaps = new JArrayList<>(deviceSysinfos).toMap(DeviceSysinfoDto.Vo::getDeviceId).cover();
-        //查询设备计费表
+        // 查询设备计费表
         List<DeviceCharging> deviceChargings = list(new LambdaQueryWrapper<DeviceCharging>().in(DeviceCharging::getDeviceId, deviceChargingHistories.getProperty(DeviceChargingHistory::getDeviceId)));
         JMap<Long, DeviceCharging> deviceChargingsJMaps = new JArrayList<>(deviceChargings).toMap(DeviceCharging::getDeviceId).cover();
-        //获取已支付字典
+        // 获取已支付字典
         Integer status = SysDictUtils.getValue(EnumDeviceChargingHistoryStatus.Code.CODE.getCode(), EnumDeviceChargingHistoryStatus.N_2.getCode(), Integer.class);
         JList<DeviceCharging> updateDeviceCharging = new JArrayList<>();
         JList<DeviceInfoDto.Update> updateDeviceInfos = new JArrayList<>();
@@ -334,21 +344,21 @@ public class DeviceChargingServiceImpl extends ServiceImpl<DeviceChargingMapper,
                     .setLastChargingTime(now);
             Integer chargingSize = deviceChargingHistory.getChargingSize();
             boolean fal = false;
-            //设备计费历史完成
+            // 设备计费历史完成
             deviceChargingHistory.setStatus(status);
             String timeout = DataTime.getStringAround(chargingSize, 0, 0, 0, 0, 0, DataTime.toString(deviceCharging.getTimeout()));
             deviceCharging.setChargingSumMoney(deviceCharging.getChargingSumMoney() + deviceChargingHistory.getChargingMoney())
                     .setTimeout(DataTime.toLocal(timeout));
-            //过期时间大于当前时间
+            // 过期时间大于当前时间
             if (DataTime.stringContrast(timeout, DataTime.toString(now)) > 0) {
                 fal = true;
             }
             if (fal) {
-                //解冻设备
+                // 解冻设备
                 DeviceInfoDto.Update updateDeviceInfo = new DeviceInfoDto.Update()
                         .setDeviceId(deviceChargingHistory.getDeviceId());
                 updateDeviceInfo.setFreezeStatus(1);
-                //激活设备
+                // 激活设备
                 if (deviceChargingHistory.getChargingType() != 100) {
                     if (deviceInfo.getActiveState() == 2) {
                         updateDeviceInfo.setActiveState(1);
@@ -359,14 +369,14 @@ public class DeviceChargingServiceImpl extends ServiceImpl<DeviceChargingMapper,
                 }
                 updateDeviceInfos.add(updateDeviceInfo);
             }
-            //支付宝设备
+            // 支付宝设备
             if (deviceInfo.getDeviceType() == aliDeviceType) {
                 if (deviceChargingHistory.getChargingType() != 100 && deviceInfo.getActiveState() == 2) {
-                    //支付宝绑定
+                    // 支付宝绑定
                     DeviceSysinfoDto.Vo deviceSysinfo = deviceSysinfosJMaps.get(deviceChargingHistory.getDeviceId());
                     BindDeviceDTO bindDeviceDTO = new BindDeviceDTO().setTerminalId(String.valueOf(deviceInfo.getDeviceId()))
                             .setBoardSn(deviceSysinfo.getDeviceSn());
-                    //支付宝激活
+                    // 支付宝激活
                     BindActiveDTO bindActiveDTO = new BindActiveDTO()
                             .setTerminalId(String.valueOf(deviceInfo.getDeviceId()))
                             .setBoardSn(deviceSysinfo.getDeviceSn())
@@ -378,29 +388,29 @@ public class DeviceChargingServiceImpl extends ServiceImpl<DeviceChargingMapper,
             updateDeviceChargingHistory.add(deviceChargingHistory);
         }
         int size = 50;
-        //修改设备计费记录
+        // 修改设备计费记录
         if (Emptys.check(updateDeviceCharging)) {
             JList<JList<DeviceCharging>> partition = updateDeviceCharging.partition(size);
             partition.forEach(data -> updateBatchById(data));
         }
-        //修改设备计费历史记录
+        // 修改设备计费历史记录
         if (Emptys.check(updateDeviceChargingHistory)) {
             JList<JList<DeviceChargingHistory>> partition = updateDeviceChargingHistory.partition(size);
             partition.forEach(data -> deviceChargingHistoryService.updateBatchById(data));
         }
-        //修改设备
+        // 修改设备
         if (Emptys.check(updateDeviceInfos)) {
             JList<JList<DeviceInfoDto.Update>> partition = updateDeviceInfos.partition(size);
             partition.forEach(data -> deviceInfoService.updateBatch(data));
         }
-        //支付宝刷脸柜激活请求
+        // 支付宝刷脸柜激活请求
         log.info("支付宝刷脸柜激活请求参数：{}", ailiActive.toString());
         if (Emptys.check(ailiActive)) {
             ThreadPoolUtils.Execute execute = ThreadPoolUtils.excPoll(DeviceThreadPoolConfig.ALI_DEVICE_ACTIVE, ailiActive.size());
             ailiActive.forEach(bindDeviceDTOBindActiveDTOTuple2 -> execute.execute(() -> {
-                //调用支付宝绑定
+                // 调用支付宝绑定
                 R.feignCheckData(alipayDeviceService.deviceBind(bindDeviceDTOBindActiveDTOTuple2.getV1()));
-                //调用支付宝激活
+                // 调用支付宝激活
                 R.feignCheckData(alipayDeviceService.deviceActive(bindDeviceDTOBindActiveDTOTuple2.getV2()));
             }));
         }