最新版本541200007

jiangping

2025-02-27 10c28ce3d0b384584c77ce9111a66a0641250752

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

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,365 @@
package com.doumee.service.business.impl;

import com.doumee.core.constants.ResponseStatus;
import com.doumee.core.exception.BusinessException;
import com.doumee.service.business.third.model.LoginUserInfo;
import com.doumee.service.business.third.model.PageData;
import com.doumee.service.business.third.model.PageWrap;
import com.doumee.core.utils.Constants;
import com.doumee.core.utils.Utils;
import com.doumee.dao.business.PlatformGroupMapper;
import com.doumee.dao.business.PlatformShowParamMapper;
import com.doumee.dao.business.join.PlatformJobJoinMapper;
import com.doumee.dao.business.join.PlatformJoinMapper;
import com.doumee.dao.business.model.*;
import com.doumee.dao.web.reqeust.PlatformDataDTO;
import com.doumee.dao.web.response.PlatformGroupWorkVO;
import com.doumee.dao.web.response.PlatformWorkVO;
import com.doumee.service.business.PlatformGroupService;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.github.yulichang.wrapper.MPJLambdaWrapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

import java.util.Date;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;

/**
 * æœˆå°_分组信息表Service实现
 * @author æ±Ÿè¹„蹄
 * @date 2024/06/28 10:03
 */
@Service
public class PlatformGroupServiceImpl implements PlatformGroupService {

    @Autowired
    private PlatformGroupMapper platformGroupMapper;

    @Autowired
    private PlatformJoinMapper platformJoinMapper;

    @Autowired
    private PlatformShowParamMapper platformShowParamMapper;

    @Autowired
    private PlatformJobJoinMapper platformJobJoinMapper;

    @Override
    public Integer create(PlatformGroup platformGroup) {
        if(platformGroup.getType() ==null
                || platformGroup.getType()>2
                || platformGroup.getType()<0){
            throw new BusinessException(ResponseStatus.BAD_REQUEST);
        }
        if(platformGroupMapper.selectCount(new QueryWrapper<PlatformGroup>().lambda()
                .eq(PlatformGroup::getIsdeleted,Constants.ZERO)
                .eq(PlatformGroup::getType,platformGroup.getType())
        )>0){
            throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(),"对不起，该类型分组已经创建，请返回刷新页面查看！");
        }
        platformGroup.setStatus(Constants.ZERO);
        platformGroup.setIsdeleted(Constants.ZERO);
        platformGroup.setCreator(platformGroup.getLoginUserInfo().getId());
        platformGroup.setCreateDate(new Date());
        platformGroup.setEditDate(platformGroup.getCreateDate());
        platformGroup.setEditor(platformGroup.getCreator());
        platformGroupMapper.insert(platformGroup);
        return platformGroup.getId();
    }

    @Override
    public void deleteById(Integer id) {
        PlatformGroup param = new PlatformGroup();
        param.setId(id);
        param.setIsdeleted(Constants.ONE);
        platformGroupMapper.updateById(param);
    }
    @Override
    public void deleteById(Integer id,LoginUserInfo user) {
//        platformGroupMapper.deleteById(id);
        PlatformGroup param = new PlatformGroup();
        param.setId(id);
        param.setIsdeleted(Constants.ONE);
        param.setEditor(user.getId());
        param.setEditDate(new Date());
        platformGroupMapper.updateById(param);
    }

    @Override
    public void delete(PlatformGroup platformGroup) {
        UpdateWrapper<PlatformGroup> deleteWrapper = new UpdateWrapper<>(platformGroup);
        platformGroupMapper.delete(deleteWrapper);
    }

    @Override
    public void deleteByIdInBatch(List<Integer> ids) {
        if (CollectionUtils.isEmpty(ids)) {
            return;
        }
        for(Integer id : ids){
            deleteById(id);
        }
    }
    @Override
    public void deleteByIdInBatch(List<Integer> ids,LoginUserInfo user) {
        if (CollectionUtils.isEmpty(ids)) {
            return;
        }
        for(Integer id : ids){
            deleteById(id,user);
        }
    }

    @Override
    public void updateById(PlatformGroup platformGroup) {
        if(platformGroup.getType() ==null
                || platformGroup.getType()>2
                || platformGroup.getType()<0){
            throw new BusinessException(ResponseStatus.BAD_REQUEST);
        }
        if(platformGroupMapper.selectCount(new QueryWrapper<PlatformGroup>().lambda()
                .eq(PlatformGroup::getIsdeleted,Constants.ZERO)
                .eq(PlatformGroup::getType,platformGroup.getType())
                .ne(PlatformGroup::getId,platformGroup.getId())
        )>0){
            throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(),"对不起，该类型分组已经创建，请返回刷新页面查看！");
        }
        platformGroup.setEditDate(new Date());
        platformGroup.setEditor(platformGroup.getLoginUserInfo().getId());
        platformGroupMapper.updateById(platformGroup);
    }

    @Override
    public void updateByIdInBatch(List<PlatformGroup> platformGroups) {
        if (CollectionUtils.isEmpty(platformGroups)) {
            return;
        }
        for (PlatformGroup platformGroup: platformGroups) {
            this.updateById(platformGroup);
        }
    }

    @Override
    public PlatformGroup findById(Integer id) {
        return platformGroupMapper.selectById(id);
    }

    @Override
    public PlatformGroup findOne(PlatformGroup platformGroup) {
        QueryWrapper<PlatformGroup> wrapper = new QueryWrapper<>(platformGroup);
        return platformGroupMapper.selectOne(wrapper);
    }

    @Override
    public List<PlatformGroup> findList(PlatformGroup platformGroup) {
        QueryWrapper<PlatformGroup> wrapper = new QueryWrapper<>(platformGroup);
        return platformGroupMapper.selectList(wrapper);
    }
  
    @Override
    public PageData<PlatformGroup> findPage(PageWrap<PlatformGroup> pageWrap) {
        IPage<PlatformGroup> page = new Page<>(pageWrap.getPage(), pageWrap.getCapacity());
        QueryWrapper<PlatformGroup> queryWrapper = new QueryWrapper<>();
        Utils.MP.blankToNull(pageWrap.getModel());
        queryWrapper.lambda()
                .eq(pageWrap.getModel().getId() != null, PlatformGroup::getId, pageWrap.getModel().getId())
                .eq(pageWrap.getModel().getCreator() != null, PlatformGroup::getCreator, pageWrap.getModel().getCreator())
                .ge(pageWrap.getModel().getCreateDate() != null, PlatformGroup::getCreateDate, Utils.Date.getStart(pageWrap.getModel().getCreateDate()))
                .le(pageWrap.getModel().getCreateDate() != null, PlatformGroup::getCreateDate, Utils.Date.getEnd(pageWrap.getModel().getCreateDate()))
                .eq(pageWrap.getModel().getEditor() != null, PlatformGroup::getEditor, pageWrap.getModel().getEditor())
                .ge(pageWrap.getModel().getEditDate() != null, PlatformGroup::getEditDate, Utils.Date.getStart(pageWrap.getModel().getEditDate()))
                .le(pageWrap.getModel().getEditDate() != null, PlatformGroup::getEditDate, Utils.Date.getEnd(pageWrap.getModel().getEditDate()))
                .eq(pageWrap.getModel().getIsdeleted() != null, PlatformGroup::getIsdeleted, pageWrap.getModel().getIsdeleted())
                .eq(pageWrap.getModel().getName() != null, PlatformGroup::getName, pageWrap.getModel().getName())
                .eq(pageWrap.getModel().getRemark() != null, PlatformGroup::getRemark, pageWrap.getModel().getRemark())
                .eq(pageWrap.getModel().getStatus() != null, PlatformGroup::getStatus, pageWrap.getModel().getStatus())
                .eq(pageWrap.getModel().getSortnum() != null, PlatformGroup::getSortnum, pageWrap.getModel().getSortnum())
        ;
        for(PageWrap.SortData sortData: pageWrap.getSorts()) {
            if (sortData.getDirection().equalsIgnoreCase(PageWrap.DESC)) {
                queryWrapper.orderByDesc(sortData.getProperty());
            } else {
                queryWrapper.orderByAsc(sortData.getProperty());
            }
        }
        return PageData.from(platformGroupMapper.selectPage(page, queryWrapper));
    }

    @Override
    public long count(PlatformGroup platformGroup) {
        QueryWrapper<PlatformGroup> wrapper = new QueryWrapper<>(platformGroup);
        return platformGroupMapper.selectCount(wrapper);
    }


    @Override
    public List<PlatformGroup> getAllPlatformGroup(PlatformDataDTO platformDataDTO, LoginUserInfo loginUserInfo) {
        if(Objects.isNull(platformDataDTO)
        || Objects.isNull(platformDataDTO.getQueryType())
        || Objects.isNull(platformDataDTO.getQueryData())){
            throw new BusinessException(ResponseStatus.BAD_REQUEST);
        }
        List<PlatformGroup> platformGroups = platformGroupMapper.selectList(
                new QueryWrapper<PlatformGroup>()
                        .lambda()
                        .eq(PlatformGroup::getIsdeleted, Constants.ZERO)
                        .orderByAsc(PlatformGroup::getSortnum)
        );
        //查询月台组下所有月台
        List<Platform> allPlatformList = platformJoinMapper.selectJoinList(Platform.class,
                new MPJLambdaWrapper<Platform>()
                        .selectAll(Platform.class)
                        .select(" ( select count(1) from platform_job pj where t.id = pj.PLATFORM_ID and pj.STATUS = "+Constants.PlatformJobStatus.WORKING.getKey()+" ) as workStatus ")
                        .eq(Platform::getIsdeleted, Constants.ZERO)
                        .eq(Objects.nonNull(platformDataDTO.getQueryType())&&!Constants.equalsInteger(platformDataDTO.getQueryType(),Constants.ZERO),
                                Platform::getStatus,Constants.ZERO)
        );
        //处理我的月台信息 æ˜¯å¦é…ç½®éšè—
        if(Constants.equalsInteger(platformDataDTO.getQueryType(),Constants.ONE)){
            //查询当前登录人配置的可查看月台
            List<PlatformShowParam> platformShowParamList = platformShowParamMapper.selectList(new QueryWrapper<PlatformShowParam>()
                    .lambda()
                    .eq(PlatformShowParam::getIsdeleted, Constants.ZERO)
                    .eq(PlatformShowParam::getMemberId,loginUserInfo.getMemberId())
            );
            //如果未配置该数据 åˆ™å…¨éƒ¨æ˜¾ç¤º
            if(CollectionUtils.isEmpty(platformShowParamList)){
                for (Platform platform:allPlatformList) {
                    platform.setShowConfig(true);
                }
            }else{
                //根据配置显示数据
                for (PlatformShowParam platformShowParam:platformShowParamList) {
                    for (Platform platform:allPlatformList) {
                        if(Constants.equalsInteger(platform.getId(),platformShowParam.getPlatformId())){
                            platform.setShowConfig(true);
                            break;
                        }
                    }
                }
            }
        }
        if(Constants.equalsInteger(platformDataDTO.getQueryData(),Constants.ONE)){
            //查询今天所有的任务数据
            List<PlatformJob> platformJobList =  platformJobJoinMapper.selectJoinList(PlatformJob.class,new MPJLambdaWrapper<PlatformJob>()
                            .selectAll(PlatformJob.class)
                            .select(" ( select pl.CREATE_DATE from platform_log pl where t.id = pl.obj_id and pl.OBJ_TYPE = "+Constants.PlatformJobLogType.WORKING.getKey()+"  order by pl.CREATE_DATE desc  limit 1  ) as newStartDate  ")
                            .select(" ( select pl.CREATE_DATE from platform_log pl where t.id = pl.obj_id and pl.OBJ_TYPE = "+Constants.PlatformJobLogType.CALLED.getKey()+" order by pl.CREATE_DATE desc  limit 1  ) as newCallDate  ")
                            .select(" case when t.total_num is null  then ( select sum(pwd.IO_QTY) from platform_wms_detail pwd where pwd.JOB_ID = t.id  ) else t.total_num end ioQty ")
                            .selectAs(PlatformWmsJob::getCarrierName,PlatformJob::getCarrierName)
                            .selectAs(PlatformBooks::getId,PlatformJob::getBookId)
                            .leftJoin(Platform.class,Platform::getId,PlatformJob::getPlatformId)
                            .leftJoin(PlatformWmsJob.class,PlatformWmsJob::getCarryBillCode,PlatformJob::getBillCode)
                            .leftJoin(PlatformBooks.class,PlatformBooks::getJobId,PlatformJob::getId)
                            .eq(PlatformJob::getIsdeleted,Constants.ZERO)
                            .apply(" ( t1.isdeleted = 0 or t.PLATFORM_ID is null  ) ")
                            .in(PlatformJob::getStatus,
                                    Constants.PlatformJobStatus.WAIT_CALL.getKey(),
                                    Constants.PlatformJobStatus.IN_WAIT.getKey(),
                                    Constants.PlatformJobStatus.CALLED.getKey(),
                                    Constants.PlatformJobStatus.WORKING.getKey(),
                                    Constants.PlatformJobStatus.EXCEPTION.getKey(),
                                    Constants.PlatformJobStatus.OVER_NUMBER.getKey(),
                                    Constants.PlatformJobStatus.TRANSFERING.getKey()
                            )
//                    .like(PlatformJob::getArriveDate,DateUtil.getCurrDate())
                    .orderByDesc(PlatformJob::getCreateDate)
            );
            for (Platform platform:allPlatformList) {
                PlatformWorkVO platformWorkVO = PlatformGroupServiceImpl.getPlatformWorkVO(platform,platformJobList);
                platform.setPlatformWorkVO(platformWorkVO);
            }
            for (PlatformGroup platformGroup:platformGroups) {
                platformGroup.setPlatformList(allPlatformList.stream().filter(m->m.getShowConfig()&&Constants.equalsInteger(m.getGroupId(),platformGroup.getId())).collect(Collectors.toList()));
            }
        }else{
            for (PlatformGroup platformGroup:platformGroups) {
                platformGroup.setPlatformList(allPlatformList.stream().filter(m->Constants.equalsInteger(m.getGroupId(),platformGroup.getId())).collect(Collectors.toList()));
            }
        }
        return platformGroups;
    }


    public static PlatformWorkVO getPlatformWorkVO(Platform platform,List<PlatformJob> platformJobList){
        PlatformWorkVO platformWorkVO = new PlatformWorkVO();
        platformWorkVO.setCurrentDate(new Date());
        if(com.github.xiaoymin.knife4j.core.util.CollectionUtils.isNotEmpty(platformJobList)){
            //获取月台组下的所有作业数据
            List<PlatformJob> platformJobs = platformJobList.stream().filter(
                    i->Constants.equalsInteger(i.getPlatformId(),platform.getId())
                    || Constants.equalsInteger(i.getPlatformGroupId(),platform.getGroupId())
            ).collect(Collectors.toList());
            if(com.github.xiaoymin.knife4j.core.util.CollectionUtils.isNotEmpty(platformJobs)){
                for(PlatformJob i :platformJobList){
                    if(Constants.equalsInteger(i.getOrigin(),Constants.ZERO)){
                        i.setWmsContractNum(i.getContractNum());
                    }
                }
                platformWorkVO.setWorkNum(
                        platformJobs.stream().filter(i->Constants.equalsInteger(i.getPlatformId(),platform.getId())  && Constants.equalsInteger(i.getStatus(),Constants.PlatformJobStatus.WORKING.getKey())).collect(Collectors.toList()).size()
                );
                platformWorkVO.setCallNum(
                        platformJobs.stream().filter(i->Constants.equalsInteger(i.getPlatformId(),platform.getId())  && Constants.equalsInteger(i.getStatus(),Constants.PlatformJobStatus.CALLED.getKey())).collect(Collectors.toList()).size()
                );
                platformWorkVO.setWaitNum(

                        platformJobs.stream().filter(i->
                                 Constants.equalsInteger(i.getStatus(),Constants.PlatformJobStatus.WAIT_CALL.getKey())
                        ).collect(Collectors.toList()).size()
                        +
                        platformJobList.stream().filter(i->
                                (  Constants.equalsInteger(i.getStatus(),Constants.PlatformJobStatus.IN_WAIT.getKey()) && Constants.equalsInteger(i.getPlatformGroupId(),platform.getGroupId()) )||
                                 ( Constants.equalsInteger(platform.getId(),i.getPlatformId()) &&
                                 Constants.equalsInteger(i.getStatus(),Constants.PlatformJobStatus.TRANSFERING.getKey())
                               )
                        ).collect(Collectors.toList()).size()
                );
                platformWorkVO.setExceptionNum(
                        platformJobs.stream().filter(i->Constants.equalsInteger(platform.getId(),i.getPlatformId())
                                && Constants.equalsInteger(i.getStatus(),Constants.PlatformJobStatus.EXCEPTION.getKey())).collect(Collectors.toList()).size()
                );
                platformWorkVO.setPlatformJobList(platformJobs.stream().filter(
                        i->Constants.equalsInteger(platform.getId(),i.getPlatformId()) && !Constants.equalsInteger(i.getStatus(),Constants.PlatformJobStatus.WAIT_CALL.getKey())
                ).collect(Collectors.toList()));
            }
        }
        return platformWorkVO;
    }



    @Override
    public PlatformGroupWorkVO getPlatformGroupWork(Integer platformGroupId){
        PlatformGroupWorkVO platformGroupWorkVO = new PlatformGroupWorkVO();
        platformGroupWorkVO.setExceptionNum(platformJobJoinMapper.selectJoinCount(new MPJLambdaWrapper<PlatformJob>()
                .leftJoin(Platform.class,Platform::getId,PlatformJob::getPlatformId)
                .eq(PlatformJob::getIsdeleted,Constants.ZERO)
                .eq(Platform::getIsdeleted,Constants.ZERO)
                .eq(PlatformJob::getPlatformGroupId,platformGroupId)
                .eq(PlatformJob::getStatus,Constants.PlatformJobStatus.EXCEPTION.getKey())
            )
        );
        platformGroupWorkVO.setWaitNum(platformJobJoinMapper.selectJoinCount(new MPJLambdaWrapper<PlatformJob>()
                        .leftJoin(Platform.class,Platform::getId,PlatformJob::getPlatformId)
                        .eq(PlatformJob::getIsdeleted,Constants.ZERO)
                        .apply(" ( t1.isdeleted = 0 or t.PLATFORM_ID is null  ) ")
                        .eq(PlatformJob::getPlatformGroupId,platformGroupId)
                        .and( i->i.eq(PlatformJob::getStatus,Constants.PlatformJobStatus.WAIT_CALL.getKey()).or()
                                        .eq(PlatformJob::getStatus,Constants.PlatformJobStatus.IN_WAIT.getKey()).or()
                                        .apply(" ( t.status = "+Constants.PlatformJobStatus.TRANSFERING.getKey()+" and t.PLATFORM_GROUP_ID = "+platformGroupId+" ) ")
                        )
                )
        );
        return platformGroupWorkVO;
    }


}