package com.qianwen.smartman.modules.tpm.service.impl;
|
|
import java.util.ArrayList;
|
import java.util.Collections;
|
import java.util.Comparator;
|
import java.util.Date;
|
import java.util.Iterator;
|
import java.util.List;
|
import java.util.Optional;
|
import java.util.stream.Collectors;
|
|
import org.slf4j.Logger;
|
import org.slf4j.LoggerFactory;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
|
import com.baomidou.mybatisplus.core.metadata.IPage;
|
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
|
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
|
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.Func;
|
import com.qianwen.smartman.common.utils.MessageUtils;
|
import com.qianwen.smartman.modules.cps.service.IMachineService;
|
import com.qianwen.smartman.modules.cps.vo.RepairRecordMaterialAddVO;
|
import com.qianwen.smartman.modules.system.service.ICodeGeneratorService;
|
import com.qianwen.smartman.modules.tpm.convert.MaterialRecordConvert;
|
import com.qianwen.smartman.modules.tpm.convert.RepairApplyFileConvert;
|
import com.qianwen.smartman.modules.tpm.convert.RepairRecordConvert;
|
import com.qianwen.smartman.modules.tpm.convert.RepairRecordDetailConvert;
|
import com.qianwen.smartman.modules.tpm.convert.RepairRecordFileConvert;
|
import com.qianwen.smartman.modules.tpm.dto.RepairApplyFileAddDTO;
|
import com.qianwen.smartman.modules.tpm.dto.RepairRecordFileAddDTO;
|
import com.qianwen.smartman.modules.tpm.dto.RepairRecordSearchDTO;
|
import com.qianwen.smartman.modules.tpm.entity.DeviceMaterialRecord;
|
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.entity.RepairRecordFile;
|
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.RepairRecordTypeEnum;
|
import com.qianwen.smartman.modules.tpm.enums.UrgencyEnum;
|
import com.qianwen.smartman.modules.tpm.mapper.RepairRecordMapper;
|
import com.qianwen.smartman.modules.tpm.service.IDeviceMaterialRecordService;
|
import com.qianwen.smartman.modules.tpm.service.IRepairApplyFileService;
|
import com.qianwen.smartman.modules.tpm.service.IRepairApplyService;
|
import com.qianwen.smartman.modules.tpm.service.IRepairRecordFileService;
|
import com.qianwen.smartman.modules.tpm.service.IRepairRecordService;
|
import com.qianwen.smartman.modules.tpm.utils.DateUtils;
|
import com.qianwen.smartman.modules.tpm.vo.ApplyRecordMaterialVO;
|
import com.qianwen.smartman.modules.tpm.vo.MaterialVO;
|
import com.qianwen.smartman.modules.tpm.vo.RepairApplyDetailVO;
|
import com.qianwen.smartman.modules.tpm.vo.RepairRecordAddVO;
|
import com.qianwen.smartman.modules.tpm.vo.RepairRecordDetailVO;
|
import com.qianwen.smartman.modules.tpm.vo.RepairRecordExportVO;
|
import com.qianwen.smartman.modules.tpm.vo.RepairRecordLookVO;
|
import com.qianwen.smartman.modules.tpm.vo.RepairRecordMaterialVO;
|
import com.qianwen.smartman.modules.tpm.vo.RepairRecordTodaySearchVO;
|
import com.qianwen.smartman.modules.tpm.vo.RepairRecordUpdateVO;
|
import com.qianwen.smartman.modules.tpm.vo.RepairRecordVO;
|
import com.qianwen.smartman.modules.tpm.vo.excel.RepairRecordExcelVO;
|
|
@Service
|
/* loaded from: blade-api.jar:BOOT-INF/classes/org/springblade/modules/tpm/service/impl/RepairRecordServiceImpl.class */
|
public class RepairRecordServiceImpl extends ServiceImpl<RepairRecordMapper, RepairRecord> implements IRepairRecordService {
|
private static final Logger log = LoggerFactory.getLogger(RepairRecordServiceImpl.class);
|
private final IRepairApplyService repairApplyService;
|
private final IRepairApplyFileService repairApplyFileService;
|
private final IRepairRecordFileService repairRecordFileService;
|
private final IDeviceMaterialRecordService deviceMaterialRecordService;
|
private final IMachineService machineService;
|
private final RepairRecordMapper repairRecordMapper;
|
private final ICodeGeneratorService codeGeneratorService;
|
|
|
public RepairRecordServiceImpl(final IRepairApplyService repairApplyService, final IRepairApplyFileService repairApplyFileService, final IRepairRecordFileService repairRecordFileService, final IDeviceMaterialRecordService deviceMaterialRecordService, final IMachineService machineService, final RepairRecordMapper repairRecordMapper, final ICodeGeneratorService codeGeneratorService) {
|
this.repairApplyService = repairApplyService;
|
this.repairApplyFileService = repairApplyFileService;
|
this.repairRecordFileService = repairRecordFileService;
|
this.deviceMaterialRecordService = deviceMaterialRecordService;
|
this.machineService = machineService;
|
this.repairRecordMapper = repairRecordMapper;
|
this.codeGeneratorService = codeGeneratorService;
|
}
|
|
@Override // org.springblade.modules.tpm.service.IRepairRecordService
|
@Transactional(rollbackFor = {Exception.class})
|
public RepairRecord createRepairRecord(RepairRecordAddVO repairRecordAddVO) {
|
RepairRecord repairRecord = RepairRecordConvert.INSTANCE.convert(repairRecordAddVO);
|
if (Func.isBlank(repairRecord.getRecordCode())) {
|
String code = this.codeGeneratorService.getGeneratorCode(repairRecordAddVO, MetaTypeEnum.REPAIR_RECORD.getCode());
|
log.info("维修记录编码规则生成的code:{}", code + " ," + code.length());
|
repairRecord.setRecordCode(code);
|
}
|
if (checkRecordCode(repairRecord.getRecordCode())) {
|
throw new ServiceException(MessageUtils.message("cps.tpm.record.apply.code.already.exists", new Object[0]));
|
}
|
if (repairRecordAddVO.getRecordType().equals(Integer.valueOf(RepairRecordTypeEnum.T1.getType()))) {
|
repairRecord.setRecordType(Integer.valueOf(RepairRecordTypeEnum.T1.getType()));
|
} else {
|
repairRecord.setRecordType(Integer.valueOf(RepairRecordTypeEnum.T2.getType()));
|
if (!checkApplyCode(repairRecordAddVO.getRepairApplyId())) {
|
throw new ServiceException(MessageUtils.message("cps.tpm.repair.apply.num.already.registered", new Object[0]));
|
}
|
repairRecord.setRepairApplyId(repairRecordAddVO.getRepairApplyId());
|
RepairApply repairApply = (RepairApply) this.repairApplyService.getById(repairRecordAddVO.getRepairApplyId());
|
if (Func.isNull(repairApply)) {
|
throw new ServiceException(MessageUtils.message("cps.tpm.repair.apply.not.exists", new Object[0]));
|
}
|
repairApply.setApplyStatus(Integer.valueOf(RepairApplyStatusEnum.Y3.getType()));
|
this.repairApplyService.updateById(repairApply);
|
}
|
repairRecord.setRecordStatus(Integer.valueOf(RepairRecordEnum.R1.getType()));
|
this.machineService.renewMachineRepairStatus(repairRecord.getDeviceId(), Integer.valueOf(DeviceRepairStatusEnum.TO_BE_CONFIRM.getType()));
|
save(repairRecord);
|
if (Func.isNotEmpty(repairRecordAddVO.getRecordFileList())) {
|
List<RepairRecordFile> repairApplyFileList = RepairRecordFileConvert.INSTANCE.convert(repairRecordAddVO.getRecordFileList());
|
repairApplyFileList.forEach(s -> {
|
s.setRepairRecordId(repairRecord.getId());
|
});
|
this.repairRecordFileService.saveBatch(repairApplyFileList);
|
}
|
if (Func.isNotEmpty(repairRecordAddVO.getMaterialVOList())) {
|
List<RepairRecordMaterialAddVO> materialAddDTOList = repairRecordAddVO.getMaterialVOList();
|
materialAddDTOList.forEach(i -> {
|
i.setRecordId(repairRecord.getId());
|
i.setBizType(1);
|
i.setDeviceId(repairRecord.getDeviceId());
|
i.setUserId(repairRecordAddVO.getRepairUserId());
|
i.setUserName(repairRecordAddVO.getRepairUserName());
|
i.setUsageTime(new Date());
|
});
|
this.deviceMaterialRecordService.createDeviceMaterialRecord(materialAddDTOList);
|
}
|
return repairRecord;
|
}
|
|
@Override // org.springblade.modules.tpm.service.IRepairRecordService
|
@Transactional(rollbackFor = {Exception.class})
|
public RepairRecord updateRepairRecord(RepairRecordUpdateVO repairRecordUpdateVO) {
|
if (!checkRecordStatus(repairRecordUpdateVO.getId())) {
|
throw new ServiceException(MessageUtils.message("cps.tpm.repair.record.status.is.edit", new Object[0]));
|
}
|
RepairRecord repairRecord = RepairRecordConvert.INSTANCE.convert(repairRecordUpdateVO);
|
updateById(repairRecord);
|
if (Func.isNotEmpty(repairRecordUpdateVO.getRecordFileList())) {
|
List<RepairRecordFile> oldFiles = this.repairRecordFileService.list(Wrappers.<RepairRecordFile>query().lambda().eq(RepairRecordFile::getRepairRecordId, repairRecordUpdateVO.getId()));
|
/*
|
List<RepairRecordFile> oldFiles = this.repairRecordFileService.list((Wrapper) Wrappers.query().lambda().eq((v0) -> {
|
return v0.getRepairRecordId();
|
}, repairRecordUpdateVO.getId()));
|
if (!Func.isNull(oldFiles)) {
|
this.repairRecordFileService.removeByIds((Collection) oldFiles.stream().map((v0) -> {
|
return v0.getId();
|
}).collect(Collectors.toList()));
|
}*/
|
List<RepairRecordFile> newFiles = RepairRecordFileConvert.INSTANCE.convert(repairRecordUpdateVO.getRecordFileList());
|
newFiles.forEach(s -> {
|
s.setRepairRecordId(repairRecord.getId());
|
});
|
this.repairRecordFileService.saveBatch(newFiles);
|
} else {
|
List<RepairRecordFile> oldFiles2 = this.repairRecordFileService.list(Wrappers.<RepairRecordFile>query().lambda().eq(RepairRecordFile::getRepairRecordId, repairRecordUpdateVO.getId()));
|
/*
|
List<RepairRecordFile> oldFiles2 = this.repairRecordFileService.list((Wrapper) Wrappers.query().lambda().eq((v0) -> {
|
return v0.getRepairRecordId();
|
}, repairRecordUpdateVO.getId()));*/
|
if (!Func.isNull(oldFiles2)) {
|
this.repairRecordFileService.removeByIds(oldFiles2.stream().map((v0) -> {
|
return v0.getId();
|
}).collect(Collectors.toList()));
|
}
|
}
|
RepairApply repairApply = this.repairApplyService.getById(repairRecord.getRepairApplyId());
|
if (Func.isNotEmpty(repairRecordUpdateVO.getMaterialVOList())) {
|
List<RepairRecordMaterialAddVO> materialAddDTOList = repairRecordUpdateVO.getMaterialVOList();
|
materialAddDTOList.forEach(i -> {
|
i.setRecordId(repairRecord.getId());
|
});
|
this.deviceMaterialRecordService.updateDeviceMaterialRecord(materialAddDTOList);
|
} else {
|
this.deviceMaterialRecordService.deleteDeviceMaterialRecordByRecordId(Collections.singletonList(repairRecord.getId()));
|
}
|
return repairRecord;
|
}
|
|
@Override // org.springblade.modules.tpm.service.IRepairRecordService
|
public IPage<RepairRecordVO> getPageRecord(RepairRecordSearchDTO repairRecordSearchDTO, Query query) {
|
IPage<RepairRecord> pages = page(Condition.getPage(query), Wrappers.<RepairRecord>lambdaQuery()
|
.eq(Func.isNotEmpty(AuthUtil.getTenantId()), RepairRecord::getTenantId, AuthUtil.getTenantId())
|
.and(Func.isNotEmpty(repairRecordSearchDTO.getDeviceTypeId()), i -> i.eq(RepairRecord::getDeviceTypeId, repairRecordSearchDTO.getDeviceTypeId()))
|
.and(Func.isNotEmpty(repairRecordSearchDTO.getRecordStatus()), i -> i.eq(RepairRecord::getRecordStatus, repairRecordSearchDTO.getRecordStatus()))
|
.and(Func.isNotEmpty(repairRecordSearchDTO.getKeyWords()), i -> i.like(RepairRecord::getRecordCode, repairRecordSearchDTO.getKeyWords()).or().like(RepairRecord::getDeviceCode, repairRecordSearchDTO.getKeyWords()).or().like(RepairRecord::getRepairApplyId, getApplyId(repairRecordSearchDTO.getKeyWords())).or().like(RepairRecord::getDeviceName, repairRecordSearchDTO.getKeyWords())));
|
|
/*
|
IPage<RepairRecord> pages = page(Condition.getPage(query), Wrappers.lambdaQuery().eq(Func.isNotEmpty(AuthUtil.getTenantId()), (v0) -> {
|
return v0.getTenantId();
|
}, AuthUtil.getTenantId()).and(Func.isNotEmpty(repairRecordSearchDTO.getDeviceTypeId()), i -> {
|
LambdaQueryWrapper lambdaQueryWrapper = (LambdaQueryWrapper) i.eq((v0) -> {
|
return v0.getDeviceTypeId();
|
}, repairRecordSearchDTO.getDeviceTypeId());
|
}).and(Func.isNotEmpty(repairRecordSearchDTO.getRecordStatus()), i2 -> {
|
LambdaQueryWrapper lambdaQueryWrapper = (LambdaQueryWrapper) i2.eq((v0) -> {
|
return v0.getRecordStatus();
|
}, repairRecordSearchDTO.getRecordStatus());
|
}).and(Func.isNotEmpty(repairRecordSearchDTO.getKeyWords()), i3 -> {
|
LambdaQueryWrapper lambdaQueryWrapper = (LambdaQueryWrapper) ((LambdaQueryWrapper) ((LambdaQueryWrapper) ((LambdaQueryWrapper) ((LambdaQueryWrapper) ((LambdaQueryWrapper) ((LambdaQueryWrapper) i3.like((v0) -> {
|
return v0.getRecordCode();
|
}, repairRecordSearchDTO.getKeyWords())).or()).like((v0) -> {
|
return v0.getDeviceCode();
|
}, repairRecordSearchDTO.getKeyWords())).or()).like((v0) -> {
|
return v0.getRepairApplyId();
|
}, getApplyId(repairRecordSearchDTO.getKeyWords()))).or()).like((v0) -> {
|
return v0.getDeviceName();
|
}, repairRecordSearchDTO.getKeyWords());
|
}));*/
|
IPage<RepairRecordVO> repairRecordVoIPage = RepairRecordConvert.INSTANCE.convert( pages);
|
repairRecordVoIPage.getRecords().forEach(i4 -> {
|
if (Func.isNotEmpty(i4.getRepairApplyId())) {
|
Long repairApplyId = i4.getRepairApplyId();
|
RepairApply repairApply = (RepairApply) this.repairApplyService.getById(repairApplyId);
|
if (Func.isNotEmpty(repairApply)) {
|
i4.setApplyCode(repairApply.getApplyCode());
|
i4.setUrgency(repairApply.getUrgency());
|
i4.setApplyUserId(repairApply.getApplyUserId());
|
i4.setApplyUserName(repairApply.getApplyUserName());
|
i4.setDescription(repairApply.getDescription());
|
}
|
}
|
});
|
List<RepairRecordVO> records = repairRecordVoIPage.getRecords();
|
|
records.sort(Comparator.comparing(RepairRecordVO::getRepairStartTime, Comparator.nullsFirst(Date::compareTo)).reversed());
|
records.sort(Comparator.comparing(RepairRecordVO::getUrgency, Comparator.nullsFirst(Integer::compareTo)).reversed());
|
records.sort(Comparator.comparing(RepairRecordVO::getRecordStatus, Comparator.nullsFirst(Integer::compareTo)));
|
|
/*
|
records.sort(Comparator.comparing((v0) -> {
|
return v0.getRepairStartTime();
|
}, Comparator.nullsFirst((v0, v1) -> {
|
return v0.compareTo(v1);
|
})).reversed());
|
records.sort(Comparator.comparing((v0) -> {
|
return v0.getUrgency();
|
}, Comparator.nullsFirst((v0, v1) -> {
|
return v0.compareTo(v1);
|
})).reversed());
|
records.sort(Comparator.comparing((v0) -> {
|
return v0.getRecordStatus();
|
}, Comparator.nullsFirst((v0, v1) -> {
|
return v0.compareTo(v1);
|
})));*/
|
repairRecordVoIPage.setRecords(records);
|
return repairRecordVoIPage;
|
}
|
|
@Override // org.springblade.modules.tpm.service.IRepairRecordService
|
public IPage<RepairRecordVO> getPageRepairRecord(RepairRecordLookVO searchDTO, Query query) {
|
IPage<RepairRecordVO> page = Condition.getPage(query);
|
List<RepairRecordVO> repairRecordPages = this.repairRecordMapper.getRepairRecordPages(searchDTO, page);
|
if (Func.isNotEmpty(repairRecordPages)) {
|
return page.setRecords(repairRecordPages);
|
}
|
return page.setRecords(new ArrayList());
|
}
|
|
private Long getApplyId(String applyCode) {
|
RepairApply one = this.repairApplyService.getOne(Wrappers.<RepairApply>query().lambda().eq(RepairApply::getApplyCode, applyCode));
|
/*
|
RepairApply one = (RepairApply) this.repairApplyService.getOne((Wrapper) Wrappers.query().lambda().eq((v0) -> {
|
return v0.getApplyCode();
|
}, applyCode));*/
|
if (Func.isNotEmpty(one)) {
|
return one.getId();
|
}
|
return null;
|
}
|
|
@Override // org.springblade.modules.tpm.service.IRepairRecordService
|
public RepairRecordDetailVO detailRecord(Long id) {
|
RepairRecord repairRecord = (RepairRecord) getById(id);
|
if (Func.isEmpty(repairRecord)) {
|
throw new ServiceException(MessageUtils.message("cps.tpm.repair.record.not.exists", new Object[0]));
|
}
|
RepairRecordDetailVO repairRecordDetailVo = RepairRecordDetailConvert.INSTANCE.convert(repairRecord);
|
RepairApply repairApply = (RepairApply) this.repairApplyService.getById(repairRecord.getRepairApplyId());
|
if (Func.isNotEmpty(repairApply) && repairRecord.getRecordType().equals(Integer.valueOf(RepairRecordTypeEnum.T2.getType()))) {
|
RepairApplyDetailVO repairApplyDetailVo = this.repairApplyService.detailApply(repairRecord.getRepairApplyId());
|
repairRecordDetailVo.setRepairApplyDetailVo(repairApplyDetailVo);
|
}
|
List<RepairRecordMaterialVO> recordByRecord = this.deviceMaterialRecordService.getRecordByRecordId(id);
|
if (Func.isNotEmpty(recordByRecord)) {
|
repairRecordDetailVo.setMaterialVOList(recordByRecord);
|
} else {
|
repairRecordDetailVo.setMaterialVOList(new ArrayList<>());
|
}
|
List<RepairRecordFile> fileList = this.repairRecordFileService.list(Wrappers.<RepairRecordFile>lambdaQuery().eq(RepairRecordFile::getRepairRecordId, id));
|
/*
|
List<RepairRecordFile> fileList = this.repairRecordFileService.list((Wrapper) Wrappers.lambdaQuery().eq((v0) -> {
|
return v0.getRepairRecordId();
|
}, id));*/
|
List<RepairRecordFileAddDTO> fileAddDtoList = fileList.stream().map(RepairRecordFileConvert.INSTANCE::convert).collect(Collectors.toList());
|
/*
|
Stream<RepairRecordFile> stream = fileList.stream();
|
RepairRecordFileConvert repairRecordFileConvert = RepairRecordFileConvert.INSTANCE;
|
repairRecordFileConvert.getClass();
|
List<RepairRecordFileAddDTO> fileAddDtoList = (List) stream.map(this::convert).collect(Collectors.toList());*/
|
if (Func.isNotEmpty(fileAddDtoList)) {
|
repairRecordDetailVo.setRecordFileList(fileAddDtoList);
|
} else {
|
repairRecordDetailVo.setRecordFileList(new ArrayList<>());
|
}
|
return repairRecordDetailVo;
|
}
|
|
@Override // org.springblade.modules.tpm.service.IRepairRecordService
|
@Transactional(rollbackFor = {Exception.class})
|
public boolean confirmRecord(Long id) {
|
RepairRecord repairRecord = (RepairRecord) getById(id);
|
if (Func.isNull(repairRecord)) {
|
throw new ServiceException(MessageUtils.message("cps.tpm.repair.record.not.exists", new Object[0]));
|
}
|
if (!repairRecord.getRecordStatus().equals(Integer.valueOf(RepairRecordEnum.R1.getType()))) {
|
throw new ServiceException(MessageUtils.message("cps.tpm.repair.record.not.to.be.confirmed", new Object[0]));
|
}
|
repairRecord.setRecordStatus(Integer.valueOf(RepairRecordEnum.R2.getType()));
|
RepairApply repairApply = (RepairApply) this.repairApplyService.getById(repairRecord.getRepairApplyId());
|
if (repairRecord.getRecordType().equals(Integer.valueOf(RepairRecordTypeEnum.T2.getType())) && Func.isNull(repairRecord.getRepairApplyId())) {
|
throw new ServiceException(MessageUtils.message("cps.tpm.repair.apply.not.exists", new Object[0]));
|
}
|
if (repairRecord.getRecordType().equals(Integer.valueOf(RepairRecordTypeEnum.T2.getType()))) {
|
repairApply.setApplyStatus(Integer.valueOf(RepairApplyStatusEnum.Y4.getType()));
|
this.repairApplyService.updateById(repairApply);
|
}
|
boolean update = updateById(repairRecord);
|
List<RepairRecord> toBeConfirmedList = list(Wrappers.<RepairRecord>lambdaQuery().eq(RepairRecord::getDeviceId, repairRecord.getDeviceId()).eq(RepairRecord::getRecordStatus, Integer.valueOf(RepairRecordEnum.R1.getType())));
|
List<RepairApply> inMaintenanceList = this.repairApplyService.list(Wrappers.<RepairApply>lambdaQuery().eq(RepairApply::getDeviceId, repairRecord.getDeviceId()).eq(RepairApply::getApplyStatus, Integer.valueOf(RepairApplyStatusEnum.Y2.getType())));
|
List<RepairApply> toBeRepairedList = this.repairApplyService.list(Wrappers.<RepairApply>lambdaQuery().eq(RepairApply::getDeviceId, repairRecord.getDeviceId()).eq(RepairApply::getApplyStatus, Integer.valueOf(RepairApplyStatusEnum.Y1.getType())));
|
/*
|
List<RepairRecord> toBeConfirmedList = list((Wrapper) ((LambdaQueryWrapper) Wrappers.lambdaQuery().eq((v0) -> {
|
return v0.getDeviceId();
|
}, repairRecord.getDeviceId())).eq((v0) -> {
|
return v0.getRecordStatus();
|
}, Integer.valueOf(RepairRecordEnum.R1.getType())));
|
List<RepairApply> inMaintenanceList = this.repairApplyService.list((Wrapper) ((LambdaQueryWrapper) Wrappers.lambdaQuery().eq((v0) -> {
|
return v0.getDeviceId();
|
}, repairRecord.getDeviceId())).eq((v0) -> {
|
return v0.getApplyStatus();
|
}, Integer.valueOf(RepairApplyStatusEnum.Y2.getType())));
|
List<RepairApply> toBeRepairedList = this.repairApplyService.list((Wrapper) ((LambdaQueryWrapper) Wrappers.lambdaQuery().eq((v0) -> {
|
return v0.getDeviceId();
|
}, repairRecord.getDeviceId())).eq((v0) -> {
|
return v0.getApplyStatus();
|
}, Integer.valueOf(RepairApplyStatusEnum.Y1.getType())));*/
|
this.machineService.updateMachineRepairPriority(repairRecord.getDeviceId(), toBeConfirmedList, inMaintenanceList, toBeRepairedList);
|
this.machineService.renewMachineRepairTime(repairRecord.getDeviceId());
|
return update;
|
}
|
|
@Override // org.springblade.modules.tpm.service.IRepairRecordService
|
public List<RepairRecordVO> getRecordByDeviceId(Long deviceId) {
|
List<RepairRecord> list = list(Wrappers.<RepairRecord>query().lambda().eq(RepairRecord::getDeviceId, deviceId).orderByDesc(RepairRecord::getRepairStartTime));
|
/*
|
List<RepairRecord> list = list((Wrapper) ((LambdaQueryWrapper) Wrappers.query().lambda().eq((v0) -> {
|
return v0.getDeviceId();
|
}, deviceId)).orderByDesc((v0) -> {
|
return v0.getRepairStartTime();
|
}));*/
|
if (Func.isEmpty(list)) {
|
throw new ServiceException(MessageUtils.message("cps.tpm.repair.record.not.exists", new Object[0]));
|
}
|
List<RepairRecordVO> convert = RepairRecordConvert.INSTANCE.convert(list);
|
convert.forEach(i -> {
|
RepairApply repairApply = (RepairApply) this.repairApplyService.getById(i.getRepairApplyId());
|
if (Func.isNotEmpty(repairApply)) {
|
i.setApplyCode(repairApply.getApplyCode());
|
i.setUrgency(repairApply.getUrgency());
|
i.setApplyUserName(repairApply.getApplyUserName());
|
}
|
});
|
|
convert.sort(Comparator.comparing(RepairRecordVO::getRepairStartTime, Comparator.nullsFirst(Date::compareTo)).reversed());
|
convert.sort(Comparator.comparing(RepairRecordVO::getUrgency, Comparator.nullsFirst(Integer::compareTo)).reversed());
|
convert.sort(Comparator.comparing(RepairRecordVO::getRecordStatus, Comparator.nullsFirst(Integer::compareTo)));
|
/*
|
convert.sort(Comparator.comparing((v0) -> {
|
return v0.getRepairStartTime();
|
}, Comparator.nullsFirst((v0, v1) -> {
|
return v0.compareTo(v1);
|
})).reversed());
|
convert.sort(Comparator.comparing((v0) -> {
|
return v0.getUrgency();
|
}, Comparator.nullsFirst((v0, v1) -> {
|
return v0.compareTo(v1);
|
})).reversed());
|
convert.sort(Comparator.comparing((v0) -> {
|
return v0.getRecordStatus();
|
}, Comparator.nullsFirst((v0, v1) -> {
|
return v0.compareTo(v1);
|
})));*/
|
return convert;
|
}
|
|
@Override // org.springblade.modules.tpm.service.IRepairRecordService
|
public ApplyRecordMaterialVO getFiles(Long id) {
|
RepairRecord repairRecord = (RepairRecord) getById(id);
|
if (Func.isNull(repairRecord)) {
|
throw new ServiceException(MessageUtils.message("cps.tpm.repair.record.not.exists", new Object[0]));
|
}
|
List<RepairApplyFile> applyFileList = this.repairApplyFileService.list(Wrappers.<RepairApplyFile>query().lambda().eq(RepairApplyFile::getRepairApplyId, repairRecord.getRepairApplyId()));
|
/*
|
List<RepairApplyFile> applyFileList = this.repairApplyFileService.list((Wrapper) Wrappers.query().lambda().eq((v0) -> {
|
return v0.getRepairApplyId();
|
}, repairRecord.getRepairApplyId()));*/
|
ApplyRecordMaterialVO applyRecordMaterialVo = new ApplyRecordMaterialVO();
|
if (Func.isNotEmpty(applyFileList)) {
|
List<RepairApplyFileAddDTO> collect = applyFileList.stream().map(RepairApplyFileConvert.INSTANCE::convert).collect(Collectors.toList());
|
/*
|
Stream<RepairApplyFile> stream = applyFileList.stream();
|
RepairApplyFileConvert repairApplyFileConvert = RepairApplyFileConvert.INSTANCE;
|
repairApplyFileConvert.getClass();
|
List<RepairApplyFileAddDTO> collect = stream.map(this::convert).collect(Collectors.toList());
|
*/
|
if (Func.isNotEmpty(collect)) {
|
applyRecordMaterialVo.setRepairApplyFileAddDTOList(collect);
|
}
|
} else {
|
applyRecordMaterialVo.setRepairApplyFileAddDTOList(new ArrayList<>());
|
}
|
List<RepairRecordFile> repairRecordFileList = this.repairRecordFileService.list(Wrappers.<RepairRecordFile>query().lambda().eq(RepairRecordFile::getRepairRecordId, id));
|
/*
|
List<RepairRecordFile> repairRecordFileList = this.repairRecordFileService.list((Wrapper) Wrappers.query().lambda().eq((v0) -> {
|
return v0.getRepairRecordId();
|
}, id));*/
|
if (Func.isNotEmpty(repairRecordFileList)) {
|
List<RepairRecordFileAddDTO> collect2 = repairRecordFileList.stream().map(RepairRecordFileConvert.INSTANCE::convert).collect(Collectors.toList());
|
/*
|
Stream<RepairRecordFile> stream2 = repairRecordFileList.stream();
|
RepairRecordFileConvert repairRecordFileConvert = RepairRecordFileConvert.INSTANCE;
|
repairRecordFileConvert.getClass();
|
List<RepairRecordFileAddDTO> collect2 = (List) stream2.map(this::convert).collect(Collectors.toList());
|
*/
|
if (Func.isNotEmpty(collect2)) {
|
applyRecordMaterialVo.setRepairRecordFileAddDTOList(collect2);
|
}
|
} else {
|
applyRecordMaterialVo.setRepairRecordFileAddDTOList(new ArrayList<>());
|
}
|
List<DeviceMaterialRecord> deviceMaterialRecordList = this.deviceMaterialRecordService.list(Wrappers.<DeviceMaterialRecord>query().lambda().eq(DeviceMaterialRecord::getRecordId, id));
|
/*
|
List<DeviceMaterialRecord> deviceMaterialRecordList = this.deviceMaterialRecordService.list((Wrapper) Wrappers.query().lambda().eq((v0) -> {
|
return v0.getRecordId();
|
}, id));*/
|
if (Func.isNotEmpty(deviceMaterialRecordList)) {
|
List<MaterialVO> collect3 = deviceMaterialRecordList.stream().map(MaterialRecordConvert.INSTANCE::convert).collect(Collectors.toList());
|
/*
|
Stream<DeviceMaterialRecord> stream3 = deviceMaterialRecordList.stream();
|
MaterialRecordConvert materialRecordConvert = MaterialRecordConvert.INSTANCE;
|
materialRecordConvert.getClass();
|
List<MaterialVO> collect3 = (List) stream3.map(this::convert).collect(Collectors.toList());*/
|
if (Func.isNotEmpty(collect3)) {
|
applyRecordMaterialVo.setMaterialVoList(collect3);
|
}
|
} else {
|
applyRecordMaterialVo.setMaterialVoList(new ArrayList<>());
|
}
|
return applyRecordMaterialVo;
|
}
|
|
@Override // org.springblade.modules.tpm.service.IRepairRecordService
|
public boolean deleteRecord(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 (!checkRecordConfirm(ids)) {
|
throw new ServiceException(MessageUtils.message("cps.tpm.repair.delete.record.status.is.pending.to.be.confirmed", new Object[0]));
|
}
|
Iterator<Long> it = ids.iterator();
|
if (it.hasNext()) {
|
Long id = it.next();
|
removeById(id);
|
RepairRecord repairRecord = (RepairRecord) getById(id);
|
if (repairRecord.getRecordType().equals(Integer.valueOf(RepairRecordTypeEnum.T2.getType()))) {
|
RepairApply repairApply = (RepairApply) this.repairApplyService.getById(repairRecord.getRepairApplyId());
|
if (Func.isNotEmpty(repairApply)) {
|
repairApply.setApplyStatus(Integer.valueOf(RepairApplyStatusEnum.Y2.getType()));
|
this.repairApplyService.updateById(repairApply);
|
}
|
}
|
List<RepairRecord> r1List = list(Wrappers.<RepairRecord>lambdaQuery().eq(RepairRecord::getDeviceId, repairRecord.getDeviceId()).eq(RepairRecord::getRecordStatus, Integer.valueOf(RepairRecordEnum.R1.getType())));
|
List<RepairApply> y2List = this.repairApplyService.list(Wrappers.<RepairApply>query().lambda().eq(RepairApply::getDeviceId, repairRecord.getDeviceId()).eq(RepairApply::getApplyStatus, Integer.valueOf(RepairApplyStatusEnum.Y2.getType())));
|
List<RepairApply> y1List = this.repairApplyService.list(Wrappers.<RepairApply>query().lambda().eq(RepairApply::getDeviceId, repairRecord.getDeviceId()).eq(RepairApply::getApplyStatus, Integer.valueOf(RepairApplyStatusEnum.Y1.getType())));
|
/*
|
List<RepairRecord> r1List = list((Wrapper) ((LambdaQueryWrapper) Wrappers.lambdaQuery().eq((v0) -> {
|
return v0.getDeviceId();
|
}, repairRecord.getDeviceId())).eq((v0) -> {
|
return v0.getRecordStatus();
|
}, Integer.valueOf(RepairRecordEnum.R1.getType())));
|
List<RepairApply> y2List = this.repairApplyService.list((Wrapper) ((LambdaQueryWrapper) Wrappers.query().lambda().eq((v0) -> {
|
return v0.getDeviceId();
|
}, repairRecord.getDeviceId())).eq((v0) -> {
|
return v0.getApplyStatus();
|
}, Integer.valueOf(RepairApplyStatusEnum.Y2.getType())));
|
List<RepairApply> y1List = this.repairApplyService.list((Wrapper) ((LambdaQueryWrapper) Wrappers.query().lambda().eq((v0) -> {
|
return v0.getDeviceId();
|
}, repairRecord.getDeviceId())).eq((v0) -> {
|
return v0.getApplyStatus();
|
}, Integer.valueOf(RepairApplyStatusEnum.Y1.getType())));*/
|
this.machineService.updateMachineRepairPriority(repairRecord.getDeviceId(), r1List, y2List, y1List);
|
return true;
|
}
|
return false;
|
}
|
|
@Override // org.springblade.modules.tpm.service.IRepairRecordService
|
public List<RepairRecordVO> queryRecord(RepairRecordLookVO repairRecordLookVO) {
|
List<RepairRecord> recordList = list(Wrappers.<RepairRecord>lambdaQuery()
|
.and(Func.isNotEmpty(repairRecordLookVO.getDeviceTypeId()), i -> i.eq(RepairRecord::getDeviceTypeId, repairRecordLookVO.getDeviceTypeId()))
|
.and(Func.isNotEmpty(repairRecordLookVO.getRecordStatus()), i -> i.eq(RepairRecord::getRecordStatus, repairRecordLookVO.getRecordStatus()))
|
.and(Func.isNotEmpty(repairRecordLookVO.getKeyWords()), i -> i.like(RepairRecord::getRecordCode, repairRecordLookVO.getKeyWords()).or().like(RepairRecord::getDeviceCode, repairRecordLookVO.getKeyWords()).or().like(RepairRecord::getRepairApplyId, getApplyId(repairRecordLookVO.getKeyWords())).or().like(RepairRecord::getDeviceName, repairRecordLookVO.getKeyWords()))
|
|
.orderByDesc(RepairRecord::getRecordCode));
|
/*
|
List<RepairRecord> recordList = list((Wrapper) Wrappers.lambdaQuery().and(Func.isNotEmpty(repairRecordLookVO.getDeviceTypeId()), i -> {
|
LambdaQueryWrapper lambdaQueryWrapper = (LambdaQueryWrapper) i.eq((v0) -> {
|
return v0.getDeviceTypeId();
|
}, repairRecordLookVO.getDeviceTypeId());
|
}).and(Func.isNotEmpty(repairRecordLookVO.getRecordStatus()), i2 -> {
|
LambdaQueryWrapper lambdaQueryWrapper = (LambdaQueryWrapper) i2.eq((v0) -> {
|
return v0.getRecordStatus();
|
}, repairRecordLookVO.getRecordStatus());
|
}).and(Func.isNotEmpty(repairRecordLookVO.getKeyWords()), i3 -> {
|
LambdaQueryWrapper lambdaQueryWrapper = (LambdaQueryWrapper) ((LambdaQueryWrapper) ((LambdaQueryWrapper) ((LambdaQueryWrapper) ((LambdaQueryWrapper) ((LambdaQueryWrapper) ((LambdaQueryWrapper) i3.like((v0) -> {
|
return v0.getRecordCode();
|
}, repairRecordLookVO.getKeyWords())).or()).like((v0) -> {
|
return v0.getDeviceCode();
|
}, repairRecordLookVO.getKeyWords())).or()).like((v0) -> {
|
return v0.getRepairApplyId();
|
}, getApplyId(repairRecordLookVO.getKeyWords()))).or()).like((v0) -> {
|
return v0.getDeviceName();
|
}, repairRecordLookVO.getKeyWords());
|
}).orderByDesc((v0) -> {
|
return v0.getRecordCode();
|
}));*/
|
List<RepairRecordVO> convert = RepairRecordConvert.INSTANCE.convert(recordList);
|
return convert;
|
}
|
|
@Override // org.springblade.modules.tpm.service.IRepairRecordService
|
public List<RepairRecord> getRecordByMalId(Long malId) {
|
List<RepairRecord> repairRecordList = list(Wrappers.<RepairRecord>lambdaQuery().eq(RepairRecord::getRecordStatus, Integer.valueOf(RepairRecordEnum.R1.getType())).orderByDesc(RepairRecord::getRecordCode));
|
/*
|
List<RepairRecord> repairRecordList = list((Wrapper) ((LambdaQueryWrapper) Wrappers.lambdaQuery().eq((v0) -> {
|
return v0.getRecordStatus();
|
}, Integer.valueOf(RepairRecordEnum.R1.getType()))).orderByDesc((v0) -> {
|
return v0.getRecordCode();
|
}));*/
|
if (Func.isNull(repairRecordList)) {
|
throw new ServiceException(MessageUtils.message("cps.tpm.repair.record.malfunction.not.exists", new Object[0]));
|
}
|
return repairRecordList;
|
}
|
|
@Override // org.springblade.modules.tpm.service.IRepairRecordService
|
public boolean updateRecordMalfunction(Long malId, String malName, String malCode, Integer action) {
|
boolean result = false;
|
List<RepairRecord> repairRecordList = getRecordByMalId(malId);
|
if (!Func.isNull(repairRecordList)) {
|
List<RepairRecord> collect = null;
|
if (action.equals(Integer.valueOf(ActionEnum.UPDATE_MAL.getType()))) {
|
collect = repairRecordList.stream().peek(i -> {
|
i.setMalfunctionId(malId);
|
i.setMalfunctionName(malName);
|
i.setMalfunctionCode(malCode);
|
}).collect(Collectors.toList());
|
} else if (action.equals(Integer.valueOf(ActionEnum.DELETE_MAL.getType()))) {
|
collect = repairRecordList.stream().peek(i2 -> {
|
i2.setMalfunctionId(null);
|
i2.setMalfunctionName(null);
|
i2.setMalfunctionCode(null);
|
}).collect(Collectors.toList());
|
}
|
updateBatchById(collect);
|
result = true;
|
}
|
return result;
|
}
|
|
@Override // org.springblade.modules.tpm.service.IRepairRecordService
|
public boolean updateApplyByApply(Long applyId, Long malId, String malName, String malCode) {
|
RepairRecord repairRecord = (RepairRecord) getById(applyId);
|
if (Func.isNull(repairRecord)) {
|
throw new ServiceException(MessageUtils.message("cps.tpm.repair.record.not.exists", new Object[0]));
|
}
|
repairRecord.setMalfunctionId(malId).setMalfunctionCode(malCode).setMalfunctionName(malName);
|
return updateById(repairRecord);
|
}
|
|
@Override // org.springblade.modules.tpm.service.IRepairRecordService
|
public List<RepairRecordExcelVO> exportRepairRecord(RepairRecordExportVO repairRecordExportVO) {
|
List<RepairRecordExcelVO> repairRecordExcelVos = this.baseMapper.exportRecordVo(repairRecordExportVO, AuthUtil.getTenantId());
|
if (Func.isNotEmpty(repairRecordExcelVos)) {
|
repairRecordExcelVos.forEach(repairRecordExcelVo -> {
|
if (Func.isNotBlank(repairRecordExcelVo.getUrgency())) {
|
if (repairRecordExcelVo.getUrgency().equals(String.valueOf(UrgencyEnum.U1.getType()))) {
|
repairRecordExcelVo.setUrgency(UrgencyEnum.U1.getDesc());
|
} else if (repairRecordExcelVo.getUrgency().equals(String.valueOf(UrgencyEnum.U2.getType()))) {
|
repairRecordExcelVo.setUrgency(UrgencyEnum.U2.getDesc());
|
} else {
|
repairRecordExcelVo.setUrgency(UrgencyEnum.U3.getDesc());
|
}
|
}
|
if (Func.isNotBlank(repairRecordExcelVo.getRecordType())) {
|
if (repairRecordExcelVo.getRecordType().equals(String.valueOf(RepairRecordTypeEnum.T1.getType()))) {
|
repairRecordExcelVo.setRecordType(RepairRecordTypeEnum.T1.getDesc());
|
} else {
|
repairRecordExcelVo.setRecordType(RepairRecordTypeEnum.T2.getDesc());
|
}
|
}
|
repairRecordExcelVo.setRepairTime(formatTime(Long.valueOf(Func.isNotBlank(repairRecordExcelVo.getRepairTime()) ? repairRecordExcelVo.getRepairTime() : "0")));
|
});
|
return repairRecordExcelVos;
|
}
|
return new ArrayList<>();
|
}
|
|
@Override // org.springblade.modules.tpm.service.IRepairRecordService
|
public IPage<RepairRecordVO> getPageRecordWaring(RepairRecordTodaySearchVO repairRecordTodaySearchVO, Query query) {
|
IPage<RepairRecordVO> page = Condition.getPage(query);
|
List<RepairRecordVO> repairTodayRecordPages = this.repairRecordMapper.getRepairTodayRecordPages(repairRecordTodaySearchVO, page);
|
if (Func.isNotEmpty(repairTodayRecordPages)) {
|
return page.setRecords(repairTodayRecordPages);
|
}
|
return page.setRecords(new ArrayList<>());
|
}
|
|
@Override // org.springblade.modules.tpm.service.IRepairRecordService
|
public Long countRecord() {
|
Long count = Long.valueOf(count(Wrappers.<RepairRecord>lambdaQuery().eq(RepairRecord::getRecordStatus, Integer.valueOf(RepairRecordEnum.R1.getType()))));
|
/*
|
Long count = Long.valueOf(count((Wrapper) Wrappers.lambdaQuery().eq((v0) -> {
|
return v0.getRecordStatus();
|
}, Integer.valueOf(RepairRecordEnum.R1.getType()))));*/
|
return (Long) Optional.of(count).orElse(0L);
|
}
|
|
@Override // org.springblade.modules.tpm.service.IRepairRecordService
|
public RepairRecordVO completeRepair(Long id) {
|
RepairApply repairApply = (RepairApply) Optional.ofNullable(this.repairApplyService.getById(id)).orElseThrow(() -> {
|
return new ServiceException(MessageUtils.message("cps.tpm.repair.apply.not.exists", new Object[0]));
|
});
|
RepairRecord repairRecord = new RepairRecord().setRepairApplyId(id).setDeviceId(repairApply.getDeviceId()).setDeviceCode(repairApply.getDeviceCode()).setDeviceName(repairApply.getDeviceName()).setDeviceTypeId(repairApply.getDeviceTypeId()).setDeviceTypeName(repairApply.getDeviceTypeName()).setRepairStartTime(repairApply.getStartTime() == null ? null : DateUtils.localDateTimeToDate(repairApply.getStartTime())).setRepairEndTime(new Date()).setRecordStatus(Integer.valueOf(RepairRecordEnum.R1.getType())).setMalfunctionId(repairApply.getMalfunctionId()).setMalfunctionCode(repairApply.getMalfunctionCode()).setMalfunctionName(repairApply.getMalfunctionName()).setIsAffect(repairApply.getIsAffect()).setRecordType(Integer.valueOf(RepairRecordTypeEnum.T2.getType()));
|
if (!checkApplyCode(id)) {
|
throw new ServiceException(MessageUtils.message("cps.tpm.repair.apply.num.already.registered", new Object[0]));
|
}
|
save(repairRecord);
|
repairApply.setApplyStatus(Integer.valueOf(RepairApplyStatusEnum.Y3.getType()));
|
this.repairApplyService.updateById(repairApply);
|
this.machineService.renewMachineRepairStatus(repairRecord.getDeviceId(), Integer.valueOf(DeviceRepairStatusEnum.TO_BE_CONFIRM.getType()));
|
return RepairRecordConvert.INSTANCE.convert(repairRecord);
|
}
|
|
private boolean checkRecordConfirm(List<Long> ids) {
|
List<RepairRecord> list = list(Wrappers.<RepairRecord>lambdaQuery().ne(RepairRecord::getRecordStatus, Integer.valueOf(RepairRecordEnum.R2.getType())).in(RepairRecord::getId, ids));
|
/*
|
List<RepairRecord> list = list((Wrapper) ((LambdaQueryWrapper) Wrappers.lambdaQuery().ne((v0) -> {
|
return v0.getRecordStatus();
|
}, Integer.valueOf(RepairRecordEnum.R2.getType()))).in((v0) -> {
|
return v0.getId();
|
}, ids));*/
|
return Func.isNull(list);
|
}
|
|
private boolean checkRecordStatus(Long id) {
|
RepairRecord repairRecord = (RepairRecord) getById(id);
|
return repairRecord.getRecordStatus().equals(Integer.valueOf(RepairRecordEnum.R1.getType()));
|
}
|
|
private boolean checkApplyCode(Long id) {
|
RepairRecord repairRecord = this.baseMapper.selectOne(Wrappers.<RepairRecord>query().lambda().eq(RepairRecord::getRepairApplyId, id));
|
/*
|
RepairRecord repairRecord = (RepairRecord) this.baseMapper.selectOne((Wrapper) Wrappers.query().lambda().eq((v0) -> {
|
return v0.getRepairApplyId();
|
}, id));*/
|
return Func.isNull(repairRecord);
|
}
|
|
private boolean checkRecordCode(String recordCode) {
|
RepairRecord repairRecord = this.baseMapper.selectOne(Wrappers.<RepairRecord>query().lambda().eq(Func.isNotEmpty(AuthUtil.getTenantId()), RepairRecord::getTenantId, AuthUtil.getTenantId()).eq(RepairRecord::getRecordCode, recordCode));
|
/*
|
RepairRecord repairRecord = (RepairRecord) this.baseMapper.selectOne((Wrapper) Wrappers.query().lambda().eq(Func.isNotEmpty(AuthUtil.getTenantId()), (v0) -> {
|
return v0.getTenantId();
|
}, AuthUtil.getTenantId()).eq((v0) -> {
|
return v0.getRecordCode();
|
}, recordCode));*/
|
return repairRecord != null;
|
}
|
|
private String formatTime(Long minuteStr) {
|
String resultStr = "";
|
if (!Func.isEmpty(minuteStr)) {
|
if (minuteStr.longValue() != 0) {
|
if (minuteStr.longValue() / 60 == 0) {
|
resultStr = (minuteStr.longValue() % 60) + "分";
|
} else if (minuteStr.longValue() % 60 == 0) {
|
resultStr = (minuteStr.longValue() / 60) + "小时";
|
} else if (minuteStr.longValue() % 1440 == 0) {
|
if (minuteStr.longValue() / 1440 > 0) {
|
resultStr = (minuteStr.longValue() / 1440) + "天0小时0分";
|
}
|
} else if (minuteStr.longValue() / 1440 > 0) {
|
resultStr = (minuteStr.longValue() / 1440) + "天" + (minuteStr.longValue() / 60) + "小时" + (minuteStr.longValue() % 60) + "分";
|
} else {
|
resultStr = (minuteStr.longValue() / 60) + "小时" + (minuteStr.longValue() % 60) + "分";
|
}
|
} else {
|
resultStr = "0分";
|
}
|
} else {
|
resultStr = "0分";
|
}
|
return resultStr;
|
}
|
}
|
