package org.jeecg.modules.base.controller;
|
|
import java.text.ParseException;
|
import java.time.LocalDateTime;
|
import java.time.format.DateTimeFormatter;
|
import java.util.*;
|
import java.util.stream.Collectors;
|
import javax.servlet.http.HttpServletRequest;
|
import javax.servlet.http.HttpServletResponse;
|
|
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
|
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
|
import com.baomidou.mybatisplus.core.toolkit.ObjectUtils;
|
import org.jeecg.common.api.vo.Result;
|
import org.jeecg.modules.base.entity.*;
|
import org.jeecg.modules.base.service.*;
|
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
import com.baomidou.mybatisplus.core.metadata.IPage;
|
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
|
import lombok.extern.slf4j.Slf4j;
|
|
import org.jeecg.common.system.base.controller.JeecgController;
|
import org.jeecg.modules.quartz.entity.QuartzJob;
|
import org.jeecg.modules.quartz.service.IQuartzJobService;
|
import org.jeecg.common.system.base.entity.DataVersion;
|
import org.jeecg.modules.system.service.IDataVersionService;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.springframework.web.bind.annotation.*;
|
import org.springframework.web.servlet.ModelAndView;
|
import io.swagger.annotations.Api;
|
import io.swagger.annotations.ApiOperation;
|
import org.jeecg.common.aspect.annotation.AutoLog;
|
|
/**
|
* @Description: mom_base_work_center
|
* @Author: jeecg-boot
|
* @Date: 2022-11-17
|
* @Version: V1.0
|
*/
|
@Api(tags="工作中心")
|
@RestController
|
@RequestMapping("/base/workCenter")
|
@Slf4j
|
public class WorkCenterController extends JeecgController<WorkCenter, IWorkCenterService> {
|
@Autowired
|
private IWorkCenterService workCenterService;
|
@Autowired
|
private IFactoryModelService factoryModelService;
|
@Autowired
|
private IQuartzJobService quartzJobService;
|
@Autowired
|
private IDataVersionService dataVersionService;
|
@Autowired
|
private IWorkCenterUserService workCenterUserService;
|
@Autowired
|
private IWorkCenterEquipmentService workCenterEquipmentService;
|
@Autowired
|
private IEnterpriseService enterpriseService;
|
/**
|
* 根据版本获取版本号
|
*
|
*
|
*/
|
@GetMapping("/getVersionStatusByVersion")
|
public Result<?> getVersionStatusByVersion(@RequestParam(value = "version",required = false) Integer version){
|
return Result.OK(workCenterService.getVersionStatusByVersion(version));
|
}
|
/**
|
* 获取初始版本号
|
*
|
* @return
|
*/
|
@GetMapping("getInitVersion")
|
public Result<?> getInitVersion(){
|
return Result.OK(workCenterService.getInitVersion());
|
}
|
/**
|
* 获取根节点
|
*
|
* @param eid
|
* @param fid
|
* @return
|
*/
|
@GetMapping("/getTop/{eid}/{fid}")
|
public Result<?> getTop(@PathVariable("eid") String eid,@PathVariable("fid") String fid){
|
return Result.OK(workCenterService.getTop(eid,fid));
|
}
|
/**
|
*
|
* 查当前生效企业下有无部门历史版本
|
*
|
*/
|
@Transactional
|
@GetMapping(value = "/getUpdateVersionPermission")
|
public Result<?> getUpdatePermission(@RequestParam("version") Integer version){
|
List<String> usableIds = factoryModelService
|
.getUsableList(enterpriseService.getUsableIdList())
|
.stream()
|
.map(FactoryModel::getId)
|
.collect(Collectors.toList());
|
if(CollectionUtils.isNotEmpty(usableIds)){
|
return Result.OK(workCenterService.list(new QueryWrapper<WorkCenter>()
|
.in("parent_factory_model_id",usableIds)
|
.eq("version",version)
|
.eq("del_flag",0)));
|
}
|
return Result.ok();
|
}
|
/**
|
*
|
* 查当前生效企业下的生效工厂下有无工作中心历史版本
|
*
|
*/
|
@Transactional
|
@GetMapping(value = "/getNewVersionPermission")
|
public Result<?> getNewVersionPermission(){
|
List<FactoryModel> usableFactoryList = factoryModelService
|
.list(new QueryWrapper<FactoryModel>()
|
.eq("del_flag",0)
|
.in("enterprise_id",enterpriseService.getUsableIdList()));
|
if(CollectionUtils.isEmpty(usableFactoryList)){
|
return Result.OK(false);
|
}else {
|
List<WorkCenter> list = workCenterService
|
.list(new QueryWrapper<WorkCenter>()
|
.in("parent_factory_model_id",usableFactoryList.stream().map(FactoryModel::getId).collect(Collectors.toList()))
|
.eq("del_flag",0));
|
if(CollectionUtils.isNotEmpty(list)){
|
return Result.OK(false);
|
}
|
else {
|
return Result.OK(true);
|
}
|
}
|
}
|
/**
|
* 升版
|
* 需要一次完成
|
* @param map
|
* @param
|
* @return
|
*/
|
@PostMapping("/updateVersion")
|
@Transactional
|
public Result<?> updateVersion(@RequestBody Map<String,Object> map){
|
Integer version = Integer.parseInt((String)map.get("version"));
|
//获取升版数据
|
List<WorkCenter> list = workCenterService.getUpdateVersionlist(version);
|
//获取升版数据的版本信息
|
QueryWrapper<DataVersion> queryWrapper = new QueryWrapper<DataVersion>()
|
.in("business_id", list.stream().map(WorkCenter::getId).collect(Collectors.toList()))
|
.eq("del_flag",0);
|
List<DataVersion> dataVersionList = dataVersionService.list(queryWrapper);
|
Set<Integer> set = workCenterService.getVersionList();
|
Optional<Integer> maxVersion = set.stream().findFirst();
|
list.stream().forEach(workCenter -> {
|
workCenter.setId("");
|
workCenter.setVersion(maxVersion.get()+1);
|
});
|
workCenterService.saveBatch(list);
|
List<WorkCenter> newList = workCenterService
|
.list(new QueryWrapper<WorkCenter>()
|
.eq("version",maxVersion.get()+1));
|
List<DataVersion> newDataVersionList = new ArrayList<>();
|
for(int i=0;i<newList.size();i++){
|
DataVersion dataVersion = new DataVersion();
|
for(int j=0;j<list.size();j++){
|
for(int k=0;k<dataVersionList.size();k++){
|
if(list.get(j).getCode().equals(newList.get(i).getCode())
|
&&list.get(j).getDataVersionId().equals(dataVersionList.get(k).getId())) {
|
dataVersion
|
.setVersion(maxVersion.get() + 1)
|
.setVersionStatus("1")
|
.setBusinessId(newList.get(i).getId())
|
.setDelFlag(0)
|
.setSourceVersionId(dataVersionList.get(k).getId())
|
.setBusinessType("工作中心")
|
.setIsLastUsable("0");
|
}
|
}
|
}
|
newDataVersionList.add(dataVersion);
|
}
|
dataVersionService.saveBatch(newDataVersionList);
|
List<String> dataVersionBusinessIdList = newDataVersionList.stream().map(DataVersion::getBusinessId).collect(Collectors.toList());
|
QueryWrapper<DataVersion> queryWrapper1 = new QueryWrapper<DataVersion>().in("business_id",dataVersionBusinessIdList).eq("del_flag",0);
|
List<DataVersion> selectDataVersionList = dataVersionService.list(queryWrapper1);
|
for(int i=0;i<newList.size();i++){
|
for(int j=0;j<selectDataVersionList.size();j++){
|
if(newList.get(i).getId().equals(selectDataVersionList.get(j).getBusinessId())){
|
newList.get(i).setDataVersionId(selectDataVersionList.get(j).getId());
|
}
|
}
|
}
|
workCenterService.updateBatchById(newList);
|
return Result.OK(maxVersion.get()+1);
|
}
|
/**
|
* 维护升版
|
* 需要一次完成
|
* @param
|
* @return
|
*/
|
@PostMapping("/updateVersionForChange")
|
@Transactional
|
public Result<?> updateVersionForChange(){
|
Set<Integer> set = workCenterService.getVersionList();
|
return Result.OK(set.stream().findFirst().get()+1);
|
}
|
/**
|
* 生效
|
* 需要一次性完成
|
* @param
|
* @param map
|
* @return
|
*/
|
@PostMapping("/updateVersionStatusToUsable")
|
@Transactional
|
public Result<?> updateVersionStatusToUsable(@RequestBody Map<String,Object> map){
|
Date date = new Date(System.currentTimeMillis());
|
QuartzJob quartzJob = quartzJobService.getOne(new QueryWrapper<QuartzJob>()
|
.eq("job_class_name","org.jeecg.modules.quartz.job.WorkCenterSetUsableJob"),true);
|
if(ObjectUtils.isNotNull(quartzJob)){
|
quartzJobService.deleteAndStopJob(quartzJob);
|
}
|
String factoryModelId = String.valueOf(map.get("factoryModelId"));
|
Integer version = Integer.parseInt((String)map.get("version"));
|
//获取上次生效版本并将其是否上次生效位置置为否
|
List<WorkCenter> lastUsableList = workCenterService.getLastUsableVersion();
|
if(CollectionUtils.isNotEmpty(lastUsableList)){
|
QueryWrapper<DataVersion> queryWrapper2 = new QueryWrapper<DataVersion>()
|
.in("business_id",lastUsableList.stream()
|
.map(WorkCenter::getId)
|
.collect(Collectors.toList()));
|
List<DataVersion> lastUsableVersionList = dataVersionService.list(queryWrapper2);
|
lastUsableVersionList.stream().forEach(dataVersion -> {
|
dataVersion
|
.setIsLastUsable("0");
|
});
|
dataVersionService.updateBatchById(lastUsableVersionList);
|
}
|
//获取生效版本及版本信息并将其置为失效
|
List<WorkCenter> usableList = workCenterService.getUsableList();
|
if(CollectionUtils.isNotEmpty(usableList)){
|
QueryWrapper<DataVersion> queryWrapper = new QueryWrapper<DataVersion>()
|
.in("business_id",usableList.stream()
|
.map(WorkCenter::getId)
|
.collect(Collectors.toList()));
|
List<DataVersion> usableDataVersionList = dataVersionService.list(queryWrapper);
|
usableDataVersionList.stream().forEach(dataVersion -> {
|
dataVersion
|
.setVersionStatus("3")
|
.setIsLastUsable("1")
|
.setExpiredTime(date);
|
});
|
dataVersionService.updateBatchById(usableDataVersionList);
|
}
|
//获取待生效版本及版本信息并将其置为生效
|
QueryWrapper<DataVersion> queryWrapper1 = new QueryWrapper<DataVersion>()
|
.in("business_id",workCenterService
|
.getUpdateVersionlist(version)
|
.stream().map(WorkCenter::getId)
|
.collect(Collectors.toList()));
|
List<DataVersion> dataVersionList = dataVersionService.list(queryWrapper1);
|
dataVersionList.stream().forEach(dataVersion -> {
|
dataVersion.setVersionStatus("2")
|
.setEffectiveType("2")
|
.setEffectiveTime(date)
|
.setIsLastUsable("0");
|
});
|
//存入数据库
|
dataVersionService.updateBatchById(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);
|
}
|
|
}
|
/**
|
* 分页列表查询
|
*
|
* @param workCenterDetail
|
* @param pageNo
|
* @param pageSize
|
* @return
|
*/
|
@ApiOperation(value="mom_base_work_center-分页列表查询", notes="mom_base_work_center-分页列表查询")
|
@GetMapping(value = "/list")
|
public Result<IPage<WorkCenterDetail>> queryPageList(WorkCenterDetail workCenterDetail,
|
@RequestParam(name="pageNo", defaultValue="1") Integer pageNo,
|
@RequestParam(name="pageSize", defaultValue="10") Integer pageSize,
|
@RequestParam(name="parentFactoryModelId",required = true,defaultValue = "") String parentFactoryModelId,
|
@RequestParam(name="factoryModelVersion",required = true,defaultValue = "") Integer factoryModelVersion,
|
@RequestParam(name="version",required = true,defaultValue = "") Integer version
|
) {
|
Page<WorkCenterDetail> page = new Page(pageNo, pageSize);
|
IPage<WorkCenterDetail> pageList = workCenterService.getAllWorkCenterByPMFId(page,parentFactoryModelId,factoryModelVersion,version);
|
return Result.OK(pageList);
|
}
|
/**
|
* 获取版本号
|
*
|
*
|
* @return
|
*/
|
@GetMapping("/versionList")
|
public Result<?> getVersionList(){
|
return Result.OK( workCenterService.getVersionList());
|
}
|
/**
|
* 获取工厂建模生效失效列表
|
* @return
|
*/
|
@GetMapping("/getFactoryVersionList")
|
public Result<?> getFactoryVersionList(){
|
return Result.OK(workCenterService.getFactoryVersionList());
|
}
|
/**
|
* 添加
|
*
|
* @param map
|
* @return
|
*/
|
@AutoLog(value = "mom_base_work_center-添加")
|
@ApiOperation(value="mom_base_work_center-添加", notes="mom_base_work_center-添加")
|
@PostMapping(value = "/add")
|
@Transactional
|
public Result<String> add(@RequestBody Map<String,Object> map) {
|
WorkCenter workCenter = new WorkCenter();
|
//(设置保存的工作中心数据）
|
workCenter.setCode(String.valueOf(map.get("code")))
|
.setName(String.valueOf(map.get("name")))
|
.setServiceCategory(String.valueOf(map.get("serviceCategory")))
|
.setWorkCenterCategory(String.valueOf(map.get("workCenterCategory")))
|
.setEquipmentTeamId(String.valueOf(map.get("equipmentTeamId")))
|
.setFeedingArea(String.valueOf(map.get("feedingArea")))
|
.setBaitingArea(String.valueOf(map.get("baitingArea")))
|
.setRemark(String.valueOf(map.get("remark")))
|
.setVersion(Integer.parseInt(String.valueOf(map.get("version"))))
|
.setFactoryModelId(String.valueOf(map.get("factoryModelId")))
|
.setParentFactoryModelId(String.valueOf(map.get("parentFactoryModelId")))
|
.setDelFlag(0);
|
workCenterService.save(workCenter);
|
QueryWrapper<WorkCenter> queryWrapper = new QueryWrapper<WorkCenter>()
|
.eq("code",workCenter.getCode()).eq("version",workCenter.getVersion()).eq("del_flag",0);
|
WorkCenter selectWorkCenter = workCenterService.getOne(queryWrapper,true);
|
DataVersion dataVersion = new DataVersion();
|
dataVersion.setBusinessId(selectWorkCenter.getId())
|
.setBusinessType("工作中心")
|
.setVersion(selectWorkCenter.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",selectWorkCenter.getId()).eq("del_flag",0);
|
DataVersion selectDataVersion = dataVersionService.getOne(queryWrapper1,true);
|
selectWorkCenter.setDataVersionId(selectDataVersion.getId());
|
workCenterService.saveOrUpdate(selectWorkCenter);
|
return Result.OK("添加成功！");
|
}
|
|
/**
|
* 编辑
|
*
|
* @param workCenter
|
* @return
|
*/
|
@AutoLog(value = "mom_base_work_center-编辑")
|
@ApiOperation(value="mom_base_work_center-编辑", notes="mom_base_work_center-编辑")
|
@RequestMapping(value = "/edit", method = {RequestMethod.PUT,RequestMethod.POST})
|
public Result<String> edit(@RequestBody WorkCenter workCenter) {
|
workCenterService.updateById(workCenter);
|
return Result.OK("编辑成功!");
|
}
|
|
/**
|
* 通过id删除
|
*
|
* @param id
|
* @return
|
*/
|
@AutoLog(value = "mom_base_work_center-通过id删除")
|
@ApiOperation(value="mom_base_work_center-通过id删除", notes="mom_base_work_center-通过id删除")
|
@DeleteMapping(value = "/delete")
|
public Result<String> delete(@RequestParam(name="id",required=true) String id) {
|
dataVersionService.update(new UpdateWrapper<DataVersion>()
|
.set("del_flag",1)
|
.eq("business_id",id));
|
workCenterService.update(new UpdateWrapper<WorkCenter>().
|
set("del_flag",1)
|
.eq("id",id));
|
return Result.OK("删除成功!");
|
}
|
|
/**
|
* 批量删除
|
*
|
* @param ids
|
* @return
|
*/
|
@AutoLog(value = "mom_base_work_center-批量删除")
|
@ApiOperation(value="mom_base_work_center-批量删除", notes="mom_base_work_center-批量删除")
|
@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(","))));
|
workCenterService.
|
update(new UpdateWrapper<WorkCenter>()
|
.set("del_flag",1)
|
.in("id",Arrays.asList(ids.split(","))));
|
return Result.OK("删除成功");
|
}
|
|
/**
|
* 通过id查询
|
*
|
* @param id
|
* @return
|
*/
|
//@AutoLog(value = "mom_base_work_center-通过id查询")
|
@ApiOperation(value="mom_base_work_center-通过id查询", notes="mom_base_work_center-通过id查询")
|
@GetMapping(value = "/queryById")
|
public Result<WorkCenter> queryById(@RequestParam(name="id",required=true) String id) {
|
WorkCenter workCenter = workCenterService.getById(id);
|
if(workCenter==null) {
|
return Result.error("未找到对应数据");
|
}
|
return Result.OK(workCenter);
|
}
|
|
/**
|
* 导出excel
|
*
|
* @param request
|
* @param workCenter
|
*/
|
//@RequiresPermissions("org.jeecg.modules.demo:mom_base_work_center:exportXls")
|
@RequestMapping(value = "/exportXls")
|
public ModelAndView exportXls(HttpServletRequest request, WorkCenter workCenter) {
|
return super.exportXls(request, workCenter, WorkCenter.class, "mom_base_work_center");
|
}
|
|
/**
|
* 通过excel导入数据
|
*
|
* @param request
|
* @param response
|
* @return
|
*/
|
//@RequiresPermissions("mom_base_work_center:importExcel")
|
@RequestMapping(value = "/importExcel", method = RequestMethod.POST)
|
public Result<?> importExcel(HttpServletRequest request, HttpServletResponse response) {
|
return super.importExcel(request, response, WorkCenter.class);
|
}
|
/**
|
* 获取该工作中心所在企业的设备组列表
|
*
|
* @param enterpriseId
|
* @return
|
*/
|
@GetMapping("/equipmentCategorylist")
|
public Result<?> getEquipmentCategoryListByEnterpriseId(@RequestParam(name = "enterpriseId",required = false) String enterpriseId){
|
return Result.OK(workCenterService.getEquipmentCategoryListByEnterpriseId(enterpriseId));
|
}
|
/**
|
* 获取当前生效版本和上一次生效版本的版本号
|
*
|
* @param
|
* @return
|
*/
|
@GetMapping("/getNowAndLastUsableVersion")
|
public Result<?> getNowAndLastUsableVersion(){
|
return Result.OK(workCenterService.getNowAndLastUsableVersion());
|
}
|
/**
|
* 校验名称是否重复
|
*
|
* @param
|
* @return
|
*/
|
@GetMapping("/check")
|
public Result<?> check( @RequestParam(name="parentFactoryModelId",required = false,defaultValue = "") String parentFactoryModelId,
|
@RequestParam(name="version",required = false) Integer version,
|
@RequestParam(name="name") String name
|
){
|
QueryWrapper<WorkCenter> queryWrapper = new QueryWrapper<WorkCenter>()
|
.eq("parent_factory_model_id",parentFactoryModelId)
|
.eq("name",name)
|
.eq("version",version)
|
.eq("del_flag",0);
|
return Result.OK(workCenterService.list(queryWrapper));
|
}
|
/**
|
* 删除消息提醒
|
*
|
* @param delIndexList
|
* @return
|
*/
|
@PostMapping("/checkDel")
|
@Transactional
|
public Result<?> checkDel(@RequestBody List<String> delIndexList){
|
List<WorkCenterEquipment> workCenterEquipments = workCenterEquipmentService
|
.list(new QueryWrapper<WorkCenterEquipment>()
|
.in("work_center_id",delIndexList)
|
.eq("del_flag",0)
|
);
|
List<WorkCenterUser> workCenterUsers = workCenterUserService.list(new QueryWrapper<WorkCenterUser>()
|
.in("work_center_id",delIndexList)
|
.eq("del_flag",0)
|
);
|
List<String> list1 = workCenterEquipments.stream().map(WorkCenterEquipment::getWorkCenterId).collect(Collectors.toList());
|
List<String> list2 = workCenterUsers.stream().map(WorkCenterUser::getWorkCenterId).collect(Collectors.toList());
|
Set<String> set = new TreeSet<>();
|
set.addAll(list1);
|
set.addAll(list2);
|
if(CollectionUtils.isNotEmpty(set)){
|
List<WorkCenter> workCenterList = workCenterService.listByIds(set);
|
final String[] listMessage = {""};
|
if(CollectionUtils.isNotEmpty(workCenterList)){
|
workCenterList.stream().forEach(workCenter -> {
|
listMessage[0] = listMessage[0] +workCenter.getCode()+",";
|
});
|
String trueMessage = "编号为"+listMessage[0]
|
.substring(0, listMessage[0].length()-1)+"的数据被引用，确认删除吗？";
|
return Result.OK(trueMessage);
|
}
|
}
|
return Result.OK("选中数据没有被引用，可以安全删除，确认删除吗？");
|
}
|
}
|
