package com.ruoyi.system.service.enterpriseManage.impl;
|
|
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
|
import com.ruoyi.common.config.RuoYiConfig;
|
import com.ruoyi.common.core.domain.AjaxResult;
|
import com.ruoyi.common.core.domain.model.LoginUser;
|
import com.ruoyi.common.utils.StringUtils;
|
import com.ruoyi.common.utils.file.FileUploadUtils;
|
import com.ruoyi.common.utils.poi.ExcelUtil;
|
import com.ruoyi.system.domain.query.EnterpriseInfoSelectByConditionDBQuery;
|
import com.ruoyi.system.domain.req.*;
|
import com.ruoyi.system.domain.resp.*;
|
import com.ruoyi.system.entity.CountProvinceDataDO;
|
import com.ruoyi.system.entity.EnterpriseManageCompanyInfo;
|
import com.ruoyi.system.entity.EnterpriseManageTechnologyType;
|
import com.ruoyi.system.entity.ValidityStateUpdateDO;
|
import com.ruoyi.system.enums.DeleteStatusEnum;
|
import com.ruoyi.system.enums.MajorHazardSourceEnum;
|
import com.ruoyi.system.enums.ValidityStateEnum;
|
import com.ruoyi.system.enums.CertificateTypeEnum;
|
import com.ruoyi.system.service.baseService.EnterpriseManageCompanyInfoService;
|
import com.ruoyi.system.service.baseService.EnterpriseManageTechnologyTypeService;
|
import com.ruoyi.system.service.company.ICompanyInfoService;
|
import com.ruoyi.system.service.enterpriseManage.EnterpriseManageService;
|
import com.ruoyi.system.utils.EnterpriseParamIsValidUtil;
|
import org.apache.commons.lang3.BooleanUtils;
|
import org.apache.ibatis.annotations.Options;
|
import org.redisson.api.RLock;
|
import org.redisson.api.RedissonClient;
|
import org.slf4j.Logger;
|
import org.slf4j.LoggerFactory;
|
import org.springframework.beans.BeanUtils;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.context.annotation.Bean;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.springframework.web.multipart.MultipartFile;
|
|
import java.io.File;
|
import java.io.IOException;
|
import java.io.InputStream;
|
import java.text.SimpleDateFormat;
|
import java.util.*;
|
import java.util.concurrent.TimeUnit;
|
import java.util.stream.Collectors;
|
|
@Service
|
public class EnterpriseManageServiceImpl implements EnterpriseManageService {
|
|
private static SimpleDateFormat dateFormat = new SimpleDateFormat( "yyyy-MM-dd HH:mm:ss:sss");
|
|
private final Logger logger = LoggerFactory.getLogger(EnterpriseManageServiceImpl.class);
|
|
@Autowired
|
private RedissonClient redissonClient;
|
|
@Autowired
|
private ICompanyInfoService companyInfoService;
|
|
@Autowired
|
private EnterpriseManageCompanyInfoService enterpriseManageCompanyInfoService;
|
|
@Autowired
|
private EnterpriseManageTechnologyTypeService technologyTypeService;
|
|
/**
|
* @description 新增企业信息
|
*/
|
@Override
|
public AjaxResult saveEnterpriseInfo(LoginUser user,EnterpriseInfoAddReqDTO infoAddReqDTO, MultipartFile companyImageFile,
|
MultipartFile businessLicenseFile, MultipartFile securityCertificateFile) {
|
Date date = new Date();
|
if (infoAddReqDTO == null){
|
return AjaxResult.error("新增企业信息参数不能为空");
|
}
|
EnterpriseManageCompanyInfo companyInfo = new EnterpriseManageCompanyInfo();
|
BeanUtils.copyProperties(infoAddReqDTO,companyInfo);
|
EnterpriseParamIsValidUtil.ParamIsValid(companyInfo);
|
|
String lockName = "XJ_ENTERPRISE_INFORMATION_ADD_"+companyInfo.getCertificateNum();
|
RLock xjEnterpriseInformationAddLock = redissonClient.getLock(lockName);
|
xjEnterpriseInformationAddLock.lock(3, TimeUnit.SECONDS);
|
|
EnterpriseManageCompanyInfo selectResult = enterpriseManageCompanyInfoService.getEnterpriseInfoByCertificateNum(companyInfo.getCertificateNum());
|
if (selectResult != null){
|
return AjaxResult.error("数据已存在，请检查证书编号是否填写正确！");
|
}
|
initFileInfo(companyInfo, companyImageFile, businessLicenseFile, securityCertificateFile);
|
companyInfo.setCreateBy(user.getUsername());
|
companyInfo.setCreateTime(date);
|
companyInfo.setUpdateBy(user.getUsername());
|
companyInfo.setUpdateTime(date);
|
companyInfo.setIsDelete(DeleteStatusEnum.DELECT_NO.getStatus());
|
companyInfo.setValidityState(judgeValidityState(companyInfo.getValidityDateEnd()));
|
boolean saveResult = enterpriseManageCompanyInfoService.save(companyInfo);
|
|
xjEnterpriseInformationAddLock.unlock();
|
|
if (saveResult){
|
return AjaxResult.success("企业信息新增成功!");
|
}else {
|
return AjaxResult.error("企业信息新增失败!");
|
}
|
|
}
|
|
/**
|
* @description 删除企业信息通过id
|
*/
|
@Transactional
|
@Override
|
public AjaxResult deleteEnterpriseInfoById(LoginUser user, EnterpriseInfoDeleteByIdReqDTO deleteByIdReqDTO) {
|
Long id = deleteByIdReqDTO.getId();
|
if (id == null){
|
return AjaxResult.error("企业id不能为空");
|
}
|
|
String lockName = "XJ_ENTERPRISE_INFORMATION_DELETE_"+id;
|
RLock xjEnterpriseInformationDeleteLock = redissonClient.getLock(lockName);
|
xjEnterpriseInformationDeleteLock.lock(3, TimeUnit.SECONDS);
|
|
EnterpriseManageCompanyInfo manageCompanyInfo = enterpriseManageCompanyInfoService.getEnterpriseInfoById(id);
|
if (manageCompanyInfo == null){
|
return AjaxResult.error("企业不存在，删除失败!");
|
}
|
EnterpriseManageCompanyInfo companyInfo = new EnterpriseManageCompanyInfo();
|
companyInfo.setId(id);
|
companyInfo.setIsDelete(DeleteStatusEnum.DELECT_YES.getStatus());
|
companyInfo.setUpdateTime(new Date());
|
companyInfo.setUpdateBy(user.getUsername());
|
deleteImage(manageCompanyInfo);
|
boolean updateResult = enterpriseManageCompanyInfoService.updateById(companyInfo);
|
|
xjEnterpriseInformationDeleteLock.unlock();
|
|
if (updateResult){
|
return AjaxResult.success("企业删除成功!");
|
}else {
|
return AjaxResult.error("企业删除失败!");
|
}
|
}
|
|
/**
|
* @description 修改企业信息
|
*/
|
@Override
|
public AjaxResult updateEnterpriseInfoById(LoginUser user, EnterpriseInfoUpdateByIdReqDTO updateByIdReqDTO,MultipartFile companyImageFile,
|
MultipartFile businessLicenseFile, MultipartFile securityCertificateFile) {
|
Date date = new Date();
|
if (updateByIdReqDTO == null){
|
return AjaxResult.error("修改企业信息参数不能为空");
|
}
|
EnterpriseManageCompanyInfo companyInfo = new EnterpriseManageCompanyInfo();
|
BeanUtils.copyProperties(updateByIdReqDTO,companyInfo);
|
EnterpriseParamIsValidUtil.ParamIsValid(companyInfo);
|
|
String lockName = "XJ_ENTERPRISE_INFORMATION_UPDATE_"+companyInfo.getCertificateNum();
|
RLock xjEnterpriseInformationUpdateLock = redissonClient.getLock(lockName);
|
xjEnterpriseInformationUpdateLock.lock(3, TimeUnit.SECONDS);
|
|
EnterpriseManageCompanyInfo selectResult = enterpriseManageCompanyInfoService.getEnterpriseInfoByCertificateNum(companyInfo.getCertificateNum());
|
if (selectResult != null){
|
if (updateByIdReqDTO.getId() != selectResult.getId()) {
|
return AjaxResult.error("数据已存在，请检查证书编号是否填写正确！");
|
}
|
}
|
|
if (!BooleanUtils.isTrue(companyInfo.getDeleteCompanyImage())){
|
companyInfo.setCompanyImage(null);
|
}
|
if (!BooleanUtils.isTrue(companyInfo.getDeleteBusinessLicense())){
|
companyInfo.setBusinessLicense(null);
|
}
|
if (!BooleanUtils.isTrue(companyInfo.getDeleteSecurityCertificate())){
|
companyInfo.setSecurityCertificate(null);
|
}
|
deleteImage(companyInfo);
|
|
initFileInfo(companyInfo, companyImageFile, businessLicenseFile, securityCertificateFile);
|
companyInfo.setUpdateTime(date);
|
companyInfo.setUpdateBy(user.getUsername());
|
companyInfo.setValidityState(judgeValidityState(companyInfo.getValidityDateEnd()));
|
boolean updateResult = enterpriseManageCompanyInfoService.updateById(companyInfo);
|
|
xjEnterpriseInformationUpdateLock.unlock();
|
|
if (updateResult){
|
return AjaxResult.success("企业修改成功!");
|
}else {
|
return AjaxResult.error("企业修改失败!");
|
}
|
}
|
|
/**
|
* @description 查询企业信息通过id
|
*/
|
@Override
|
public AjaxResult getEnterpriseInfoById(LoginUser user, EnterpriseInfoSelectByIdReqDTO selectById) {
|
Long id = selectById.getId();
|
if (id == null){
|
return AjaxResult.error("企业信息id不能为空");
|
}
|
EnterpriseManageCompanyInfo enterpriseInfo = enterpriseManageCompanyInfoService.getEnterpriseInfoById(id);
|
if (enterpriseInfo == null){
|
return AjaxResult.success(enterpriseInfo);
|
}
|
EnterpriseInfoByIdSelectRespDTO respDTO = new EnterpriseInfoByIdSelectRespDTO();
|
BeanUtils.copyProperties(enterpriseInfo,respDTO);
|
|
EnterpriseManageTechnologyType technologyType = technologyTypeService.getValidTechnologyTypeById(respDTO.getTechnologyType());
|
if (technologyType != null){
|
respDTO.setTechnologyName(technologyType.getTechnologyName());
|
}
|
if (CertificateTypeEnum.PRODUCE.getStatus().equals(respDTO.getCertificateType())){
|
respDTO.setCertificateTypeName(CertificateTypeEnum.PRODUCE.getDesc());
|
}
|
if (CertificateTypeEnum.MANAGE.getStatus().equals(respDTO.getCertificateType())){
|
respDTO.setCertificateTypeName(CertificateTypeEnum.MANAGE.getDesc());
|
}
|
return AjaxResult.success(respDTO);
|
}
|
|
/**
|
* @description 查询各地市的企业信息
|
*/
|
@Override
|
public AjaxResult getEnterpriseInfoByCity(LoginUser user, EnterpriseInfoSelectByCityReqDTO selectByCityReqDTO) {
|
String city = selectByCityReqDTO.getCity();
|
if (StringUtils.isBlank(city)){
|
return AjaxResult.error("城市不能为空");
|
}
|
EnterpriseInfoSelectByCityResultRespDTO resultRespDTO = new EnterpriseInfoSelectByCityResultRespDTO();
|
resultRespDTO.setCity(city);
|
|
Byte validityState = selectByCityReqDTO.getValidityState();
|
List<EnterpriseManageCompanyInfo> companyInfos = enterpriseManageCompanyInfoService.getEnterpriseInfoByCity(city,validityState);
|
if (CollectionUtils.isEmpty(companyInfos)){
|
return AjaxResult.success(companyInfos);
|
}
|
|
resultRespDTO.setOneMonthEnterpriseNum(countEnterpriseNumByCityAndValidity(companyInfos,ValidityStateEnum.STATE_30_DAYS.getStatus()));
|
resultRespDTO.setTwoMonthEnterpriseNum(countEnterpriseNumByCityAndValidity(companyInfos,ValidityStateEnum.STATE_60_DAYS.getStatus()));
|
resultRespDTO.setThreeMonthEnterpriseNum(countEnterpriseNumByCityAndValidity(companyInfos,ValidityStateEnum.STATE_90_DAYS.getStatus()));
|
|
Map<String, List<EnterpriseManageCompanyInfo>> companyInfoMap =
|
companyInfos.stream().collect(Collectors.groupingBy(EnterpriseManageCompanyInfo::getCompanyArea));
|
|
List<EnterpriseInfoSelectByCityRespDTO> companyInfoResults = new ArrayList<>();
|
companyInfoMap.keySet().forEach(area -> {
|
List<EnterpriseManageCompanyInfo> enterpriseManageCompanyInfosByArea = companyInfoMap.get(area);
|
EnterpriseInfoSelectByCityRespDTO companyInfoResult = new EnterpriseInfoSelectByCityRespDTO();
|
companyInfoResult.setCity(enterpriseManageCompanyInfosByArea.get(0).getCompanyCity());
|
companyInfoResult.setArea(enterpriseManageCompanyInfosByArea.get(0).getCompanyArea());
|
companyInfoResult.setEnterpriseNum(enterpriseManageCompanyInfosByArea.size());
|
List<EnterpriseInfoByCityRespDTO> enterprises = enterpriseManageCompanyInfosByArea.stream().map((enterpriseInfo)->{
|
EnterpriseInfoByCityRespDTO enterprise = new EnterpriseInfoByCityRespDTO();
|
BeanUtils.copyProperties(enterpriseInfo,enterprise);
|
enterprise.setMajorHazardSourceLevel(judgeMajorHazardSource(enterpriseInfo));
|
return enterprise;
|
}).collect(Collectors.toList());
|
companyInfoResult.setEnterprises(enterprises);
|
companyInfoResults.add(companyInfoResult);
|
});
|
resultRespDTO.setCompanyInfoResults(companyInfoResults);
|
return AjaxResult.success(resultRespDTO);
|
}
|
|
/**
|
* @description 统计全省的数据
|
*/
|
@Override
|
public AjaxResult countProvinceData(LoginUser user) {
|
CountProvinceDataDO provinceDataDO = enterpriseManageCompanyInfoService.countProvinceData();
|
if (provinceDataDO == null){
|
return AjaxResult.success(provinceDataDO);
|
}
|
CountProvinceDataRespDTO respDTO = new CountProvinceDataRespDTO();
|
BeanUtils.copyProperties(provinceDataDO,respDTO);
|
return AjaxResult.success(respDTO);
|
}
|
|
/**
|
* @description 根据条件查询企业信息
|
*/
|
@Override
|
public AjaxResult getEnterpriseInfoByCondition(LoginUser user, EnterpriseInfoSelectByConditionReqDTO conditionReqDTO) {
|
EnterpriseInfoSelectByConditionDBQuery dbQuery = new EnterpriseInfoSelectByConditionDBQuery();
|
BeanUtils.copyProperties(conditionReqDTO,dbQuery);
|
List<EnterpriseManageCompanyInfo> companyInfos = enterpriseManageCompanyInfoService.getEnterpriseInfoByCondition(dbQuery);
|
if (CollectionUtils.isEmpty(companyInfos)){
|
return AjaxResult.success(companyInfos);
|
}
|
Map<String, List<EnterpriseManageCompanyInfo>> companyCityInfoMap =
|
companyInfos.stream().collect(Collectors.groupingBy(EnterpriseManageCompanyInfo::getCompanyCity));
|
|
List<EnterpriseInfoSelectByConditionResultRespDTO> conditionResultRespDTOS = new ArrayList<>();
|
|
companyCityInfoMap.keySet().forEach(city -> {
|
|
EnterpriseInfoSelectByConditionResultRespDTO conditionResultRespDTO = new EnterpriseInfoSelectByConditionResultRespDTO();
|
conditionResultRespDTO.setCity(city);
|
|
List<EnterpriseManageCompanyInfo> enterpriseManageCompanyInfosByCity = companyCityInfoMap.get(city);
|
|
Map<String, List<EnterpriseManageCompanyInfo>> enterpriseManageCompanyInfosByArea =
|
enterpriseManageCompanyInfosByCity.stream().collect(Collectors.groupingBy(EnterpriseManageCompanyInfo::getCompanyArea));
|
|
List<EnterpriseInfoSelectByConditionRespDTO> companyInfoResults = new ArrayList<>();
|
|
enterpriseManageCompanyInfosByArea.keySet().forEach(area -> {
|
List<EnterpriseManageCompanyInfo> enterpriseManageCompanyInfo = enterpriseManageCompanyInfosByArea.get(area);
|
|
EnterpriseInfoSelectByConditionRespDTO companyInfoResult = new EnterpriseInfoSelectByConditionRespDTO();
|
companyInfoResult.setCity(enterpriseManageCompanyInfo.get(0).getCompanyCity());
|
companyInfoResult.setArea(enterpriseManageCompanyInfo.get(0).getCompanyArea());
|
companyInfoResult.setEnterpriseNum(enterpriseManageCompanyInfo.size());
|
List<EnterpriseInfoByConditionRespDTO> enterprises = enterpriseManageCompanyInfo.stream().map((enterpriseInfo)->{
|
EnterpriseInfoByConditionRespDTO enterprise = new EnterpriseInfoByConditionRespDTO();
|
BeanUtils.copyProperties(enterpriseInfo,enterprise);
|
enterprise.setMajorHazardSourceLevel(judgeMajorHazardSource(enterpriseInfo));
|
return enterprise;
|
}).collect(Collectors.toList());
|
companyInfoResult.setEnterprises(enterprises);
|
companyInfoResults.add(companyInfoResult);
|
});
|
conditionResultRespDTO.setCompanyInfoResults(companyInfoResults);
|
conditionResultRespDTOS.add(conditionResultRespDTO);
|
});
|
return AjaxResult.success(conditionResultRespDTOS);
|
}
|
|
/**
|
* @description 获取所有的企业id和许可证截止时间进行判断，距离到期还有多久
|
*/
|
@Transactional
|
@Override
|
public void ValidityStateUpdate(){
|
List<ValidityStateUpdateDO> validityStateUpdateDOS = enterpriseManageCompanyInfoService.getInfoIdAndValidityEndTime();
|
if (CollectionUtils.isNotEmpty(validityStateUpdateDOS)){
|
logger.info("【更新许可证状态执行ing】 " + dateFormat.format(new Date())+" 有效数据数："+validityStateUpdateDOS.size());
|
List<EnterpriseManageCompanyInfo> companyInfos = validityStateUpdateDOS.stream().map((validityStateUpdateDO)->{
|
EnterpriseManageCompanyInfo companyInfo = new EnterpriseManageCompanyInfo();
|
BeanUtils.copyProperties(validityStateUpdateDO,companyInfo);
|
companyInfo.setValidityState(judgeValidityState(validityStateUpdateDO.getValidityDateEnd()));
|
return companyInfo;
|
}).collect(Collectors.toList());
|
boolean updateResult = enterpriseManageCompanyInfoService.updateBatchById(companyInfos);
|
if (!updateResult){
|
throw new RuntimeException("许可证状态批量更新失败");
|
}
|
logger.info("【更新许可证状态执行ing】 " + dateFormat.format(new Date())+" 更新数据："+companyInfos.size());
|
}
|
}
|
|
/**
|
* @description 批量导入企业信息
|
*/
|
@Override
|
@Transactional
|
public AjaxResult importData(LoginUser user, MultipartFile file) {
|
String username = user.getUsername();
|
Date date = new Date();
|
if (file == null){
|
return AjaxResult.error("请上传需导入的Excel文件!");
|
}
|
ExcelUtil<CompanyInfoReqDTO> util = new ExcelUtil<>(CompanyInfoReqDTO.class);
|
List<CompanyInfoReqDTO> companyInfos;
|
try {
|
companyInfos = util.importExcel(file.getInputStream());
|
} catch (Exception e) {
|
return AjaxResult.error("导入失败，请检查导入文件格式是否正确");
|
}
|
if (CollectionUtils.isEmpty(companyInfos)){
|
return AjaxResult.error("导入失败，请检查导入文件格式是否正确");
|
}
|
//新传入的工艺类型名称
|
List<String> technologyTypeNames = companyInfos.stream().map((companyInfoReqDTO -> {
|
return companyInfoReqDTO.getTechnologyType().trim();
|
})).collect(Collectors.toList());
|
|
if (CollectionUtils.isEmpty(technologyTypeNames)){
|
return AjaxResult.error("导入失败，工艺类型不能为空");
|
}
|
|
List<EnterpriseManageTechnologyType> technologyTypes = technologyTypeService.selectTechnologyTypeList();
|
List<EnterpriseManageTechnologyType> newManageTechnologyTypes;
|
|
if (CollectionUtils.isEmpty(technologyTypes)){
|
newManageTechnologyTypes = technologyTypeNames.stream().map((technologyTypeName)->{
|
EnterpriseManageTechnologyType technologyType = new EnterpriseManageTechnologyType();
|
technologyType.setTechnologyName(technologyTypeName);
|
technologyType.setIsDelete(DeleteStatusEnum.DELECT_NO.getStatus());
|
technologyType.setUpdateBy(username);
|
technologyType.setUpdateTime(date);
|
technologyType.setCreateBy(username);
|
technologyType.setCreateTime(date);
|
return technologyType;
|
}).collect(Collectors.toList());
|
technologyTypeService.saveBatch(newManageTechnologyTypes);
|
}else {
|
//数据库中现有的工艺类型
|
List<String> oldTechnologyName = technologyTypes.stream().map(EnterpriseManageTechnologyType::getTechnologyName).collect(Collectors.toList());
|
HashSet newHashSet = new HashSet(technologyTypeNames);
|
HashSet oldHashSet = new HashSet(oldTechnologyName);
|
newHashSet.removeAll(oldHashSet);
|
List<String> listTechnologyTypes = new ArrayList<String>();
|
listTechnologyTypes.addAll(newHashSet);
|
if (CollectionUtils.isNotEmpty(listTechnologyTypes)){
|
newManageTechnologyTypes = listTechnologyTypes.stream().map((listTechnologyType)->{
|
EnterpriseManageTechnologyType technologyType = new EnterpriseManageTechnologyType();
|
technologyType.setTechnologyName(listTechnologyType);
|
technologyType.setIsDelete(DeleteStatusEnum.DELECT_NO.getStatus());
|
technologyType.setUpdateBy(username);
|
technologyType.setUpdateTime(date);
|
technologyType.setCreateBy(username);
|
technologyType.setCreateTime(date);
|
return technologyType;
|
}).collect(Collectors.toList());
|
technologyTypeService.saveBatch(newManageTechnologyTypes);
|
}
|
}
|
List<EnterpriseManageTechnologyType> nowTchnologyTypes = technologyTypeService.selectTechnologyTypeList();
|
if (CollectionUtils.isEmpty(nowTchnologyTypes)){
|
return AjaxResult.error("工艺类型为空,无法导入");
|
}
|
Map<String,Integer> technologyTypeMap = nowTchnologyTypes.stream()
|
.collect(Collectors.toMap(EnterpriseManageTechnologyType::getTechnologyName,EnterpriseManageTechnologyType::getId));
|
|
List<EnterpriseManageCompanyInfo> importData = companyInfos.stream().map((companyInfoReqDTO)->{
|
AjaxResult paramIsValid = EnterpriseParamIsValidUtil.tableParamIsValid(companyInfoReqDTO);
|
companyInfoReqDTO = (CompanyInfoReqDTO) paramIsValid.get("data");
|
EnterpriseManageCompanyInfo manageCompanyInfo = new EnterpriseManageCompanyInfo();
|
BeanUtils.copyProperties(companyInfoReqDTO,manageCompanyInfo);
|
if (CertificateTypeEnum.PRODUCE.getDesc().equals(companyInfoReqDTO.getCertificateType())){
|
manageCompanyInfo.setCertificateType(CertificateTypeEnum.PRODUCE.getStatus());
|
}else if (CertificateTypeEnum.MANAGE.getDesc().equals(companyInfoReqDTO.getCertificateType())){
|
manageCompanyInfo.setCertificateType(CertificateTypeEnum.MANAGE.getStatus());
|
}else {
|
manageCompanyInfo.setCertificateType(null);
|
}
|
manageCompanyInfo.setValidityState(judgeValidityState(companyInfoReqDTO.getValidityDateEnd()));
|
Integer integer = technologyTypeMap.get(companyInfoReqDTO.getTechnologyType());
|
if (integer == null){
|
manageCompanyInfo.setTechnologyType(null);
|
}else {
|
manageCompanyInfo.setTechnologyType(integer);
|
}
|
if (manageCompanyInfo.getLevelOneMajorHazardSourceSum() == null){
|
manageCompanyInfo.setLevelOneMajorHazardSourceSum(0);
|
}
|
if (manageCompanyInfo.getLevelTwoMajorHazardSourceSum() == null){
|
manageCompanyInfo.setLevelTwoMajorHazardSourceSum(0);
|
}
|
if (manageCompanyInfo.getLevelThreeMajorHazardSourceSum() == null){
|
manageCompanyInfo.setLevelThreeMajorHazardSourceSum(0);
|
}
|
if (manageCompanyInfo.getLevelFourMajorHazardSourceSum() == null){
|
manageCompanyInfo.setLevelFourMajorHazardSourceSum(0);
|
}
|
manageCompanyInfo.setIsDelete(DeleteStatusEnum.DELECT_NO.getStatus());
|
manageCompanyInfo.setUpdateBy(username);
|
manageCompanyInfo.setUpdateTime(date);
|
manageCompanyInfo.setCreateBy(username);
|
manageCompanyInfo.setCreateTime(date);
|
return manageCompanyInfo;
|
}).collect(Collectors.toList());
|
//表格的数据量
|
int tableSize = importData.size();
|
|
List<EnterpriseManageCompanyInfo> duplicateRemoveImportData = importData.stream().distinct().collect(Collectors.collectingAndThen(
|
Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(EnterpriseManageCompanyInfo::getCertificateNum))), ArrayList::new));
|
|
if (CollectionUtils.isEmpty(duplicateRemoveImportData)){
|
return AjaxResult.success("导入成功,导入成功条数 0 条.");
|
}
|
|
for (EnterpriseManageCompanyInfo enterpriseManageCompanyInfo : duplicateRemoveImportData) {
|
if (enterpriseManageCompanyInfo.getCertificateType() == null){
|
return AjaxResult.error(enterpriseManageCompanyInfo.getCompanyName()+"许可证类型不属于生产、经营,许可证类型异常!");
|
}
|
if (enterpriseManageCompanyInfo.getTechnologyType() == null){
|
return AjaxResult.error(enterpriseManageCompanyInfo.getCompanyName()+"工艺类型异常!");
|
}
|
}
|
|
//表格中去除重复数据后的条数
|
int duplicateRemoveImportDataSize = duplicateRemoveImportData.size();
|
|
List<EnterpriseManageCompanyInfo> companyInfosFromDB = enterpriseManageCompanyInfoService.listEnterpriseInfo();
|
if (CollectionUtils.isEmpty(companyInfosFromDB)){
|
boolean saveResult = enterpriseManageCompanyInfoService.saveBatch(duplicateRemoveImportData);
|
return AjaxResult.success("表格数据总条数: "+tableSize+" ,去除重复后的数据条数："+duplicateRemoveImportDataSize+" ,与数据库比对去重后新增: "+duplicateRemoveImportDataSize + ".");
|
}else {
|
List<String> certificateNumFromDB = companyInfosFromDB.stream().map(EnterpriseManageCompanyInfo -> EnterpriseManageCompanyInfo.getCertificateNum()).collect(Collectors.toList());
|
|
List<EnterpriseManageCompanyInfo> data = new ArrayList<>();
|
for (EnterpriseManageCompanyInfo ImportData : duplicateRemoveImportData) {
|
if (!certificateNumFromDB.contains(ImportData.getCertificateNum())){
|
data.add(ImportData);
|
}
|
}
|
enterpriseManageCompanyInfoService.saveBatch(data);
|
int dataSize = 0;
|
if (data != null){
|
dataSize = data.size();
|
}
|
return AjaxResult.success("表格数据总共: "+tableSize+" ,去除重复后的数据条数："+duplicateRemoveImportDataSize+" ,与数据库比对去重后新增: "+dataSize + ".");
|
}
|
}
|
|
|
/**
|
* @description 统计某市各许可证期限数量 validityState（4-正常在期(非临期);3-90天内到期;2-60天内到期;1-30天内到期;0-已到期）
|
*/
|
private Long countEnterpriseNumByCityAndValidity(List<EnterpriseManageCompanyInfo> companyInfos,Byte validityState){
|
long count = companyInfos.stream()
|
.filter(companyInfo -> Optional.ofNullable(companyInfo.getValidityState()).orElse((byte) 6) == validityState)
|
.collect(Collectors.toList()).stream()
|
.count();
|
return count;
|
}
|
|
/**
|
* @description 重大危险源等级判断
|
*/
|
private Byte judgeMajorHazardSource(EnterpriseManageCompanyInfo enterpriseInfo){
|
if (enterpriseInfo != null){
|
if (enterpriseInfo.getLevelOneMajorHazardSourceSum() > 0){
|
return MajorHazardSourceEnum.ONE_LEVEL.getStatus();
|
}
|
if (enterpriseInfo.getLevelTwoMajorHazardSourceSum() > 0){
|
return MajorHazardSourceEnum.TWO_LEVEL.getStatus();
|
}
|
if (enterpriseInfo.getLevelThreeMajorHazardSourceSum() > 0){
|
return MajorHazardSourceEnum.THREE_LEVEL.getStatus();
|
}
|
if (enterpriseInfo.getLevelFourMajorHazardSourceSum() > 0){
|
return MajorHazardSourceEnum.FOUR_LEVEL.getStatus();
|
}
|
return MajorHazardSourceEnum.ZERO_LEVEL.getStatus();
|
}
|
return null;
|
}
|
|
/**
|
* @description 图片删除
|
*/
|
public static void deleteImage(EnterpriseManageCompanyInfo manageCompanyInfo){
|
List<String> imageAddress = new ArrayList<>();
|
if (StringUtils.isNoneBlank(manageCompanyInfo.getCompanyImage())){
|
imageAddress.add(manageCompanyInfo.getCompanyImage());
|
}
|
if (StringUtils.isNoneBlank(manageCompanyInfo.getBusinessLicense())){
|
imageAddress.add(manageCompanyInfo.getBusinessLicense());
|
}
|
if (StringUtils.isNoneBlank(manageCompanyInfo.getSecurityCertificate())){
|
imageAddress.add(manageCompanyInfo.getSecurityCertificate());
|
}
|
if (CollectionUtils.isNotEmpty(imageAddress)){
|
for (String address : imageAddress) {
|
File image = null;
|
try {
|
address = address.replaceFirst("/profile/","/");
|
image = FileUploadUtils.getAbsoluteFile(FileUploadUtils.getDefaultBaseDir(), address);
|
} catch (IOException e) {
|
throw new RuntimeException("获取图片地址失败");
|
}
|
if (image != null){
|
if (!image.delete()){
|
throw new RuntimeException("图片删除失败");
|
}
|
}
|
}
|
}
|
}
|
|
|
/**
|
* @description 新增时候对许可证进行一次有效期判断
|
*/
|
private Byte judgeValidityState(Date validityDateEnd){
|
Calendar calendar = Calendar.getInstance();
|
calendar.setTime(validityDateEnd);
|
calendar.set(Calendar.HOUR_OF_DAY,23);
|
calendar.set(Calendar.MINUTE,59);
|
calendar.set(Calendar.SECOND,59);
|
validityDateEnd = calendar.getTime();
|
|
Date date = new Date();
|
if (validityDateEnd.compareTo(date)<0){
|
return ValidityStateEnum.STATE_EXPIRED.getStatus();
|
}
|
int days = (int) ((validityDateEnd.getTime() - date.getTime()) / (1000*3600*24));
|
if (days <= 30){
|
return ValidityStateEnum.STATE_30_DAYS.getStatus();
|
}
|
if (days > 30 && days <= 60){
|
return ValidityStateEnum.STATE_60_DAYS.getStatus();
|
}
|
if (days > 60 && days <= 90){
|
return ValidityStateEnum.STATE_90_DAYS.getStatus();
|
}
|
return ValidityStateEnum.STATE_NORMAL.getStatus();
|
}
|
|
|
/**
|
* @description 图片保存功能
|
*/
|
public void initFileInfo(EnterpriseManageCompanyInfo companyInfo, MultipartFile companyImage,
|
MultipartFile businessLicense, MultipartFile securityCertificate) {
|
|
if (BooleanUtils.isTrue(companyInfo.getDeleteCompanyImage())) {
|
companyInfo.setCompanyImage("");
|
}
|
if (BooleanUtils.isTrue(companyInfo.getDeleteBusinessLicense())) {
|
companyInfo.setBusinessLicense("");
|
}
|
if (BooleanUtils.isTrue(companyInfo.getDeleteSecurityCertificate())) {
|
companyInfo.setSecurityCertificate("");
|
}
|
|
if (companyImage != null) {
|
// 上传文件路径
|
String filePath = RuoYiConfig.getUploadPath();
|
// 上传并返回新文件名称
|
String fileName = null;
|
try {
|
fileName = FileUploadUtils.upload(filePath, companyImage);
|
} catch (IOException e) {
|
throw new RuntimeException(e);
|
}
|
companyInfo.setCompanyImage(fileName);
|
}
|
|
if (businessLicense != null) {
|
// 上传文件路径
|
String filePath = RuoYiConfig.getUploadPath();
|
// 上传并返回新文件名称
|
String fileName = null;
|
try {
|
fileName = FileUploadUtils.upload(filePath, businessLicense);
|
} catch (IOException e) {
|
throw new RuntimeException(e);
|
}
|
companyInfo.setBusinessLicense(fileName);
|
}
|
|
if (securityCertificate != null) {
|
// 上传文件路径
|
String filePath = RuoYiConfig.getUploadPath();
|
// 上传并返回新文件名称
|
String fileName = null;
|
try {
|
fileName = FileUploadUtils.upload(filePath, securityCertificate);
|
} catch (IOException e) {
|
throw new RuntimeException(e);
|
}
|
companyInfo.setSecurityCertificate(fileName);
|
}
|
}
|
}
|
