package org.jeecg.modules.eam.controller;
|
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
|
import com.baomidou.mybatisplus.core.metadata.IPage;
|
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
|
import com.baomidou.mybatisplus.core.toolkit.ObjectUtils;
|
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
|
import io.swagger.annotations.Api;
|
import io.swagger.annotations.ApiOperation;
|
import lombok.extern.slf4j.Slf4j;
|
import org.apache.shiro.SecurityUtils;
|
import org.jeecg.common.api.vo.Result;
|
import org.jeecg.common.constant.CommonConstant;
|
import org.jeecg.common.system.api.ISysBaseAPI;
|
import org.jeecg.common.system.base.controller.JeecgController;
|
import org.jeecg.common.system.base.entity.DataVersion;
|
import org.jeecg.common.system.vo.LoginUser;
|
import org.jeecg.common.util.DateUtils;
|
import org.jeecg.modules.eam.entity.InspectionCycle;
|
import org.jeecg.modules.eam.entity.MaintenanceCycle;
|
import org.jeecg.modules.eam.service.IMaintenanceCycleService;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.springframework.web.bind.annotation.*;
|
|
import javax.servlet.http.HttpServletRequest;
|
import java.math.BigDecimal;
|
import java.text.ParseException;
|
import java.time.LocalDateTime;
|
import java.time.format.DateTimeFormatter;
|
import java.util.*;
|
|
/**
|
* @Description: mom_eam_inspection_cycle
|
* @Author: cj
|
* @Date: 2023-04-13
|
* @Version: V1.0
|
*/
|
@Api(tags = "保养周期规则")
|
@RestController
|
@RequestMapping("/eam/maintenanceCycle")
|
@Slf4j
|
public class MaintenanceCycleController extends JeecgController<MaintenanceCycle, IMaintenanceCycleService> {
|
|
|
@Autowired
|
private IMaintenanceCycleService maintenanceCycleService;
|
|
// @Autowired
|
// private IDataVersionService dataVersionService;
|
//
|
// @Autowired
|
// private IEnterpriseService enterpriseService;
|
//
|
// @Autowired
|
// private IQuartzJobService quartzJobService;
|
//
|
// @Autowired
|
// private ISysDictService dictService;
|
|
|
@Autowired
|
private ISysBaseAPI sysBaseApi;
|
|
/**
|
* 分页列表查询
|
*
|
* @param maintenanceCycle
|
* @param pageNo
|
* @param pageSize
|
* @param req
|
* @return
|
*/
|
@ApiOperation(value = "保养周期规则-分页列表查询", notes = "保养周期规则-分页列表查询")
|
@GetMapping(value = "/list")
|
public Result<IPage<Map<String, Object>>> queryPageList(MaintenanceCycle maintenanceCycle, @RequestParam(name = "pageNo", defaultValue = "1") Integer pageNo, @RequestParam(name = "pageSize", defaultValue = "10") Integer pageSize, HttpServletRequest req) {
|
Page<Map<String, Object>> page = new Page(pageNo, pageSize);
|
IPage<Map<String, Object>> pageList = maintenanceCycleService.page(page, maintenanceCycle);
|
return Result.OK(pageList);
|
}
|
|
|
/**
|
* 添加
|
*
|
* @param map
|
* @return
|
*/
|
@ApiOperation(value = "保养周期规则-添加", notes = "保养周期规则-添加")
|
@PostMapping(value = "/add")
|
public Result<String> add(@RequestBody Map<String, Object> map) {
|
MaintenanceCycle maintenanceCycle = new MaintenanceCycle();
|
// String cycleUnit = dictService.queryDictTextByKey("cycle_unit",String.valueOf(map.get("cycleUnit")));
|
String cycleUnit = sysBaseApi.queryDictTextByKey("cycle_unit", String.valueOf(map.get("cycleUnit")));
|
maintenanceCycle.setCode(String.valueOf(map.get("code"))).setName(String.valueOf(map.get("cycle")).concat(cycleUnit)).setCycle(new BigDecimal(String.valueOf(map.get("cycle")))).setCycleUnit(String.valueOf(map.get("cycleUnit"))).setArrangeWay(String.valueOf(map.get("arrangeWay"))).setAuditStatus(String.valueOf(map.get("auditStatus"))).setCalendarType(String.valueOf(map.get("calendarType"))).setEffectiveTime(new BigDecimal(String.valueOf(map.get("effectiveTime")))).setEnterpriseId(String.valueOf(map.get("enterpriseId"))).setUnit(String.valueOf(map.get("unit"))).setLeadTime(new BigDecimal(String.valueOf(map.get("leadTime"))))
|
.setVersion(String.valueOf(map.get("version"))).setFirstMaintenanceTime(DateUtils.str2Date(String.valueOf(map.get("firstMaintenanceTime")), DateUtils.datetimeFormat.get())).setDelFlag(0);
|
maintenanceCycleService.save(maintenanceCycle);
|
QueryWrapper<MaintenanceCycle> queryWrapper = new QueryWrapper<MaintenanceCycle>().eq("code", maintenanceCycle.getCode()).eq("version", maintenanceCycle.getVersion()).eq("del_flag", 0);
|
MaintenanceCycle selectMaintenanceCycle = maintenanceCycleService.getOne(queryWrapper, true);
|
DataVersion dataVersion = new DataVersion();
|
dataVersion.setBusinessId(selectMaintenanceCycle.getId()).setBusinessType("保养周期").setErterpriseId(String.valueOf(map.get("enterpriseId")))
|
.setVersion(Integer.parseInt(selectMaintenanceCycle.getVersion()))
|
.setVersionStatus(String.valueOf(map.get("versionStatus")))
|
.setDelFlag(0).setEffectiveType("0").setIsLastUsable("0");
|
sysBaseApi.saveDataVersion(dataVersion);
|
// DataVersion dataVersion = new DataVersion();
|
// dataVersion.setBusinessId(selectMaintenanceCycle.getId())
|
// .setBusinessType("保养周期")
|
// .setErterpriseId(String.valueOf(map.get("enterpriseId")))
|
// .setVersion(selectMaintenanceCycle.getVersion())
|
// .setVersionStatus(String.valueOf(map.get("versionStatus")))
|
// .setDelFlag(0)
|
// .setEffectiveType("0")
|
// .setIsLastUsable("0");
|
// dataVersionService.save(dataVersion);
|
/* QueryWrapper<DataVersion> queryWrapper1 = new QueryWrapper<DataVersion>()
|
.eq("business_id",selectMaintenanceCycle.getId()).eq("del_flag",0);
|
DataVersion selectDataVersion = dataVersionService.getOne(queryWrapper1,true);
|
selectMaintenanceCycle.setDataVersionId(selectDataVersion.getId());
|
maintenanceCycleService.saveOrUpdate(selectMaintenanceCycle);*/
|
return Result.OK("添加成功！");
|
}
|
|
|
/**
|
* 添加
|
*/
|
@PostMapping(value = "/addNew")
|
public Result<String> addNew(@RequestBody MaintenanceCycle maintenanceCycle) {
|
String cycleUnit = sysBaseApi.queryDictTextByKey("maintenance_cycle_unit", String.valueOf(maintenanceCycle.getCycleUnit()));
|
maintenanceCycle.setName(String.valueOf(maintenanceCycle.getCycle()).concat(cycleUnit));
|
maintenanceCycleService.save(maintenanceCycle);
|
return Result.OK("添加成功！");
|
}
|
|
/**
|
* 编辑
|
*
|
* @param maintenanceCycle
|
* @return
|
*/
|
@ApiOperation(value = "保养周期规则-编辑", notes = "保养周期规则-编辑")
|
@RequestMapping(value = "/edit", method = {RequestMethod.PUT, RequestMethod.POST})
|
public Result<String> edit(@RequestBody MaintenanceCycle maintenanceCycle) {
|
maintenanceCycleService.updateById(maintenanceCycle);
|
return Result.OK("编辑成功!");
|
}
|
|
/**
|
* 通过id删除
|
*
|
* @param id
|
* @return
|
*/
|
@ApiOperation(value = "保养周期规则-通过id删除", notes = "保养周期规则-通过id删除")
|
@DeleteMapping(value = "/delete")
|
public Result<String> delete(@RequestParam(name = "id", required = true) String id) {
|
maintenanceCycleService.removeById(id);
|
sysBaseApi.removeDataVersionByBusinessId(id);
|
|
// dataVersionService.update(new UpdateWrapper<DataVersion>()
|
// .set("del_flag",1)
|
// .eq("business_id",id));
|
// maintenanceCycleService.update(new UpdateWrapper<MaintenanceCycle>().
|
// set("del_flag",1)
|
// .eq("id",id));
|
return Result.OK("删除成功!");
|
}
|
|
/**
|
* 批量删除
|
*
|
* @param ids
|
* @return
|
*/
|
@ApiOperation(value = "保养周期规则-批量删除", notes = "保养周期规则-批量删除")
|
@DeleteMapping(value = "/deleteBatch")
|
public Result<String> deleteBatch(@RequestParam(name = "ids", required = true) String ids) {
|
// dataVersionService.update(new UpdateWrapper<DataVersion>().set("del_flag", 1).in("business_id", Arrays.asList(ids.split(","))));
|
// maintenanceCycleService.update(new UpdateWrapper<MaintenanceCycle>().set("del_flag", 1).in("id", Arrays.asList(ids.split(","))));
|
|
sysBaseApi.removeDataVersionByIds(ids);
|
maintenanceCycleService.removeBatchByIds(Arrays.asList(ids.split(",")));
|
return Result.OK("批量删除成功!");
|
}
|
|
/**
|
* 获取初始信息
|
*/
|
@GetMapping("/getMaintenanceCycleInfo")
|
public Result<?> getMaintenanceCycleInfo() {
|
Map<String, Object> infoMap = new HashMap<>(3);
|
LoginUser loginUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
|
// String enterpriseName = enterpriseService.lambdaQuery().eq(Enterprise::getId, loginUser.getEnterpriseId()).eq(Enterprise::getDelFlag, CommonConstant.DEL_FLAG_0).one().getName();
|
String enterpriseName = sysBaseApi.getEnterpriseNameById(loginUser.getEnterpriseId());
|
infoMap.put("enterpriseId", loginUser.getEnterpriseId());
|
infoMap.put("enterpriseName", enterpriseName);
|
if (CollectionUtils.isNotEmpty(maintenanceCycleService.getUsableVersion())) {
|
infoMap.put("version", maintenanceCycleService.getUsableVersion().get(0));
|
// String versionStatus = dataVersionService.lambdaQuery().eq(DataVersion::getVersion, maintenanceCycleService.getUsableVersion().get(0)).eq(DataVersion::getBusinessType, "保养周期").eq(DataVersion::getDelFlag, CommonConstant.DEL_FLAG_0).list().get(0).getVersionStatus();
|
String versionStatus = sysBaseApi.getVersionStatusByVersionAndBusinessType(maintenanceCycleService.getUsableVersion().get(0), "保养周期");
|
infoMap.put("versionStatus", versionStatus);
|
} else {
|
infoMap.put("version", 1);
|
infoMap.put("versionStatus", "0");
|
}
|
return Result.OK(infoMap);
|
}
|
|
/**
|
* 获取所有版本号
|
*/
|
@GetMapping("/getVersionList")
|
public Result<?> getAllVersion() {
|
return Result.OK(maintenanceCycleService.getVersionList());
|
}
|
|
/**
|
* 根据版本号获取版本状态
|
*/
|
@PostMapping("/getVersionStatus")
|
public Result<?> getVersionStatus(@RequestBody Map<String, Object> map) {
|
Integer version = Integer.parseInt((String) map.get("version"));
|
// String versionStatus = dataVersionService.lambdaQuery().eq(DataVersion::getVersion, version).eq(DataVersion::getBusinessType, "保养周期").eq(DataVersion::getDelFlag, CommonConstant.DEL_FLAG_0).list().get(0).getVersionStatus();
|
String versionStatus = sysBaseApi.getVersionStatusByVersionAndBusinessType(version, "保养周期");
|
return Result.OK(versionStatus);
|
}
|
|
/**
|
* 升版
|
*
|
* @param map
|
* @return
|
*/
|
@PostMapping("/updateVersion")
|
@Transactional
|
public Result<?> updateVersion(@RequestBody Map<String, Object> map) {
|
Integer version = Integer.parseInt((String) map.get("version"));
|
String enterpriseId = String.valueOf(map.get("enterpriseId"));
|
List<MaintenanceCycle> maintenanceCycleList = maintenanceCycleService.lambdaQuery().eq(MaintenanceCycle::getEnterpriseId, enterpriseId).eq(MaintenanceCycle::getVersion, version).eq(MaintenanceCycle::getDelFlag, CommonConstant.DEL_FLAG_0).list();
|
Integer newVersion = maintenanceCycleService.getVersionList().stream().findFirst().get() + 1;
|
for (MaintenanceCycle maintenanceCycle : maintenanceCycleList) {
|
// DataVersion oldDataVersion = dataVersionService.lambdaQuery().eq(DataVersion::getBusinessId, maintenanceCycle.getId()).eq(DataVersion::getDelFlag, CommonConstant.DEL_FLAG_0).one();
|
DataVersion oldDataVersion = sysBaseApi.getDataVersionByBusinessId(maintenanceCycle.getId());
|
maintenanceCycle.setId(null);
|
maintenanceCycle.setVersion(newVersion.toString());
|
maintenanceCycleService.save(maintenanceCycle);
|
DataVersion dataVersion = new DataVersion();
|
dataVersion.setBusinessId(maintenanceCycle.getId()).setBusinessType("保养周期").setVersion(newVersion).setErterpriseId(enterpriseId).setVersionStatus("1").setDelFlag(0).setEffectiveType("0").setSourceVersionId(oldDataVersion.getId()).setIsLastUsable("0");
|
// dataVersionService.save(dataVersion);
|
sysBaseApi.saveDataVersion(dataVersion);
|
}
|
return Result.OK("升版成功", newVersion);
|
}
|
|
/**
|
* 立即生效
|
*
|
* @param map
|
* @param
|
* @return
|
*/
|
@PostMapping("/updateVersionStatusToUsable")
|
@Transactional
|
public Result<?> updateVersionStatusToUsable(@RequestBody Map<String, Object> map) {
|
//如果有定时生生效,则将定时生效任务关闭
|
// QuartzJob quartzJob = quartzJobService.getOne(new QueryWrapper<QuartzJob>().eq("job_class_name", "org.jeecg.modules.quartz.job.MaintenanceCycleSetUsableJob"), true);
|
// if (ObjectUtils.isNotNull(quartzJob)) {
|
// quartzJobService.deleteAndStopJob(quartzJob);
|
// }
|
|
sysBaseApi.closeJobByClassName("org.jeecg.modules.quartz.job.MaintenanceCycleSetUsableJob");
|
//获取版本号
|
Integer version = Integer.parseInt((String) map.get("version"));
|
String enterpriseId = String.valueOf(map.get("enterpriseId"));
|
//将上次生效的是否上次生效置为否
|
// List<DataVersion> lastDataVersions = dataVersionService.lambdaQuery().eq(DataVersion::getBusinessType, "保养周期").eq(DataVersion::getErterpriseId, enterpriseId).eq(DataVersion::getIsLastUsable, "1").list();
|
List<DataVersion> lastDataVersions = sysBaseApi.getLastDataVersion("保养周期", enterpriseId, "1");
|
for (DataVersion dataVersion : lastDataVersions) {
|
dataVersion.setIsLastUsable("0");
|
}
|
sysBaseApi.updateBatchDataVersion(lastDataVersions);
|
//将状态为生效的置为失效
|
// List<DataVersion> dataVersions = dataVersionService.lambdaQuery().eq(DataVersion::getBusinessType, "保养周期").eq(DataVersion::getErterpriseId, enterpriseId).eq(DataVersion::getVersionStatus, "2").list();
|
List<DataVersion> dataVersions = sysBaseApi.getDataVersionList("保养周期", enterpriseId, "2", null);
|
for (DataVersion dataVersion : dataVersions) {
|
dataVersion.setVersionStatus("3");
|
dataVersion.setIsLastUsable("1");
|
dataVersion.setExpiredTime(new Date(System.currentTimeMillis()));
|
}
|
sysBaseApi.updateBatchDataVersion(dataVersions);
|
//获取待生效版本及版本信息并将其置为生效
|
// List<DataVersion> dataVersionList = dataVersionService.lambdaQuery().eq(DataVersion::getBusinessType, "保养周期").eq(DataVersion::getVersion, version).eq(DataVersion::getErterpriseId, enterpriseId).list();
|
List<DataVersion> dataVersionList = sysBaseApi.getDataVersionList("保养周期", enterpriseId, null, version.toString());
|
|
for (DataVersion dataVersion : dataVersionList) {
|
dataVersion.setVersionStatus("2");
|
dataVersion.setEffectiveType("2");
|
dataVersion.setEffectiveTime(new Date(System.currentTimeMillis()));
|
dataVersion.setIsLastUsable("0");
|
}
|
// dataVersionService.updateBatchById(dataVersionList);
|
sysBaseApi.updateBatchDataVersion(dataVersionList);
|
return Result.OK("生效成功");
|
}
|
//
|
// /**
|
// * 定时生效
|
// *
|
// * @param quartzJob
|
// * @param
|
// * @return
|
// */
|
// @PostMapping("/updateVersionStatusToUsableBySetTime")
|
// @Transactional
|
// public Result<?> updateVersionStatusToUsableBySetTime(@RequestBody QuartzJob quartzJob) throws ParseException {
|
// DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
|
// DateTimeFormatter dateTimeFormatter1 = DateTimeFormatter.ofPattern("ss mm HH dd MM ? yyyy");
|
// String jobClassName = quartzJob.getJobClassName();
|
// String time = quartzJob.getCronExpression();
|
// System.out.println(time);
|
// LocalDateTime localDateTime = LocalDateTime.parse(time, dateTimeFormatter);
|
// String cronStr = dateTimeFormatter1.format(localDateTime);
|
// quartzJob.setCronExpression(cronStr);
|
// QueryWrapper<QuartzJob> queryWrapper = new QueryWrapper();
|
// queryWrapper.eq("JOB_CLASS_NAME", jobClassName);
|
// List<QuartzJob> quartzJobs = quartzJobService.list(queryWrapper);
|
// if (CollectionUtils.isEmpty(quartzJobs)) {
|
// quartzJobService.saveAndScheduleJob(quartzJob);
|
// quartzJobs = quartzJobService.list(queryWrapper);
|
// quartzJob.setId(quartzJobs.get(0).getId());
|
// quartzJobService.resumeJob(quartzJob);
|
// return Result.OK(quartzJob);
|
// } else {
|
// quartzJob.setId(quartzJobs.get(0).getId());
|
// quartzJobService.resumeJob(quartzJob);
|
// return Result.OK(quartzJob);
|
// }
|
// }
|
/**
|
* 版本升级
|
* qsw 2023-7-26
|
*/
|
@PostMapping(value = "/revise")
|
public Result<String> revise(@RequestBody MaintenanceCycle maintenanceCycle) {
|
String cycleUnit = sysBaseApi.queryDictTextByKey("maintenance_cycle_unit", String.valueOf(maintenanceCycle.getCycleUnit()));
|
maintenanceCycle.setId("");
|
maintenanceCycle.setName(String.valueOf(maintenanceCycle.getCycle()).concat(cycleUnit));
|
maintenanceCycle.setCreateTime(new Date());
|
maintenanceCycle.setUpdateBy(null);
|
maintenanceCycle.setUpdateTime(null);
|
maintenanceCycle.setLoseEfficacyTime(null);
|
maintenanceCycle.setTakeEffectTime(null);
|
boolean b = maintenanceCycleService.save(maintenanceCycle);
|
if(b){
|
return Result.OK("版本升级成功！");
|
}else{
|
return Result.error("版本升级失败！");
|
}
|
|
}
|
|
/**
|
* 升版
|
* qsw 2023-7-26
|
*/
|
@RequestMapping("/getReviseVersion")
|
public Result<?> getReviseVersion(@RequestBody MaintenanceCycle maintenanceCycle) {
|
List<MaintenanceCycle> maintenanceCycles = maintenanceCycleService.lambdaQuery()
|
.eq(MaintenanceCycle::getCode, maintenanceCycle.getCode())
|
.orderByDesc(MaintenanceCycle::getVersion).list();
|
String version = maintenanceCycles.get(0).getVersion();
|
BigDecimal versionB = new BigDecimal(version);
|
BigDecimal versionCode = versionB.add(new BigDecimal(1));
|
return Result.ok(versionCode.toString());
|
}
|
|
/**
|
* 版本生效
|
* qsw 2023-7-26
|
*/
|
@RequestMapping(value = "/versionTakeEffect", method = {RequestMethod.PUT,RequestMethod.POST})
|
@Transactional(rollbackFor = { Exception.class })
|
public Result<String> versionTakeEffect(@RequestBody MaintenanceCycle maintenanceCycle) {
|
List<MaintenanceCycle> maintenanceCycles = maintenanceCycleService.lambdaQuery()
|
.eq(MaintenanceCycle::getCode, maintenanceCycle.getCode())
|
.orderByDesc(MaintenanceCycle::getVersion).list();
|
for (MaintenanceCycle cycle : maintenanceCycles) {
|
cycle.setVersionStatus("3");
|
cycle.setLoseEfficacyTime(new Date());
|
maintenanceCycleService.updateById(cycle);
|
}
|
maintenanceCycle.setTakeEffectTime(new Date());
|
boolean b = maintenanceCycleService.updateById(maintenanceCycle);
|
if (b){
|
return Result.OK("生效成功!");
|
}else{
|
return Result.error("生效失败!");
|
}
|
}
|
}
|
