package com.qianwen.smartman.modules.tpm.service.impl;

import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import java.lang.invoke.SerializedLambda;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.qianwen.smartman.common.cache.RegionCache;
import com.qianwen.smartman.common.constant.NotifyConstant;
import com.qianwen.smartman.common.utils.MessageUtils;
import com.qianwen.core.log.exception.ServiceException;
import com.qianwen.core.mp.support.Condition;
import com.qianwen.core.mp.support.Query;
import com.qianwen.core.secure.utils.AuthUtil;
import com.qianwen.core.tool.utils.CollectionUtil;
import com.qianwen.core.tool.utils.Func;
import com.qianwen.smartman.modules.cps.service.IMachineService;
import com.qianwen.smartman.modules.cps.service.IWorkstationService;
import com.qianwen.smartman.modules.cps.vo.WorkstationVO;
import com.qianwen.smartman.modules.notify.business.BusinessSend;
import com.qianwen.smartman.modules.notify.business.BusinessSendFactory;
import com.qianwen.smartman.modules.notify.dto.NotifyBusinessSendDTO;
import com.qianwen.smartman.modules.system.service.ICodeGeneratorService;
import com.qianwen.smartman.modules.tpm.convert.RepairApplyConvert;
import com.qianwen.smartman.modules.tpm.convert.RepairApplyFileConvert;
import com.qianwen.smartman.modules.tpm.dto.RepairApplyFileAddDTO;
import com.qianwen.smartman.modules.tpm.entity.RepairApply;
import com.qianwen.smartman.modules.tpm.entity.RepairApplyFile;
import com.qianwen.smartman.modules.tpm.entity.RepairRecord;
import com.qianwen.smartman.modules.tpm.enums.ActionEnum;
import com.qianwen.smartman.modules.tpm.enums.DeviceRepairStatusEnum;
import com.qianwen.smartman.modules.tpm.enums.MetaTypeEnum;
import com.qianwen.smartman.modules.tpm.enums.RepairApplyStatusEnum;
import com.qianwen.smartman.modules.tpm.enums.RepairRecordEnum;
import com.qianwen.smartman.modules.tpm.enums.UrgencyEnum;
import com.qianwen.smartman.modules.tpm.mapper.RepairApplyMapper;
import com.qianwen.smartman.modules.tpm.service.IRepairApplyFileService;
import com.qianwen.smartman.modules.tpm.service.IRepairApplyService;
import com.qianwen.smartman.modules.tpm.service.IRepairRecordService;
import com.qianwen.smartman.modules.tpm.vo.ApplyCodeVO;
import com.qianwen.smartman.modules.tpm.vo.RepairApplyAddVO;
import com.qianwen.smartman.modules.tpm.vo.RepairApplyDetailVO;
import com.qianwen.smartman.modules.tpm.vo.RepairApplyExportVO;
import com.qianwen.smartman.modules.tpm.vo.RepairApplyLookVO;
import com.qianwen.smartman.modules.tpm.vo.RepairApplySearchVO;
import com.qianwen.smartman.modules.tpm.vo.RepairApplyUpdateVO;
import com.qianwen.smartman.modules.tpm.vo.RepairApplyVO;
import com.qianwen.smartman.modules.tpm.vo.RepairFileVO;
import com.qianwen.smartman.modules.tpm.vo.excel.RepairApplyExcelVO;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
/* loaded from: blade-api.jar:BOOT-INF/classes/org/springblade/modules/tpm/service/impl/RepairApplyServiceImpl.class */
public class RepairApplyServiceImpl extends ServiceImpl<RepairApplyMapper, RepairApply> implements IRepairApplyService {
    private static final Logger log = LoggerFactory.getLogger(RepairApplyServiceImpl.class);
    @Autowired
    private IRepairApplyFileService iRepairApplyFileService;
    @Autowired
    @Lazy
    private IRepairRecordService repairRecordService;
    @Autowired
    private IMachineService machineService;
    @Autowired
    private ICodeGeneratorService codeGeneratorService;
    @Autowired
    private BusinessSendFactory businessSendFactory;
    @Autowired
    private IWorkstationService workstationService;

    @Override // org.springblade.modules.tpm.service.IRepairApplyService
    @Transactional(rollbackFor = {Exception.class})
    public RepairApply createRepairApply(RepairApplyAddVO repairApplyAddVO) {
        RepairApply repairApply = RepairApplyConvert.INSTANCE.convert(repairApplyAddVO);
        if (Func.isBlank(repairApply.getApplyCode())) {
            String code = this.codeGeneratorService.getGeneratorCode(repairApplyAddVO, MetaTypeEnum.REPAIR_APPLY.getCode());
            log.info("维修申请编码规则生成的code:{}", code + " ," + code.length());
            repairApply.setApplyCode(code);
        }
        if (checkApplyCode(repairApply.getApplyCode())) {
            throw new ServiceException(MessageUtils.message("cps.tpm.repair.apply.code.already.exists", new Object[0]));
        }
        repairApply.setApplyStatus(Integer.valueOf(RepairApplyStatusEnum.Y1.getType()));
        this.machineService.createRepairApplyUpdateMachine(repairApply.getDeviceId(), Integer.valueOf(DeviceRepairStatusEnum.TO_BE_REPAIRED.getType()));
        save(repairApply);
        if (Func.isNotEmpty(repairApplyAddVO.getFileAddDTOList())) {
            List<RepairApplyFile> repairApplyFileList = RepairApplyFileConvert.INSTANCE.convert(repairApplyAddVO.getFileAddDTOList());
            repairApplyFileList.forEach(s -> {
                s.setRepairApplyId(repairApply.getId());
            });
            this.iRepairApplyFileService.saveBatch(repairApplyFileList);
        }
        NotifyBusinessSendDTO notifyBusinessSend = repairApplyAddVO.getNotifyBusinessSend();
        sendMessage(repairApply, notifyBusinessSend);
        return repairApply;
    }

    private boolean checkApplyCode(String applyCode) {
    	RepairApply repairApply = this.baseMapper.selectOne(Wrappers.<RepairApply>query().lambda()
    			.eq(Func.isNotEmpty(AuthUtil.getTenantId()), RepairApply::getTenantId, AuthUtil.getTenantId())
    			.eq(RepairApply::getApplyCode, applyCode));
    	/*
        RepairApply repairApply = (RepairApply) this.baseMapper.selectOne((Wrapper) Wrappers.query().lambda().eq(Func.isNotEmpty(AuthUtil.getTenantId()), (v0) -> {
            return v0.getTenantId();
        }, AuthUtil.getTenantId()).eq((v0) -> {
            return v0.getApplyCode();
        }, applyCode));*/
        return repairApply != null;
    }

    @Override // org.springblade.modules.tpm.service.IRepairApplyService
    public RepairApplyDetailVO detailApply(Long id) {
    	
    	RepairApply repairApply = this.baseMapper.selectOne(Wrappers.<RepairApply>query().lambda().eq(RepairApply::getId, id));
    	/*
        RepairApply repairApply = (RepairApply) this.baseMapper.selectOne((Wrapper) Wrappers.query().lambda().eq((v0) -> {
            return v0.getId();
        }, id));*/
        if (Func.isEmpty(repairApply)) {
            throw new ServiceException(MessageUtils.message("cps.tpm.repair.apply.not.exists", new Object[0]));
        }
        List<RepairApplyFile> fileList = this.iRepairApplyFileService.list(Wrappers.<RepairApplyFile>lambdaQuery().eq(RepairApplyFile::getRepairApplyId, id));
        /*
        List<RepairApplyFile> fileList = this.iRepairApplyFileService.list((Wrapper) Wrappers.lambdaQuery().eq((v0) -> {
            return v0.getRepairApplyId();
        }, id));*/
        new RepairApplyDetailVO();
        RepairApplyDetailVO vo = RepairApplyConvert.INSTANCE.convert1(repairApply);
        List<RepairApplyFileAddDTO> fileAddDtoList = fileList.stream().map(RepairApplyFileConvert.INSTANCE::convert).collect(Collectors.toList());
        /*
        Stream<RepairApplyFile> stream = fileList.stream();
        RepairApplyFileConvert repairApplyFileConvert = RepairApplyFileConvert.INSTANCE;
        repairApplyFileConvert.getClass();
        List<RepairApplyFileAddDTO> fileAddDtoList = (List) stream.map(this::convert).collect(Collectors.toList());
        */
        if (Func.isNotEmpty(fileAddDtoList)) {
            vo.setFileAddDTOList(fileAddDtoList);
        } else {
            vo.setFileAddDTOList(new ArrayList<>());
        }
        return vo;
    }

    @Override // org.springblade.modules.tpm.service.IRepairApplyService
    public IPage<RepairApplyVO> getPageApply(RepairApplyLookVO repairApplyLookVO, Query query) {
    	IPage<RepairApply> pages = page(Condition.getPage(query), Wrappers.<RepairApply>lambdaQuery()
    	        .eq(Func.isNotEmpty(AuthUtil.getTenantId()), RepairApply::getTenantId, AuthUtil.getTenantId())
    	        .and(Func.isNotEmpty(repairApplyLookVO.getDeviceTypeId()), i -> i.eq(RepairApply::getDeviceTypeId, repairApplyLookVO.getDeviceTypeId()))
    	        .and(CollectionUtil.isNotEmpty(repairApplyLookVO.getApplyStatusList()), i -> i.in(RepairApply::getApplyStatus, repairApplyLookVO.getApplyStatusList()))
    	        .and(Func.isNotEmpty(repairApplyLookVO.getKeyWords()), i -> i.likeRight(RepairApply::getApplyCode, repairApplyLookVO.getKeyWords()).or().likeRight(RepairApply::getDeviceCode, repairApplyLookVO.getKeyWords()).or().likeRight(RepairApply::getDeviceName, repairApplyLookVO.getKeyWords()))
    	        
    	        .orderByAsc(RepairApply::getIsAffect).orderByDesc(RepairApply::getUrgency).orderByDesc(RepairApply::getCreateTime).orderByDesc(RepairApply::getId));
    	/*
        IPage<RepairApply> pages = page(Condition.getPage(query), (Wrapper) ((LambdaQueryWrapper) ((LambdaQueryWrapper) ((LambdaQueryWrapper) Wrappers.lambdaQuery().eq(Func.isNotEmpty(AuthUtil.getTenantId()), (v0) -> {
            return v0.getTenantId();
        }, AuthUtil.getTenantId()).and(Func.isNotEmpty(repairApplyLookVO.getDeviceTypeId()), i -> {
            LambdaQueryWrapper lambdaQueryWrapper = (LambdaQueryWrapper) i.eq((v0) -> {
                return v0.getDeviceTypeId();
            }, repairApplyLookVO.getDeviceTypeId());
        }).and(CollectionUtil.isNotEmpty(repairApplyLookVO.getApplyStatusList()), i2 -> {
            LambdaQueryWrapper lambdaQueryWrapper = (LambdaQueryWrapper) i2.in((v0) -> {
                return v0.getApplyStatus();
            }, repairApplyLookVO.getApplyStatusList());
        }).and(Func.isNotEmpty(repairApplyLookVO.getKeyWords()), i3 -> {
            LambdaQueryWrapper lambdaQueryWrapper = (LambdaQueryWrapper) ((LambdaQueryWrapper) ((LambdaQueryWrapper) ((LambdaQueryWrapper) ((LambdaQueryWrapper) i3.likeRight((v0) -> {
                return v0.getApplyCode();
            }, repairApplyLookVO.getKeyWords())).or()).likeRight((v0) -> {
                return v0.getDeviceCode();
            }, repairApplyLookVO.getKeyWords())).or()).likeRight((v0) -> {
                return v0.getDeviceName();
            }, repairApplyLookVO.getKeyWords());
        }).orderByAsc((v0) -> {
            return v0.getIsAffect();
        })).orderByDesc((v0) -> {
            return v0.getUrgency();
        })).orderByDesc((v0) -> {
            return v0.getCreateTime();
        })).orderByDesc((v0) -> {
            return v0.getId();
        }));*/
        return RepairApplyConvert.INSTANCE.convert(pages);
    }

    @Override // org.springblade.modules.tpm.service.IRepairApplyService
    public List<RepairApplyVO> queryApply(RepairApplyLookVO repairApplyLookVO) {
    	List<RepairApply> pages = list(Wrappers.<RepairApply>lambdaQuery()
    	        .eq(Func.isNotEmpty(AuthUtil.getTenantId()), RepairApply::getTenantId, AuthUtil.getTenantId())
    	        .and(CollectionUtil.isNotEmpty(repairApplyLookVO.getApplyStatusList()), i -> i.in(RepairApply::getApplyStatus, repairApplyLookVO.getApplyStatusList()))
    	        .and(Func.isNotEmpty(repairApplyLookVO.getKeyWords()), i -> i.likeRight(RepairApply::getApplyCode, repairApplyLookVO.getKeyWords()).or().likeRight(RepairApply::getDeviceCode, repairApplyLookVO.getKeyWords()).or().likeRight(RepairApply::getDeviceName, repairApplyLookVO.getKeyWords()))
    	        
    	        .orderByAsc(RepairApply::getIsAffect).orderByDesc(RepairApply::getUrgency).orderByAsc(RepairApply::getMalfunctionTime));
    	/*
        List<RepairApply> pages = list((Wrapper) ((LambdaQueryWrapper) ((LambdaQueryWrapper) Wrappers.lambdaQuery().eq(Func.isNotEmpty(AuthUtil.getTenantId()), (v0) -> {
            return v0.getTenantId();
        }, AuthUtil.getTenantId()).and(CollectionUtil.isNotEmpty(repairApplyLookVO.getApplyStatusList()), i -> {
            LambdaQueryWrapper lambdaQueryWrapper = (LambdaQueryWrapper) i.in((v0) -> {
                return v0.getApplyStatus();
            }, repairApplyLookVO.getApplyStatusList());
        }).and(Func.isNotEmpty(repairApplyLookVO.getKeyWords()), i2 -> {
            LambdaQueryWrapper lambdaQueryWrapper = (LambdaQueryWrapper) ((LambdaQueryWrapper) ((LambdaQueryWrapper) ((LambdaQueryWrapper) ((LambdaQueryWrapper) i2.likeRight((v0) -> {
                return v0.getApplyCode();
            }, repairApplyLookVO.getKeyWords())).or()).likeRight((v0) -> {
                return v0.getDeviceCode();
            }, repairApplyLookVO.getKeyWords())).or()).likeRight((v0) -> {
                return v0.getDeviceName();
            }, repairApplyLookVO.getKeyWords());
        }).orderByAsc((v0) -> {
            return v0.getIsAffect();
        })).orderByDesc((v0) -> {
            return v0.getUrgency();
        })).orderByAsc((v0) -> {
            return v0.getMalfunctionTime();
        }));*/
        return RepairApplyConvert.INSTANCE.convert(pages);
    }

    @Override // org.springblade.modules.tpm.service.IRepairApplyService
    @Transactional(rollbackFor = {Exception.class})
    public boolean deleteRepairApply(List<Long> ids) {
        if (Func.isEmpty(ids) || ids.size() < 1) {
            throw new ServiceException(MessageUtils.message("cps.tpm.repair.delete.id.not.empty.and.least.one", new Object[0]));
        }
        if (!checkApplyStatus(ids)) {
            throw new ServiceException(MessageUtils.message("cps.tpm.repair.delete.apply.status.is.pending", new Object[0]));
        }
        for (Long id : ids) {
            RepairApply repairApply = (RepairApply) getById(id);
            removeById(id);
            List<RepairApplyFile> list = this.iRepairApplyFileService.list(Wrappers.<RepairApplyFile>lambdaQuery().eq(RepairApplyFile::getRepairApplyId, id));
            /*
            List<RepairApplyFile> list = this.iRepairApplyFileService.list((Wrapper) Wrappers.lambdaQuery().eq((v0) -> {
                return v0.getRepairApplyId();
            }, id));*/
            if (Func.isNotEmpty(list)) {
                list.forEach(i -> {
                    this.iRepairApplyFileService.removeById(i.getId());
                });
            }
            
            List<RepairApply> y1List = list(Wrappers.<RepairApply>query().lambda().eq(RepairApply::getDeviceId, repairApply.getDeviceId()).eq(RepairApply::getApplyStatus, Integer.valueOf(RepairApplyStatusEnum.Y1.getType())));
            /*
            List<RepairApply> y1List = list((Wrapper) ((LambdaQueryWrapper) Wrappers.query().lambda().eq((v0) -> {
                return v0.getDeviceId();
            }, repairApply.getDeviceId())).eq((v0) -> {
                return v0.getApplyStatus();
            }, Integer.valueOf(RepairApplyStatusEnum.Y1.getType())));*/
            List<RepairApply> y2List = list(Wrappers.<RepairApply>query().lambda().eq(RepairApply::getDeviceId, repairApply.getDeviceId()).eq(RepairApply::getApplyStatus, Integer.valueOf(RepairApplyStatusEnum.Y2.getType())));
            /*
            List<RepairApply> y2List = list((Wrapper) ((LambdaQueryWrapper) Wrappers.query().lambda().eq((v0) -> {
                return v0.getDeviceId();
            }, repairApply.getDeviceId())).eq((v0) -> {
                return v0.getApplyStatus();
            }, Integer.valueOf(RepairApplyStatusEnum.Y2.getType())));
            */
            List<RepairRecord> r1List = this.repairRecordService.list(Wrappers.<RepairRecord>query().lambda().eq(RepairRecord::getDeviceId, repairApply.getDeviceId()).eq(RepairRecord::getRecordStatus, Integer.valueOf(RepairRecordEnum.R1.getType())));
            /*
            List<RepairRecord> r1List = this.repairRecordService.list((Wrapper) ((LambdaQueryWrapper) Wrappers.query().lambda().eq((v0) -> {
                return v0.getDeviceId();
            }, repairApply.getDeviceId())).eq((v0) -> {
                return v0.getRecordStatus();
            }, Integer.valueOf(RepairRecordEnum.R1.getType())));*/
            this.machineService.updateMachineRepairPriority(repairApply.getDeviceId(), r1List, y2List, y1List);
        }
        return true;
    }

    private boolean checkApplyStatus(List<Long> ids) {
    	List<RepairApply> list = list(Wrappers.<RepairApply>query().lambda().ne(RepairApply::getApplyStatus, Integer.valueOf(RepairApplyStatusEnum.Y1.getType())).in(RepairApply::getId, ids));
    	/*
        List<RepairApply> list = list((Wrapper) ((LambdaQueryWrapper) Wrappers.query().lambda().ne((v0) -> {
            return v0.getApplyStatus();
        }, Integer.valueOf(RepairApplyStatusEnum.Y1.getType()))).in((v0) -> {
            return v0.getId();
        }, ids));*/
        return Func.isEmpty(list);
    }

    @Override // org.springblade.modules.tpm.service.IRepairApplyService
    public boolean checkRepairApplyStatus(Long id) {
    	RepairApply repairApply = this.baseMapper.selectOne(Wrappers.<RepairApply>query().lambda().eq(RepairApply::getId, id).eq(RepairApply::getApplyStatus, Integer.valueOf(RepairApplyStatusEnum.Y1.getType())));
    	/*
        RepairApply repairApply = (RepairApply) this.baseMapper.selectOne((Wrapper) ((LambdaQueryWrapper) Wrappers.query().lambda().eq((v0) -> {
            return v0.getId();
        }, id)).eq((v0) -> {
            return v0.getApplyStatus();
        }, Integer.valueOf(RepairApplyStatusEnum.Y1.getType())));*/
        return Func.isNotEmpty(repairApply);
    }

    @Override // org.springblade.modules.tpm.service.IRepairApplyService
    @Transactional(rollbackFor = {Exception.class})
    public boolean implementApply(Long id) {
        if (!checkRepairApplyStatus(id)) {
            throw new ServiceException(MessageUtils.message("cps.tpm.repair.execution.apply.status.is.pending", new Object[0]));
        }
        RepairApply repairApply = getOne(Wrappers.<RepairApply>query().lambda().eq(RepairApply::getId, id));
        /*
        RepairApply repairApply = (RepairApply) getOne((Wrapper) Wrappers.query().lambda().eq((v0) -> {
            return v0.getId();
        }, id));*/
        if (Func.isEmpty(repairApply)) {
            throw new ServiceException(MessageUtils.message("cps.tpm.repair.apply.not.exists", new Object[0]));
        }
        repairApply.setApplyStatus(Integer.valueOf(RepairApplyStatusEnum.Y2.getType()));
        repairApply.setStartTime(LocalDateTime.now());
        this.machineService.implementRepairApply(repairApply.getDeviceId(), Integer.valueOf(DeviceRepairStatusEnum.IN_MAINTENANCE.getType()));
        return updateById(repairApply);
    }

    @Override // org.springblade.modules.tpm.service.IRepairApplyService
    @Transactional(rollbackFor = {Exception.class})
    public RepairApply updateRepairApply(RepairApplyUpdateVO repairApplyUpdateVO) {
        RepairApply re = (RepairApply) getById(repairApplyUpdateVO.getId());
        if (Func.isNull(re)) {
            throw new ServiceException(MessageUtils.message("cps.tpm.repair.apply.not.exists", new Object[0]));
        }
        if (!checkRepairApplyStatus(repairApplyUpdateVO.getId())) {
            throw new ServiceException(MessageUtils.message("cps.tpm.repair.execution.apply.status.is.pending", new Object[0]));
        }
        RepairApply repairApply = RepairApplyConvert.INSTANCE.convertUpdate(repairApplyUpdateVO);
        updateById(repairApply);
        if (Func.isNotEmpty(repairApplyUpdateVO.getFileAddDTOList())) {
        	List<RepairApplyFile> oldFiles = this.iRepairApplyFileService.list(Wrappers.<RepairApplyFile>query().lambda().eq(RepairApplyFile::getRepairApplyId, repairApplyUpdateVO.getId()));
        	/*
            List<RepairApplyFile> oldFiles = this.iRepairApplyFileService.list((Wrapper) Wrappers.query().lambda().eq((v0) -> {
                return v0.getRepairApplyId();
            }, repairApplyUpdateVO.getId()));
            */
            if (!Func.isNull(oldFiles)) {
                this.iRepairApplyFileService.removeByIds(oldFiles.stream().map((v0) -> {
                    return v0.getId();
                }).collect(Collectors.toList()));
            }
            List<RepairApplyFile> newFiles = RepairApplyFileConvert.INSTANCE.convert(repairApplyUpdateVO.getFileAddDTOList());
            newFiles.forEach(s -> {
                s.setRepairApplyId(repairApply.getId());
            });
            this.iRepairApplyFileService.saveBatch(newFiles);
        } else {
        	List<RepairApplyFile> oldFiles2 = this.iRepairApplyFileService.list(Wrappers.<RepairApplyFile>query().lambda().eq(RepairApplyFile::getRepairApplyId, repairApplyUpdateVO.getId()));
        	/*
            List<RepairApplyFile> oldFiles2 = this.iRepairApplyFileService.list(Wrappers.<RepairApplyFilequery().lambda().eq((v0) -> {
                return v0.getRepairApplyId();
            }, repairApplyUpdateVO.getId()));*/
            if (!Func.isNull(oldFiles2)) {
                this.iRepairApplyFileService.removeByIds((Collection) oldFiles2.stream().map((v0) -> {
                    return v0.getId();
                }).collect(Collectors.toList()));
            }
        }
        updateApplyMalFunction(repairApplyUpdateVO.getMalfunctionId(), repairApplyUpdateVO.getMalfunctionName(), repairApplyUpdateVO.getMalfunctionCode(), Integer.valueOf(ActionEnum.UPDATE_MAL.getType()));
        return re;
    }

    @Override // org.springblade.modules.tpm.service.IRepairApplyService
    public RepairFileVO getFileAndDes(Long id) {
        RepairApply repairApply = (RepairApply) getById(id);
        if (Func.isNull(repairApply)) {
            throw new ServiceException(MessageUtils.message("cps.tpm.repair.apply.not.exists", new Object[0]));
        }
        List<RepairApplyFile> files = this.iRepairApplyFileService.list(Wrappers.<RepairApplyFile>query().lambda().eq(RepairApplyFile::getRepairApplyId, id));
        /*
        List<RepairApplyFile> files = this.iRepairApplyFileService.list((Wrapper) Wrappers.query().lambda().eq((v0) -> {
            return v0.getRepairApplyId();
        }, id));*/
        RepairFileVO repairFileVo = new RepairFileVO();
        if (!Func.isNull(repairApply.getDescription())) {
            repairFileVo.setDescription(repairApply.getDescription());
        }
        if (!Func.isNull(files)) {
        	repairFileVo.setFileAddDTOList(files.stream().map(RepairApplyFileConvert.INSTANCE::convert).collect(Collectors.toList()));
        	/*
            Stream<RepairApplyFile> stream = files.stream();
            RepairApplyFileConvert repairApplyFileConvert = RepairApplyFileConvert.INSTANCE;
            repairApplyFileConvert.getClass();
            repairFileVo.setFileAddDTOList((List) stream.map(this::convert).collect(Collectors.toList()));*/
        } else {
            repairFileVo.setFileAddDTOList(new ArrayList<>());
        }
        return repairFileVo;
    }

    @Override // org.springblade.modules.tpm.service.IRepairApplyService
    public List<ApplyCodeVO> queryApplyCode() {
    	List<RepairApply> list = list(Wrappers.<RepairApply>query().lambda().eq(RepairApply::getApplyStatus, Integer.valueOf(RepairApplyStatusEnum.Y2.getType())));
    	/*
        List<RepairApply> list = list((Wrapper) Wrappers.query().lambda().eq((v0) -> {
            return v0.getApplyStatus();
        }, Integer.valueOf(RepairApplyStatusEnum.Y2.getType())));*/
        if (Func.isNotEmpty(list)) {
            return list.stream().map(i -> {
                ApplyCodeVO applyCodeVo = new ApplyCodeVO();
                applyCodeVo.setId(i.getId());
                applyCodeVo.setApplyCode(i.getApplyCode());
                return applyCodeVo;
            }).collect(Collectors.toList());
        }
        return new ArrayList();
    }

    @Override // org.springblade.modules.tpm.service.IRepairApplyService
    public List<RepairApply> getRepairApplyByMalId(Long malId) {
    	List<RepairApply> repairApplyList = list(Wrappers.<RepairApply>query().lambda()
    	        .eq(RepairApply::getMalfunctionId, malId)
    	        .and(i -> i.ne(RepairApply::getApplyStatus, Integer.valueOf(RepairApplyStatusEnum.Y4.getType()))));
    	/*
        List<RepairApply> repairApplyList = list((Wrapper) ((LambdaQueryWrapper) Wrappers.query().lambda().eq((v0) -> {
            return v0.getMalfunctionId();
        }, malId)).and(i -> {
            LambdaQueryWrapper lambdaQueryWrapper = (LambdaQueryWrapper) i.ne((v0) -> {
                return v0.getApplyStatus();
            }, Integer.valueOf(RepairApplyStatusEnum.Y4.getType()));
        }));*/
        if (Func.isNull(repairApplyList)) {
            throw new ServiceException(MessageUtils.message("cps.tpm.repair.apply.malfunction.not.exists", new Object[0]));
        }
        return repairApplyList;
    }

    @Override // org.springblade.modules.tpm.service.IRepairApplyService
    public boolean updateApplyMalFunction(Long malId, String malName, String malCode, Integer action) {
        List<RepairApply> repairApplyByMalList = getRepairApplyByMalId(malId);
        if (Func.isNotEmpty(repairApplyByMalList)) {
            List<RepairApply> collect = null;
            if (action.equals(Integer.valueOf(ActionEnum.UPDATE_MAL.getType()))) {
                collect = repairApplyByMalList.stream().map(i -> {
                    i.setMalfunctionId(malId);
                    i.setMalfunctionName(malName);
                    i.setMalfunctionCode(malCode);
                    return i;
                }).collect(Collectors.toList());
            } else if (action.equals(Integer.valueOf(ActionEnum.DELETE_MAL.getType()))) {
                collect = repairApplyByMalList.stream().peek(i2 -> {
                    i2.setMalfunctionId(null);
                    i2.setMalfunctionName(null);
                    i2.setMalfunctionCode(null);
                }).collect(Collectors.toList());
            }
            updateBatchById(collect);
            return true;
        }
        return false;
    }

    @Override // org.springblade.modules.tpm.service.IRepairApplyService
    public boolean updateApplyByRecord(Long applyId, Long malId, String malName, String malCode) {
        RepairApply repairApply = (RepairApply) getById(applyId);
        if (Func.isNull(repairApply)) {
            throw new ServiceException(MessageUtils.message("cps.tpm.repair.apply.not.exists", new Object[0]));
        }
        repairApply.setMalfunctionId(malId).setMalfunctionCode(malCode).setMalfunctionName(malName);
        return updateById(repairApply);
    }

    @Override // org.springblade.modules.tpm.service.IRepairApplyService
    public List<RepairApplyExcelVO> exportRepairApply(RepairApplyExportVO repairApplyExportVO) {
        List<RepairApplyExcelVO> repairApplyExcelVoList = this.baseMapper.exportApplyVo(repairApplyExportVO, AuthUtil.getTenantId());
        if (Func.isNotEmpty(repairApplyExcelVoList)) {
            repairApplyExcelVoList.forEach(i -> {
                if (Func.isNotBlank(i.getUrgency())) {
                    if (i.getUrgency().equals(String.valueOf(UrgencyEnum.U1.getType()))) {
                        i.setUrgency(UrgencyEnum.U1.getDesc());
                    } else if (i.getUrgency().equals(String.valueOf(UrgencyEnum.U2.getType()))) {
                        i.setUrgency(UrgencyEnum.U2.getDesc());
                    } else {
                        i.setUrgency(UrgencyEnum.U3.getDesc());
                    }
                }
            });
            return repairApplyExcelVoList;
        }
        return new ArrayList();
    }

    @Override // org.springblade.modules.tpm.service.IRepairApplyService
    public IPage<RepairApplyVO> applyWaringPage(RepairApplySearchVO repairApplySearchVO, Query query) {
        IPage<RepairApplyVO> page = Condition.getPage(query);
        List<RepairApplyVO> vos = this.baseMapper.pageRepairApplyToday(query, page, repairApplySearchVO);
        return page.setRecords(vos);
    }

    @Override // org.springblade.modules.tpm.service.IRepairApplyService
    public Long countApplyNum() {
    	Long count = Long.valueOf(count(Wrappers.<RepairApply>lambdaQuery()
    	          .eq(RepairApply::getApplyStatus, Integer.valueOf(RepairApplyStatusEnum.Y2.getType()))
    	          .or()
    	          .eq(RepairApply::getApplyStatus, Integer.valueOf(RepairApplyStatusEnum.Y1.getType()))));
    	/*
        Long count = Long.valueOf(count((Wrapper) ((LambdaQueryWrapper) ((LambdaQueryWrapper) Wrappers.lambdaQuery().eq((v0) -> {
            return v0.getApplyStatus();
        }, Integer.valueOf(RepairApplyStatusEnum.Y2.getType()))).or()).eq((v0) -> {
            return v0.getApplyStatus();
        }, Integer.valueOf(RepairApplyStatusEnum.Y1.getType()))));
        */
        return (Long) Optional.of(count).orElse(0L);
    }

    @Override // org.springblade.modules.tpm.service.IRepairApplyService
    public RepairApplyDetailVO detail(Long id) {
        RepairApplyDetailVO repairApplyDetailVO = detailApply(id);
        RepairRecord bean = this.repairRecordService.getOne(Wrappers.<RepairRecord>query().lambda().eq(RepairRecord::getRepairApplyId, id));
        /*
        RepairRecord bean = (RepairRecord) this.repairRecordService.getOne((Wrapper) Wrappers.query().lambda().eq((v0) -> {
            return v0.getRepairApplyId();
        }, id));*/
        if (bean != null) {
            repairApplyDetailVO.setRepairRecordDetailVO(this.repairRecordService.detailRecord(bean.getId()));
        }
        return repairApplyDetailVO;
    }

    private void sendMessage(RepairApply repairApply, NotifyBusinessSendDTO notifyBusinessSend) {
        BusinessSend businessSend = this.businessSendFactory.getBusinessSend(NotifyConstant.MAINTENANCE_APPLY);
        businessSend.saveState(repairApply, notifyBusinessSend);
    }

    @Override // org.springblade.modules.tpm.service.IRepairApplyService
    public IPage<RepairApplyVO> getPageApplyForHmi(Long workstationId, Query query) {
        WorkstationVO workstationVO = this.workstationService.getDetail(workstationId);
        return this.baseMapper.getPageApplyForHmi(workstationVO.getMachineId(), Condition.getPage(query));
    }
}