最新版本541200007

doum

昨天 5ffe34a87c27f73bc92b2ac0c58e6894ec61792b

 server/visits/dmvisit_service/src/main/java/com/doumee/service/business/impl/PlatformJobServiceImpl.java

@@ -12,6 +12,8 @@
import com.doumee.core.haikang.model.param.respose.ParkReservationAddResponse;
import com.doumee.core.haikang.service.HKService;
import com.doumee.dao.business.dao.UserActionMapper;
import com.doumee.dao.system.model.SystemDictData;
import com.doumee.service.business.third.WmsService;
import com.doumee.service.business.third.model.LoginUserInfo;
import com.doumee.service.business.third.model.PageData;
import com.doumee.service.business.third.model.PageWrap;
@@ -247,7 +249,7 @@
                .selectAs(PlatformBooks::getId,PlatformJob::getBookId)
                .select("s.REALNAME",PlatformJob::getEditUserName)
                .leftJoin(Platform.class,Platform::getId,PlatformJob::getPlatformId)
                .leftJoin(PlatformGroup.class,PlatformGroup::getId,Platform::getGroupId)
                .leftJoin(PlatformGroup.class,PlatformGroup::getId,PlatformJob::getPlatformGroupId)
                .leftJoin(PlatformWmsJob.class,PlatformWmsJob::getCarryBillCode,PlatformJob::getBillCode)
                .leftJoin(SystemUser.class,SystemUser::getId,PlatformJob::getOutUserId)
                .leftJoin(PlatformBooks.class,PlatformBooks::getJobId,PlatformJob::getId)
@@ -407,7 +409,7 @@
                                .apply(" ( t.status = "+Constants.PlatformJobStatus.TRANSFERING.getKey()+" and t.PLATFORM_GROUP_ID = "+pageWrap.getModel().getPlatformGroupId()+" ) ")
                )
//                .like(PlatformJob::getArriveDate,DateUtil.dateTypeToString(new Date(),"yyyy-MM-dd"))
                .orderByDesc(PlatformJob::getStatus)
                .orderByDesc(PlatformJob::getStatus,PlatformJob::getUrgeTime)
                .orderByAsc(PlatformJob::getSignDate)
        ;
        IPage<PlatformJob> platformJobIPage = platformJobJoinMapper.selectJoinPage(page,PlatformJob.class,queryWrapper);
@@ -694,10 +696,10 @@
        savePlatformLog(Constants.PlatformJobLogType.SIGN.getKey(),oldPlatformJob,platformJob,
                Constants.PlatformJobLogType.SIGN.getInfo());
        //签到微信通知 2025年3月26日14:25:00
        logger.info("签到微信通知=========================>开始====签到类型=>"+signInDTO.getSignType()+"===>人员主键=>"+platformGroup.getSignInNoticeUsers());
        log.info("签到微信通知=========================>开始====签到类型=>"+signInDTO.getSignType()+"===>人员主键=>"+platformGroup.getSignInNoticeUsers());
        if(!Constants.equalsInteger(signInDTO.getSignType(),Constants.TWO)&&
                StringUtils.isNotBlank(platformGroup.getSignInNoticeUsers())){
            logger.info("签到微信通知=========================>进入");
            log.info("签到微信通知=========================>进入");
            List<SystemUser> systemUserList = systemUserMapper.selectList(new QueryWrapper<SystemUser>().lambda()
                    .eq(SystemUser::getDeleted,Constants.ZERO).eq(SystemUser::getStatus,Constants.ZERO).isNotNull(SystemUser::getOpenid)
                    .in(SystemUser::getMemberId,Arrays.asList(platformGroup.getSignInNoticeUsers().split(",")))
@@ -710,7 +712,7 @@
                );
            }
        }
        logger.info("签到微信通知=========================>结束");
        log.info("签到微信通知=========================>结束");
    }


@@ -984,7 +986,7 @@
        BeanUtils.copyProperties(platformJob,oldPlatformJob);
        platformJob.setPlatformId(platform.getId());
        platformJob.setInwaitDate(new Date());
        platformJob.setInwaitUserId(jobOperateDTO.getLoginUserInfo().getId());
        platformJob.setInwaitUserId(Objects.isNull(jobOperateDTO.getLoginUserInfo())?null:jobOperateDTO.getLoginUserInfo().getId());
        platformJob.setStatus(Constants.PlatformJobStatus.IN_WAIT.getKey());
        platformJob.setEditDate(new Date());
        platformJobMapper.updateById(platformJob);
@@ -998,11 +1000,40 @@
                emayService,smsEmailMapper,smsConfigMapper,platformJobMapper,platformJob.getId(),
                SmsConstants.platformJobContent.platformJobCallIn,null,null
        );
        

        //公众号模板消息
        if(Objects.nonNull(platformJob.getDrivierPhone())) {
          this.sendWxNotice(WxPlatConstants.platformJobContent.platformJobCallIn,platformJob);
            this.sendWxNotice(WxPlatConstants.platformJobContent.platformJobCallIn,platformJob);
        }
        return platformJob;
    }
    public PlatformJob platformInParkBiz(PlatformJob platformJob,  Platform platform ){
        platformJob.setPlatformId(platform.getId());
        platformJob.setPlatformName(platform.getName());
        //判断是否需要填充进去
        if(StringUtils.isBlank(platformJob.getPlatforms())){
            platformJob.setPlatforms(platform.getId().toString());
            platformJob.setPlatformNames(platform.getName());
        }else{
            if(!Constants.equalsInteger(platform.getId(),platformJob.getPlatformId())){
                platformJob.setPlatforms(platformJob.getPlatforms() + "," +platformJob.getPlatformId().toString());
                platformJob.setPlatformNames(platformJob.getPlatformNames() + "," +platform.getName());
            }
        }

        PlatformJob oldPlatformJob = new PlatformJob();
        BeanUtils.copyProperties(platformJob,oldPlatformJob);
        platformJob.setPlatformId(platform.getId());
        platformJob.setInwaitDate(new Date());
        platformJob.setStatus(Constants.PlatformJobStatus.IN_WAIT.getKey());
        platformJob.setEditDate(new Date());
        platformJobMapper.updateById(platformJob);

        //存储操作日志
        savePlatformLog(Constants.PlatformJobLogType.IN_WAIT.getKey(),oldPlatformJob,platformJob,
                Constants.PlatformJobLogType.IN_WAIT.getInfo());


        return platformJob;
    }

@@ -1034,7 +1065,6 @@



    private Logger logger = LoggerFactory.getLogger(PlatformJobServiceImpl.class);

    @Override
    public void sendInPark(PlatformJob platformJob){
@@ -1206,7 +1236,7 @@
        ) ){
            throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"对不起,业务状态已流转！");
        }
        

        Platform platform = platformJoinMapper.selectById(jobOperateDTO.getPlatformId());
        if(Objects.isNull(platform)){
            throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(),"未查询到月台信息");
@@ -1225,7 +1255,8 @@
        BeanUtils.copyProperties(platformJob,oldPlatformJob);

        platformJob.setCallDate(Objects.isNull(platformJob.getCallDate())?new Date():null);
        platformJob.setCallUserId(jobOperateDTO.getLoginUserInfo().getId());
        platformJob.setCallWay(0);
        platformJob.setCallUserId(Objects.isNull(jobOperateDTO.getLoginUserInfo())?null:jobOperateDTO.getLoginUserInfo().getId());
        platformJob.setStatus(Constants.PlatformJobStatus.CALLED.getKey());
        platformJob.setPlatformId(jobOperateDTO.getPlatformId());
        //判断是否需要填充进去
@@ -1264,6 +1295,34 @@
                Constants.PlatformBroadcastContent.CALLING.getInfo()+ Constants.PlatformBroadcastContent.CALLING.getInfo() + Constants.PlatformBroadcastContent.CALLING.getInfo()
        );

        platformJob.setPlatformWmsCode(platform.getCode());
        return platformJob;
    }
    public PlatformJob platformCallNumberBiz( PlatformJob platformJob ,Platform platform ){
        platformJob.setPlatformId(platform.getId());
        PlatformJob oldPlatformJob = new PlatformJob();
        BeanUtils.copyProperties(platformJob,oldPlatformJob);
        platformJob.setCallDate(Objects.isNull(platformJob.getCallDate())?new Date():null);
        platformJob.setCallWay(Constants.ONE);
        platformJob.setStatus(Constants.PlatformJobStatus.CALLED.getKey());
        platformJob.setPlatformId(platform.getId());
        //判断是否需要填充进去
        if(StringUtils.isBlank(platformJob.getPlatforms())){
            platformJob.setPlatforms(platform.getId().toString());
            platformJob.setPlatformNames(platform.getName());
        }else{
            if(!Constants.equalsInteger(platform.getId(),platformJob.getPlatformId())){
                platformJob.setPlatforms(platformJob.getPlatforms() + "," +platform.getId().toString());
                platformJob.setPlatformNames(platformJob.getPlatformNames() + "," +platform.getName());
            }
        }
        platformJob.setEditDate(new Date());
        platformJobMapper.updateById(platformJob);

        //存储操作日志
        savePlatformLog(Constants.PlatformJobLogType.CALLED.getKey(),oldPlatformJob,platformJob,
                Constants.PlatformJobLogType.CALLED.getInfo().replace("{data}",platform.getName()));
        platformJob.setPlatformName(platform.getName());
        platformJob.setPlatformWmsCode(platform.getCode());
        return platformJob;
    }
@@ -1376,7 +1435,6 @@
        platformJob.setEditDate(new Date());
        platformJobMapper.updateById(platformJob);

        //TODO 调起WMS 通知月台转移
        //存储操作日志
        savePlatformLog(Constants.PlatformJobLogType.TRANSFERING.getKey(),oldPlatformJob,platformJob,
                Constants.PlatformJobLogType.TRANSFERING.getInfo().replace("{data}",oldPlatform.getName()));
@@ -1709,7 +1767,7 @@
                               jobIds.add(job.getJobId());
                           }
                       }catch (Exception e){
                           logger.error("=============更新电子锁状态信息异常："+e.getMessage());
                           log.error("=============更新电子锁状态信息异常："+e.getMessage());
                       }
                   }
               }
@@ -2447,6 +2505,73 @@


    /**
     * 更换月台分钟
     * @param param
     */
    @Override
    public void changPlatformGroup(PlatformJob param, LoginUserInfo loginUser){
        if(param.getId() ==null || param.getPlatformGroupId()==null) {
            throw  new BusinessException(ResponseStatus.BAD_REQUEST);
        }
        PlatformJob model  = platformJobMapper.selectById(param.getId());
        if(model ==null || Constants.equalsInteger(model.getIsdeleted(),Constants.ONE)){
            throw  new BusinessException(ResponseStatus.DATA_EMPTY);
        }
        if(Constants.equalsInteger(model.getType(),Constants.platformJobType.sgscxh)){
            throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(),"【市公司外协车卸货】作业类型不支持月台组切换");
        }
        //   WAIT_CONFIRM(0, "待确认","待确认" ),
        //        WART_SIGN_IN(1, "待签到","待签到" ),
        //        WAIT_CALL(2, "已签到","已签到"),
        if(!Constants.equalsInteger(model.getStatus(),Constants.PlatformJobStatus.WAIT_CONFIRM.getKey())
                &&!Constants.equalsInteger(model.getStatus(),Constants.PlatformJobStatus.WART_SIGN_IN.getKey())
                &&!Constants.equalsInteger(model.getStatus(),Constants.PlatformJobStatus.WAIT_CALL.getKey())){
            throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"对不起,业务状态已流转，不支持月台组切换！");
        }
        PlatformGroup group = platformGroupMapper.selectById(param.getPlatformGroupId());
        if(Objects.isNull(group)|| Constants.equalsInteger(group.getIsdeleted(),Constants.ONE)){
            throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(),"未查询到月台组信息");
        }
        if(Constants.equalsInteger(model.getType(),Constants.platformJobType.zycxh)
                ||Constants.equalsInteger(model.getType(),Constants.platformJobType.wxcxh)){
            if( ! Constants.equalsInteger(group.getType(),Constants.ZERO)){
                throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"该作业只能在【安泰物流卸货】类型的月台组下作业");
            }
        }
        if(Constants.equalsInteger(model.getType(),Constants.platformJobType.zyczh)
                ||Constants.equalsInteger(model.getType(),Constants.platformJobType.wxczh)){
            if( ! Constants.equalsInteger(group.getType(),Constants.ONE)){
                throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"该作业只能在【安泰物流装货】类型的月台组下作业");
            }
        }
        if(Constants.equalsInteger(model.getType(),Constants.platformJobType.sgscxh)
                && !Constants.equalsInteger(group.getType(),Constants.TWO)){
                throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"该作业只能在【市公司卸货】类型的月台组下作业");
        }
        PlatformJob platformJob = new PlatformJob();
        BeanUtils.copyProperties(model,platformJob);
        platformJob.setPlatformGroupId(param.getPlatformGroupId());
        platformJob.setEditDate(new Date());
        platformJob.setTagVirtual(Constants.ONE);
        platformJob.setTagVirtualUser(platformJob.getEditor());
        platformJob.setTagVirtualTime(platformJob.getEditDate());
        platformJob.setEditor(loginUser.getId());
       int flag =  platformJobMapper.update(null,new UpdateWrapper<PlatformJob>().lambda()
                .set(PlatformJob::getEditDate,platformJob.getEditDate())
                .set(PlatformJob::getTagVirtualTime,platformJob.getTagVirtualTime())
                .set(PlatformJob::getEditor,platformJob.getEditor())
                .set(PlatformJob::getPlatformGroupId,param.getPlatformGroupId())
                .set(PlatformJob::getTagVirtualUser,platformJob.getEditor())
                .set(PlatformJob::getPlatformId,null)//置空分配的月台信息
                .in(PlatformJob::getStatus,Constants.PlatformJobStatus.WAIT_CONFIRM.getKey(),
                        Constants.PlatformJobStatus.WART_SIGN_IN.getKey(),
                        Constants.PlatformJobStatus.WAIT_CALL.getKey())
                .eq(PlatformJob::getId,param.getId()));
        //存储操作日志
        savePlatformLog(Constants.PlatformJobLogType.CHANGE_GROUP.getKey(),model,platformJob,
                Constants.PlatformJobLogType.CHANGE_GROUP.getInfo().replace("{data}",param.getPlatformGroupName()).replace("{data1}",group.getName()));
    }
    /**
     * 手动完成作业
     * @param jobIdList
     */
@@ -2508,4 +2633,404 @@
        return platformJob;
    }

    @Override
    @Transactional
    public void autoPlatformCallCar(WmsService wmsService){
        //查询当前开启的月台数据
        List<PlatformGroup> allPlatformGroup = platformGroupMapper.selectList(new QueryWrapper<PlatformGroup>().lambda().eq(PlatformGroup::getStatus,Constants.ZERO)
                .eq(PlatformGroup::getIsdeleted,Constants.ZERO).eq(PlatformGroup::getAutoCall,Constants.ONE)
        );
        if(com.github.xiaoymin.knife4j.core.util.CollectionUtils.isEmpty(allPlatformGroup)){
            log.error("========月台自动叫号============结束：无自动叫号月台组");
            return;
        }
        //过滤当前时间段不在时间内的月台组  AUTO_CALL_END_TIME AUTO_CALL_START_TIME
        Integer nowHm = Integer.valueOf(DateUtil.getFomartDate(new Date(),"HH:mm").replaceAll(":",""));
        List<PlatformGroup> autoCallGroup = allPlatformGroup.stream().filter(
                i->StringUtils.isNotBlank(i.getAutoCallStartTime())&&StringUtils.isNotBlank(i.getAutoCallEndTime())
                && Integer.valueOf(i.getAutoCallStartTime().replaceAll(":","")) < nowHm
                && Integer.valueOf(i.getAutoCallEndTime().replaceAll(":","")) > nowHm
        ).collect(Collectors.toList());
        if(com.github.xiaoymin.knife4j.core.util.CollectionUtils.isEmpty(autoCallGroup)){
            log.error("========月台自动叫号============结束：无工作时间内 自动叫号月台组");
            return;
        }
        //查询所有月台
        List<Platform> platformList = platformJoinMapper.selectList(new QueryWrapper<Platform>()
                .lambda()
                .eq(Platform::getIsdeleted,Constants.ZERO)
                .eq(Platform::getStatus,Constants.ZERO)
                .isNotNull(Platform::getWorkingNum)
                .in(Platform::getGroupId,autoCallGroup.stream().map(i->i.getId()).collect(Collectors.toList()))
        );
        if(com.github.xiaoymin.knife4j.core.util.CollectionUtils.isEmpty(platformList)){
            log.error("========月台自动叫号============结束：无自动叫号月台");
            return;
        }

        List<PlatformJob> noticeList = new ArrayList<>();
        //循环所有自动叫号月台
        for (PlatformGroup platformGroup:autoCallGroup) {
            List<Platform> platforms = platformList.stream().filter(i->Constants.equalsInteger(i.getGroupId(),platformGroup.getId())).collect(Collectors.toList());
            if(CollectionUtils.isEmpty(platforms)){
                log.error("========月台自动叫号============结束：无自动叫号月台-"+platformGroup.getName());
                continue;
            }
            log.error("========月台自动叫号============有自动叫号月台--"+platformGroup.getName());
            Boolean isDefaul = false;
            if(Constants.equalsInteger(platforms.size(),Constants.ONE)){
                isDefaul = true;
            }else{
                int t1 =0,t0=0;
                //查询月台组下的月台是否同时存在整托和散托月台
                for(Platform i : platforms){
                    if(Constants.equalsInteger(i.getType(),Constants.ONE)){
                        t1 ++;
                    }else{
                        t0 ++;
                    }
                }
                if(t1 == 0 ||  t0 ==0){
                    isDefaul = true;
                }
            }


            for (Platform platform:platforms) {
                log.error("========月台自动叫号============开始处理找月台作业--"+platform.getName());
                //月台 叫号入园数量
                Integer workingNum = Constants.formatIntegerNum(platform.getWorkingNum());
                //查询当前月台是否存在月台叫号数据 如果大于等于可叫号数量 则跳过
                Integer workNum = platformJobJoinMapper.selectCount(new QueryWrapper<PlatformJob>().lambda()
                        .eq(PlatformJob::getIsdeleted,Constants.ZERO)
                        .eq(PlatformJob::getPlatformId,platform.getId())
                        .eq(PlatformJob::getStatus,Constants.PlatformJobStatus.CALLED.getKey())).intValue();
                if(workNum>=workingNum){
                    log.error("========月台自动叫号============结束：超过自动叫号作业限制-"+platform.getName());
                    continue;
                };

                //查询月台下 可以进行叫号的数据
                List<PlatformJob> platformJobList = platformJobJoinMapper.selectList(new QueryWrapper<PlatformJob>()
                                .lambda()
                        .eq(PlatformJob::getIsdeleted,Constants.ZERO)
                        .eq(PlatformJob::getPlatformGroupId, platformGroup.getId())
                        .apply(" ( " +
                                " (  `STATUS` = "+Constants.PlatformJobStatus.WAIT_CALL.getKey()+" and PLATFORM_GROUP_ID = "+platformGroup.getId()+"  )" +
                                " or  " +
                                " ( `STATUS` = "+Constants.PlatformJobStatus.IN_WAIT.getKey()+" and  PLATFORM_ID = "+platform.getId()+" )  " +
                                " or " +
                                "  ( `STATUS` = "+Constants.PlatformJobStatus.TRANSFERING.getKey()+" and PLATFORM_ID = "+platform.getId()+" )  " +
                                ") "
                        )
                        //排序方式 月台作业类型 （转移中 >叫号入园）>  加急 >  签到时间
                        .orderByDesc(PlatformJob::getStatus,PlatformJob::getUrgeTime)
                        .orderByAsc(PlatformJob::getSignDate));
                if(CollectionUtils.isEmpty(platformJobList)){
                    log.error("========月台自动叫号============结束：无满足条件的集合1-"+platform.getName());
                    continue;
                }
                log.error("========月台自动叫号============有满足条件的作业集合--"+platform.getName());
                for (int i = 0; i < workingNum - workNum && platformJobList.size()>0; i++) {
                    if(platformJobList== null || platformJobList.size() ==0){
                        break;
                    }
                    PlatformJob platformJob  = this.getAutoCallJob(platformJobList,platform,isDefaul,platformGroup);
                    if(Objects.isNull(platformJob)){
                        log.error("========月台自动叫号============结束：无满足条件的作业2-"+platform.getName());
                        break;
                    }
                    PlatformJob callPlatformJob = this.platformCallNumberBiz(platformJob,platform);
                    noticeList.add(callPlatformJob );
                    List<PlatformJob> newList = new ArrayList<>();
                    for(PlatformJob j :platformJobList ){
                        if(!Constants.equalsInteger(j.getId(),platformJob.getId())){
                            newList.add(j);
                        }
                    }
                    platformJobList = newList;
//                    platformJobList = platformJobList.stream().filter(j->!Constants.equalsInteger(j.getId(),platformJob.getId())).collect(Collectors.toList());
                }
            }
        }
        if(noticeList.size()>0){
            for(PlatformJob platformJob : noticeList){
                //发送短信信息
                SmsEmailServiceImpl.sendPlatformJobSms(systemDictDataBiz,
                        emayService,smsEmailMapper,smsConfigMapper,platformJobMapper,platformJob.getId(),
                        SmsConstants.platformJobContent.platformJobSingIn,platformJob.getPlatformName(),null
                );

                //公众号模板消息
                if(Objects.nonNull(platformJob.getDrivierPhone())){
                    this.sendWxNotice(WxPlatConstants.platformJobContent.platformJobSingIn,platformJob);
                }
                //广播 led通知
                platformJob.setPlatformName(platformJob.getPlatformName());
                this.broadcastAndLEed(platformJob,Constants.PlatformLedContent.CALLING.getInfo(),
                        Constants.PlatformBroadcastContent.CALLING.getInfo()+ Constants.PlatformBroadcastContent.CALLING.getInfo() + Constants.PlatformBroadcastContent.CALLING.getInfo()
                );
                try{
                    this.sendInPark(platformJob);
                    if(!Constants.equalsInteger(platformJob.getType(),Constants.FOUR)
                            && StringUtils.isNotBlank(platformJob.getBillCode())){
                        //通知WMS绑定月台信息
                        wmsService.orderPlatformBind(platformJob);
                    }
                }catch (Exception e){
                    log.error("月台自动叫号权限下发失败：{}"+JSONObject.toJSONString(platformJob));
                }

            }
        }
    }



    @Override
    @Transactional
    public void autoCallInParkCar(WmsService wmsService){
        //查询当前开启的月台数据
        List<PlatformGroup> allPlatformGroup = platformGroupMapper.selectList(new QueryWrapper<PlatformGroup>().lambda().eq(PlatformGroup::getStatus,Constants.ZERO)
                .eq(PlatformGroup::getIsdeleted,Constants.ZERO).eq(PlatformGroup::getAutoCall,Constants.ONE)
        );
        if(com.github.xiaoymin.knife4j.core.util.CollectionUtils.isEmpty(allPlatformGroup)){
            return;
        }
        //过滤当前时间段不在时间内的月台组  AUTO_CALL_END_TIME  AUTO_CALL_START_TIME
        Integer nowHm = Integer.valueOf(DateUtil.getFomartDate(new Date(),"HH:mm").replaceAll(":",""));
        List<PlatformGroup> autoCallGroup = allPlatformGroup.stream().filter(
                i->StringUtils.isNotBlank(i.getAutoCallStartTime())&&StringUtils.isNotBlank(i.getAutoCallEndTime())
                        && Integer.valueOf(i.getAutoCallStartTime().replaceAll(":","")) < nowHm
                        && Integer.valueOf(i.getAutoCallEndTime().replaceAll(":","")) > nowHm
        ).collect(Collectors.toList());
        if(com.github.xiaoymin.knife4j.core.util.CollectionUtils.isEmpty(autoCallGroup)){
            return;
        }
        //查询所有月台
        List<Platform> platformList = platformJoinMapper.selectList(new QueryWrapper<Platform>()
                .lambda()
                .eq(Platform::getIsdeleted,Constants.ZERO)
                .eq(Platform::getStatus,Constants.ZERO)
//                .isNotNull(Platform::getCallReadyNum)
                .in(Platform::getGroupId,autoCallGroup.stream().map(i->i.getId()).collect(Collectors.toList()))
        );
        if(com.github.xiaoymin.knife4j.core.util.CollectionUtils.isEmpty(platformList)){
            return;
        }
        List<PlatformJob> noticeList = new ArrayList<>();
        //循环所有自动叫号月台
        for (PlatformGroup platformGroup:autoCallGroup) {
            List<Platform> platforms = platformList.stream().filter(i->Constants.equalsInteger(i.getGroupId(),platformGroup.getId())).collect(Collectors.toList());
            if(CollectionUtils.isEmpty(platforms)){
                continue;
            }
            Boolean isDefaul = false;
            if(Constants.equalsInteger(platforms.size(),Constants.ONE)){
                isDefaul = true;
            }else{
                //查询月台组下的月台是否同时存在整托和散托月台
                if((((platforms.stream().filter(i->Constants.equalsInteger(i.getType(),Constants.ONE)).collect(Collectors.toList()).size()>Constants.ZERO)?Constants.ONE:Constants.ZERO)
                                +
                                ((platforms.stream().filter(i->Constants.equalsInteger(i.getType(),Constants.ZERO)).collect(Collectors.toList()).size()>Constants.ZERO)?Constants.ONE:Constants.ZERO)
                )==Constants.ONE
                ){
                    isDefaul = true;
                }
            }
            for (Platform platform:platforms) {
                //月台 叫号入园数量
                Integer callReadyNum = Constants.formatIntegerNum(platform.getCallReadyNum());
                //查询当前月台是否存在待开始作业数据 如果存在则直接跳过当前月台
                Integer callNum = platformJobJoinMapper.selectCount(new QueryWrapper<PlatformJob>().lambda()
                        .eq(PlatformJob::getIsdeleted,Constants.ZERO)
                        .eq(PlatformJob::getPlatformId,platform.getId())
                        .eq(PlatformJob::getStatus,Constants.PlatformJobStatus.IN_WAIT.getKey())).intValue();
                if(callNum>=callReadyNum){
                    continue;
                };

                //查询月台下 可以进行叫号的数据
                List<PlatformJob> platformJobList = platformJobJoinMapper.selectList(new QueryWrapper<PlatformJob>()
                        .lambda()
                        .eq(PlatformJob::getIsdeleted,Constants.ZERO)
                        .eq(PlatformJob::getPlatformGroupId, platformGroup.getId())
                        .apply(" ( `STATUS` = "+Constants.PlatformJobStatus.WAIT_CALL.getKey()+" and PLATFORM_GROUP_ID = "+platformGroup.getId()+" ) ")
                        //排序方式 月台作业类型 （异常挂起>叫号入园）>  加急 >  签到时间
                        .orderByDesc(PlatformJob::getStatus,PlatformJob::getUrgeTime)
                        .orderByAsc(PlatformJob::getSignDate));
                if(CollectionUtils.isEmpty(platformJobList)){
                    continue;
                }
                for (int i = 0; i < callReadyNum - callNum && platformJobList.size()>0 ; i++) {
                    if(platformJobList== null || platformJobList.size() ==0){
                        break;
                    }
                    PlatformJob platformJob  = this.getAutoCallJob(platformJobList,platform,isDefaul,platformGroup);
                    if(platformJob ==null){
                        break;
                    }
                    PlatformJob callPlatformJob = this.platformInParkBiz(platformJob,platform);
                    noticeList.add(callPlatformJob);
                    platformJobList = platformJobList.stream().filter(j->!Constants.equalsInteger(j.getId(),platformJob.getId())).collect(Collectors.toList());
                }
            }
        }
        if(noticeList.size()>0){
            for(PlatformJob platformJob :noticeList){
                //发送短信信息
                SmsEmailServiceImpl.sendPlatformJobSms(systemDictDataBiz,
                        emayService,smsEmailMapper,smsConfigMapper,platformJobMapper,platformJob.getId(),
                        SmsConstants.platformJobContent.platformJobCallIn,null,null
                );
                //公众号模板消息
                if(Objects.nonNull(platformJob.getDrivierPhone())) {
                    this.sendWxNotice(WxPlatConstants.platformJobContent.platformJobCallIn,platformJob);
                }
                try{
                    this.sendInPark(platformJob);
                    if(!Constants.equalsInteger(platformJob.getType(),Constants.FOUR)
                            && StringUtils.isNotBlank(platformJob.getBillCode())){
                        //通知WMS绑定月台信息
                        wmsService.orderPlatformBind(platformJob);
                    }
                }catch (Exception e){
                    log.error("自动叫号入园权限下发失败：{}"+JSONObject.toJSONString(platformJob));
                }
            }
        }
    }




    /**
     * 月台分配任务
     * @param platformJobList 所有月台下可以分配的任务
     * @param platform  月台
     * @param platformGroup 月台组
     * @return
     */
    public PlatformJob getAutoCallJob(List<PlatformJob> platformJobList, Platform platform,Boolean isDefaul,PlatformGroup platformGroup){
        if(platformJobList.size() ==0){
            return  null;
        }
        if(isDefaul){
            //月台下只有一类月台 直接返回第一个任务
            return platformJobList.get(Constants.ZERO);
        }
        for (PlatformJob platformJob:platformJobList) {
            log.error("月台自动叫号========开始找作业："+platformJob.getId());
            //叫号入园 或者异常挂起 则直接进行叫号
            if(Constants.equalsInteger(platformJob.getStatus(),Constants.PlatformJobStatus.EXCEPTION.getKey())
                    || Constants.equalsInteger(platformJob.getStatus(),Constants.PlatformJobStatus.IN_WAIT.getKey())){
                return platformJob;
            }
            int typeParam = 1;// 0整托 1散件
            //根据月台组判断 叫号逻辑
            // 新库出库自动叫号规则
            // 1）如果单个运单仅包含单一品规，则自动分配至在整托盘月台进行作业；
            // 2）如果单个运单包含两个及以上的品规，则需要判断是否存在单个品规超过 500 件且该品规数量占整个运单任务量的 60%及以上，则自动分配至在整托盘 月台进行月台；
            // 3）如若不满足以上两点，则自动分配至散件月台进行作业；
            if(Constants.equalsInteger(platformGroup.getType(),Constants.ONE)){
                typeParam = 1;
                //装货月台 - 出库
                if(Constants.equalsInteger(platformJob.getOrigin(),Constants.ONE)){
                    // WM推送任务
                    List<PlatformWmsDetail> platformWmsDetailList = platformWmsDetailMapper.selectList(new QueryWrapper<PlatformWmsDetail>().lambda()
                            .eq(PlatformWmsDetail::getIsdeleted,Constants.ZERO)
                            .eq(PlatformWmsDetail::getJobId,platformJob.getId()));
                    if(com.github.xiaoymin.knife4j.core.util.CollectionUtils.isEmpty(platformWmsDetailList)){
                        continue;
                    }
                    //WMS推送任务 运单仅包含单一品规（商品类型只有一类），则自动分配至在整托盘月台进行作业；
                    List<String> materialNameList = platformWmsDetailList.stream().map(i->i.getMaterialName()).collect(Collectors.toList());
                    Set<String> materialNameSet = new HashSet<>(materialNameList);
                    if(Constants.equalsInteger(materialNameSet.size(),Constants.ONE)){
                        //单一品类 且当前循环月台为整托盘月台
                        typeParam = 0;// 0整托
                    }else  if(materialNameSet.size()> Constants.ONE){
                        boolean isZhengtuo = false;
                        //非单一品类
                        //如果单个运单包含两个及以上的品规，则需要判断是否存在单个品规超过 500 件且该品规数量占整个运单任务量的 60%及以上，则自动分配至在整托盘 月台进行月台；
                        BigDecimal total = platformWmsDetailList.stream().map(i->i.getIoQty()).reduce(BigDecimal.ZERO,BigDecimal::add);
                        BigDecimal compareTotal = new BigDecimal("500");
                        if((total.multiply(new BigDecimal("0.6")).compareTo(compareTotal)>Constants.ZERO)){
                            compareTotal = total.multiply(new BigDecimal("0.6"));
                        }
                        for (String name:materialNameSet) {
                            BigDecimal quanlity = platformWmsDetailList.stream().filter(i->i.getMaterialName().equals(name)).map(i->i.getIoQty()).reduce(BigDecimal.ZERO,BigDecimal::add);
                            if(Constants.formatBigdecimal(quanlity).compareTo(compareTotal)>Constants.ZERO){
                                //超过规定数量 且当前月台为整托月台
                                isZhengtuo =true;
                                typeParam = 0;// 0整托
                            }
                        }
                    }
                }
            }else{
                typeParam = 0;//默认整托
                //卸货月台 - 入库
                // 1）发货地为指定地区，如省外/芜湖，则自动分配至散件月台进行作业；（联营加工情况）
                // 2）其它场景，均自动分配至整托盘月台进行作业
                if(Constants.equalsInteger(platformJob.getOrigin(),Constants.ONE)){
                    PlatformWmsJob platformWmsJob = platformWmsJobMapper.selectOne(new QueryWrapper<PlatformWmsJob>().lambda()
                            .eq(PlatformWmsJob::getIsdeleted,Constants.ZERO)
                            .eq(PlatformWmsJob::getJobId,platformJob.getId())
                            .orderByDesc(PlatformWmsJob::getId)
                            .last(" limit 1"));
                    if(Objects.isNull(platformWmsJob)){
                        continue;
                    }
                    SystemDictData systemDictData = systemDictDataBiz.queryByCode(Constants.WMS_PARAM,Constants.IN_REPERTOTY_CODE);
                    if( Objects.nonNull(systemDictData)){
                        //判断放置位置
                        if(platformWmsDetailMapper.selectCount(new QueryWrapper<PlatformWmsDetail>().lambda().eq(PlatformWmsDetail::getIsdeleted,Constants.ZERO)
                                .eq(PlatformWmsDetail::getWmsJobId,platformWmsJob.getId())
                                .apply(" find_in_set(IN_REPERTOTY_CODE ,'"+systemDictData.getCode()+"')")
                                .isNotNull(PlatformWmsDetail::getInRepertotyCode)
                        ) > Constants.ZERO ){//指定区域分配到散件月台
                            typeParam = 1;//
                        }
                    }
                }
            }

            log.error("月台自动叫号========开始找作业结果："+platformJob.getId()+"============"+platform.getType()+"===="+typeParam);
            if(  Constants.equalsInteger(platform.getType(),typeParam)){
                log.error("月台自动叫号========找到了作业："+platform.getName() );
                return platformJob;
            }
        }
        return null;
    }



    @Override
    public void jobUrge(Integer jobId,LoginUserInfo loginUserInfo){
        if(Objects.isNull(jobId)){
            throw new BusinessException(ResponseStatus.BAD_REQUEST);
        }
        PlatformJob platformJob = platformJobMapper.selectById(jobId);
        if(Objects.isNull(platformJob)){
            throw new BusinessException(ResponseStatus.DATA_EMPTY);
        }
        if(!(Constants.equalsInteger(platformJob.getStatus(),Constants.PlatformJobStatus.WAIT_CALL.getKey())
                        || Constants.equalsInteger(platformJob.getStatus(),Constants.PlatformJobStatus.IN_WAIT.getKey())
                || Constants.equalsInteger(platformJob.getStatus(),Constants.PlatformJobStatus.TRANSFERING.getKey()))){
            throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"对不起，状态已流转");
        }

        platformJobMapper.update(null,new UpdateWrapper<PlatformJob>().lambda()
                .set(PlatformJob::getUrgeUser,loginUserInfo.getId())
                .set(PlatformJob::getUrgeTime,DateUtil.getCurrDateTime())
                .set(PlatformJob::getEditDate,DateUtil.getCurrDateTime())
                .eq(PlatformJob::getId,platformJob.getId())
        );
    }




}