package org.jeecg.modules.dncFlow.service.impl;
|
|
import cn.hutool.core.util.StrUtil;
|
import com.alibaba.fastjson.JSON;
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
import com.baomidou.mybatisplus.core.metadata.IPage;
|
import com.baomidou.mybatisplus.core.toolkit.IdWorker;
|
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
|
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
|
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
|
import org.apache.commons.lang3.StringUtils;
|
import org.apache.shiro.SecurityUtils;
|
import org.flowable.engine.TaskService;
|
import org.flowable.engine.runtime.ProcessInstance;
|
import org.flowable.task.api.Task;
|
import org.jeecg.common.api.vo.Result;
|
import org.jeecg.common.system.vo.LoginUser;
|
import org.jeecg.modules.dnc.entity.*;
|
import org.jeecg.modules.dnc.exception.ExceptionCast;
|
import org.jeecg.modules.dnc.ext.NcTxtFilePathInfo;
|
import org.jeecg.modules.dnc.response.*;
|
import org.jeecg.modules.dnc.service.*;
|
import org.jeecg.modules.dnc.utils.ValidateUtil;
|
import org.jeecg.modules.dnc.utils.date.DateUtil;
|
import org.jeecg.modules.dnc.utils.file.FileUtilS;
|
import org.jeecg.modules.dncFlow.entity.AssignFileStream;
|
import org.jeecg.modules.dncFlow.entity.ToEquipmentTask;
|
import org.jeecg.modules.dncFlow.ext.AssignFileStreamExt;
|
import org.jeecg.modules.dncFlow.mapper.AssignFileStreamMapper;
|
import org.jeecg.modules.dncFlow.request.ApproveBatchRequest;
|
import org.jeecg.modules.dncFlow.request.AssignFileRequest;
|
import org.jeecg.modules.dncFlow.request.AssignFileStreamQueryRequest;
|
import org.jeecg.modules.dncFlow.request.TaskRequest;
|
import org.jeecg.modules.dncFlow.service.IAssignFileStreamService;
|
import org.jeecg.modules.dncFlow.service.IToEquipmentTaskService;
|
import org.jeecg.modules.dncFlow.vo.AssignFlowTaskVo;
|
import org.jeecg.modules.flowable.apithird.business.entity.FlowMyBusiness;
|
import org.jeecg.modules.flowable.apithird.business.service.IFlowMyBusinessService;
|
import org.jeecg.modules.flowable.apithird.service.FlowCallBackServiceI;
|
import org.jeecg.modules.flowable.apithird.service.FlowCommonService;
|
import org.jeecg.modules.flowable.domain.vo.FlowTaskVo;
|
import org.jeecg.modules.flowable.service.IFlowDefinitionService;
|
import org.jeecg.modules.flowable.service.IFlowTaskService;
|
import org.jeecg.modules.mdc.entity.MdcEquipment;
|
import org.jeecg.modules.mdc.service.IMdcEquipmentService;
|
import org.jeecg.modules.message.enums.DeployEnum;
|
import org.jeecg.modules.system.service.IMdcProductionService;
|
import org.springframework.beans.BeanUtils;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.beans.factory.annotation.Value;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
|
import javax.annotation.Resource;
|
import java.io.IOException;
|
import java.util.Date;
|
import java.util.HashMap;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.stream.Collectors;
|
|
@Service("IAssignFileStreamService")
|
public class AssignFileStreamServiceImpl extends ServiceImpl<AssignFileStreamMapper, AssignFileStream> implements IAssignFileStreamService , FlowCallBackServiceI {
|
private static final String PROCESS_KEY = "assign_nc_to_device";
|
private static final String APPLY_VARIABLE = "apply_user";
|
private static final String APPROVE_VARIABLE = "approve_users";
|
private static final String SEND_CODE = "SEND";
|
|
@Value("${flowable.enable}")
|
private Boolean flowableEnable;
|
|
@Autowired
|
private IDocInfoService docInfoService;
|
@Autowired
|
private IProcessStreamService processStreamService;
|
@Autowired
|
private IDocClassificationService classificationService;
|
@Autowired
|
private IToEquipmentTaskService equipmentTaskService;
|
@Autowired
|
private IDeviceInfoService deviceInfoService;
|
@Autowired
|
private IDocFileService docFileService;
|
@Autowired
|
private IDocRelativeService docRelativeService;
|
@Autowired
|
private ISynchronizedFlagService synchronizedFlagService;
|
@Autowired
|
private IDeviceCharactersService iDeviceCharactersService;
|
@Autowired
|
private IMdcEquipmentService iMdcEquipmentService;
|
@Autowired
|
private IMdcProductionService iMdcProductionService;
|
@Autowired
|
private TaskService taskService;
|
@Resource
|
private FlowCommonService flowCommonService;
|
@Resource
|
private IFlowDefinitionService flowDefinitionService;
|
@Autowired
|
private IFlowTaskService flowTaskService;
|
@Autowired
|
private IFlowMyBusinessService flowMyBusinessService;
|
@Autowired
|
private PermissionService permissionService;
|
@Autowired
|
private IDncPassLogService dncPassLogService;
|
@Value("${deploy.deployType}")
|
//工控网/涉密网部署 0为工控网 1为涉密网
|
private String deployType;
|
@Value("${deploy.secretFolder}")
|
//涉密网传输nc文件夹
|
private String secretFolder;
|
|
@Override
|
@Transactional(rollbackFor = {Exception.class})
|
public Result applyAssignFile(AssignFileStream stream) {
|
synchronized (this){
|
//判断设备特殊字符
|
String specialChar = getDeviceSpecialChar(stream.getDeviceId(),stream.getFileId());
|
if (StrUtil.isNotEmpty(specialChar)){
|
//抛出特殊字符异常
|
return Result.error("文件名称存在设备特殊字符");
|
}
|
if(flowableEnable) {
|
return applyAssignFileActive(stream);
|
}else {
|
return applyAssignFileNonActive(stream);
|
}
|
}
|
}
|
|
/**
|
* 判断设备特殊字符
|
* @param deviceId,fileId
|
* 设备ID，文件ID
|
*/
|
public String getDeviceSpecialChar(String deviceId, String fileId){
|
//替换为mdc设备表
|
// DeviceInfo deviceInfo = deviceInfoService.getById(deviceId);
|
MdcEquipment mdcEquipment = iMdcEquipmentService.getById(deviceId);
|
if(mdcEquipment == null)
|
ExceptionCast.cast(ActivitiCode.ACT_ASSIGN_DEVICE_NONE);
|
// DocFile docFile = docFileService.getById(fileId);
|
DocInfo docInfo = docInfoService.getOne(new QueryWrapper<DocInfo>().eq("publish_file_id",fileId));
|
if(docInfo == null)
|
ExceptionCast.cast(ActivitiCode.ACT_FILE_ERROR);
|
List<DeviceCharacters> deviceCharactersList=iDeviceCharactersService.list(
|
new LambdaQueryWrapper<DeviceCharacters>().eq(DeviceCharacters::getDeviceNo,mdcEquipment.getEquipmentId()));
|
if (deviceCharactersList.isEmpty()){
|
return "";
|
}else {
|
List<String> specialCharList=deviceCharactersList.stream().map(DeviceCharacters::getCharacters).collect(Collectors.toList());
|
if(!specialCharList.isEmpty()){
|
//对比文件名是否包含特殊字符
|
String fileName=docInfo.getDocName();
|
for(String specialChar:specialCharList){
|
if (fileName.contains(specialChar)){
|
return specialChar;
|
}
|
}
|
}else {
|
return "";
|
}
|
}
|
return "";
|
}
|
|
private ResponseResult createSpecialCharErrorResponse(String specialChar) {
|
return new ResponseResult(new ResultCode() {
|
@Override
|
public boolean success() {
|
return false;
|
}
|
@Override
|
public int code() {
|
return 88881;
|
}
|
@Override
|
public String message() {
|
return "文件名称存在设备特殊字符" + specialChar;
|
}
|
});
|
}
|
|
@Override
|
@Transactional(rollbackFor = {Exception.class})
|
public Result<?> applyAssignFileActive(AssignFileStream stream) {
|
validateParams(stream);
|
DocInfo docInfo = getDocInfo(stream);
|
MdcEquipment mdcEquipment = getMdcEquipment(stream);
|
DocFile docFile = docFileService.getById(stream.getFileId());
|
DocInfo deviceDoc = docInfoService.getByDocAttrAndDocId(stream.getDocId(), 7, stream.getDeviceId());
|
if (deviceDoc != null) {
|
handleExistingDeviceDoc(docFile, mdcEquipment, stream.getDeviceId());
|
}
|
deviceDoc = docInfoService.findByAttrAndDocName(docInfo.getDocName(), 7, stream.getDeviceId());
|
if (deviceDoc != null) {
|
handleExistingDeviceDoc(docFile, mdcEquipment, stream.getDeviceId());
|
}
|
PermissionStreamNew permissionStreams = getPermissionStreams(stream);
|
if (permissionStreams==null){
|
return Result.error("用户没有权限");
|
}
|
LoginUser user = (LoginUser) SecurityUtils.getSubject().getPrincipal();
|
String userId = user.getId();
|
saveBusinessObject(stream, userId);
|
System.out.println("指派NC文档到设备流程：" + stream.getDocId());
|
flowCommonService.initActBusiness("指派NC文档到设备流程：" +docInfo.getDocName()+"."+docInfo.getDocSuffix()+"到设备->"+mdcEquipment.getEquipmentName() ,
|
stream.getStreamId(), "IAssignFileStreamService", "assign_nc_to_device", null);
|
Map<String, Object> variables = new HashMap<>();
|
variables.put("dataId", stream.getStreamId());
|
if (stream.getApplyReason() != null) {
|
variables.put("organization", stream.getApplyReason());
|
}else {
|
variables.put("organization", "");
|
}
|
Result result= flowDefinitionService.startProcessInstanceByKey("assign_nc_to_device", variables);
|
if (result.isSuccess()){
|
return Result.OK("操作成功");
|
}else {
|
super.removeById(stream.getStreamId());
|
|
return Result.error("操作失败");
|
}
|
}
|
|
@Override
|
@Transactional(rollbackFor = {Exception.class})
|
public Result<?> applyAssignFileNonActive(AssignFileStream stream) {
|
//权限校验
|
validateParams(stream);
|
DocInfo docInfo = getDocInfo(stream);
|
MdcEquipment mdcEquipment = getMdcEquipment(stream);
|
DocFile docFile = getDocFile(stream);
|
DocInfo deviceDoc = docInfoService.getByDocAttrAndDocId(stream.getDocId(), 7, stream.getDeviceId());
|
if(deviceDoc != null) {
|
// 删除 备份 覆盖 原有的
|
List<String> strings=iMdcProductionService.findListParentTreeAll(mdcEquipment.getId());
|
if (strings != null && !strings.isEmpty()) {
|
String path = StringUtils.join(strings.toArray(), "/");
|
boolean copyFileNc = FileUtilS.copyFileNcToBak(path + "/"+ mdcEquipment.getEquipmentId(),
|
docFile.getFileName(), docFile.getFileSuffix());
|
}
|
}
|
getPermissionStreams(stream);
|
//插入文档到设备发送文档
|
if(deviceDoc == null) {
|
DocClassification classification = classificationService.getByCode(SEND_CODE);
|
if(classification == null)
|
ExceptionCast.cast(DocumentCode.DOC_CLASS_ERROR);
|
DocRelative docRelative = new DocRelative();
|
docRelative.setDocId(docInfo.getDocId());
|
docRelative.setClassificationId(classification.getClassificationId());
|
docRelative.setAttributionType(7);
|
docRelative.setAttributionId(stream.getDeviceId());
|
boolean b = docRelativeService.save(docRelative);
|
if(!b) {
|
ExceptionCast.cast(ActivitiCode.ACT_APPROVE_ERROR);
|
}
|
|
}
|
handleFileTransfer(mdcEquipment, docFile);
|
//注意----区分工控网与涉密网！！！ 涉密网进行NC文件的拷贝，工控网负责进行解析NC文件
|
if (deployType.equals(DeployEnum.SMW.getCode())) {
|
handleFileProcessing(docFile, mdcEquipment, secretFolder);
|
}
|
synchronizedFlagService.updateFlag(2);
|
return Result.OK("操作成功");
|
}
|
|
@Override
|
public AssignFileStreamExt getAssignFileStreamDetail(String streamId) {
|
if(!ValidateUtil.validateString(streamId))
|
return null;
|
return super.getBaseMapper().getAssignFileStreamDetail(streamId);
|
}
|
|
@Override
|
@Transactional(rollbackFor = {Exception.class})
|
public boolean approveAssignFile(AssignFlowTaskVo assignFlowTaskVo) {
|
if(!ValidateUtil.validateString(assignFlowTaskVo.getTaskId()) || !ValidateUtil.validateString(assignFlowTaskVo.getDataId()) || assignFlowTaskVo == null)
|
ExceptionCast.cast(CommonCode.INVALID_PARAM);
|
LoginUser user = (LoginUser) SecurityUtils.getSubject().getPrincipal();
|
String userId = user.getId();
|
if(!ValidateUtil.validateString(userId))
|
ExceptionCast.cast(UcenterCode.UCENTER_ACCOUNT_NOT_EXIST);
|
if(!ValidateUtil.validateInteger(assignFlowTaskVo.getStatus()))
|
ExceptionCast.cast(ActivitiCode.ACT_STATUS_ERROR);
|
AssignFileStream en = super.getById(assignFlowTaskVo.getDataId());
|
if(en == null)
|
ExceptionCast.cast(ActivitiCode.ACT_BUSINESS_DETAIL_ERROR);
|
//flowable处理
|
FlowTaskVo flowTaskVo = new FlowTaskVo();
|
BeanUtils.copyProperties(assignFlowTaskVo, flowTaskVo);
|
|
List<FlowMyBusiness> businessList = flowMyBusinessService.list(
|
new QueryWrapper<FlowMyBusiness>()
|
.eq("process_instance_id", assignFlowTaskVo.getInstanceId())
|
);
|
if (businessList.isEmpty()) {
|
return false;
|
}
|
FlowMyBusiness flowMyBusiness = businessList.get(0);
|
List<String> todoUsers = JSON.parseArray(flowMyBusiness.getTodoUsers(), String.class);
|
if (todoUsers == null || !todoUsers.contains(user.getUsername())) {
|
return false;
|
}
|
|
// 4. 认领任务（处理已被认领的情况）
|
String taskId = flowMyBusiness.getTaskId();
|
Task task = taskService.createTaskQuery().taskId(taskId).singleResult();
|
if (task == null) {
|
return false;
|
}
|
if (task.getAssignee() != null && !task.getAssignee().equals(user.getUsername())) {
|
return false;
|
}
|
taskService.claim(taskId, user.getUsername());
|
Map<String, Object> values=new HashMap<>();
|
values.put("dataId", assignFlowTaskVo.getDataId());
|
flowTaskVo.setTaskId(assignFlowTaskVo.getTaskId());
|
flowTaskVo.setValues(values);
|
flowTaskService.complete(flowTaskVo);
|
//更新对象封装
|
AssignFileStream up = new AssignFileStream();
|
up.setApproveContent(assignFlowTaskVo.getApproveContent());
|
up.setStatus(assignFlowTaskVo.getStatus());
|
up.setApproveUserId(userId);
|
up.setApproveTime(DateUtil.getNow());
|
up.setStreamId(assignFlowTaskVo.getDataId());
|
boolean b = super.updateById(up);
|
if(!b)
|
ExceptionCast.cast(ActivitiCode.ACT_APPROVE_ERROR);
|
if(up.getStatus() == 2) {
|
//同意操作
|
DocInfo docInfo = docInfoService.getByDocAttrAndDocId(en.getDocId(), Integer.valueOf(en.getAttributionType()), en.getAttributionId());
|
if(docInfo == null )
|
ExceptionCast.cast(ActivitiCode.ACT_DOC_ERROR);
|
MdcEquipment mdcEquipment = iMdcEquipmentService.getById(en.getDeviceId());
|
if(mdcEquipment == null)
|
ExceptionCast.cast(ActivitiCode.ACT_ASSIGN_DEVICE_NONE);
|
DocFile docFile = docFileService.getById(en.getFileId());
|
if(docFile == null)
|
ExceptionCast.cast(ActivitiCode.ACT_FILE_ERROR);
|
DocInfo deviceDoc = docInfoService.getByDocAttrAndDocId(en.getDocId(),7, en.getDeviceId());
|
if(deviceDoc != null) {
|
// 删除 备份 覆盖 原有的
|
List<String> strings = iMdcProductionService.findListParentTreeAll(mdcEquipment.getId());
|
if (strings != null && !strings.isEmpty()) {
|
String path = StringUtils.join(strings.toArray(), "/");
|
boolean copyFileNc = FileUtilS.copyFileNcToBak(path + "/"+ mdcEquipment.getEquipmentId(),
|
docFile.getFileName(), docFile.getFileSuffix());
|
/* //docInfoService.getBaseMapper().deleteById(deviceDoc.getDocId());
|
boolean doc = docRelativeService.deleteCopyDocByAttrNext(deviceDoc.getDocId(),7,stream.getDeviceId());
|
if (!doc) {
|
ExceptionCast.cast(ActivitiCode.ACT_DOC_ERROR_DELEVE);
|
}*/
|
}
|
} else {
|
//插入文档到设备发送文档
|
DocClassification classification = classificationService.getByCode(SEND_CODE);
|
if(classification == null)
|
ExceptionCast.cast(DocumentCode.DOC_CLASS_ERROR);
|
|
DocRelative docRelative = new DocRelative();
|
docRelative.setDocId(docInfo.getDocId());
|
docRelative.setClassificationId(classification.getClassificationId());
|
docRelative.setAttributionType(7);
|
docRelative.setAttributionId(en.getDeviceId());
|
b = docRelativeService.save(docRelative);
|
}
|
if(!b)
|
ExceptionCast.cast(ActivitiCode.ACT_APPROVE_ERROR);
|
if (mdcEquipment != null) {
|
List<String> strings = iMdcProductionService.findListParentTreeAll(mdcEquipment.getId());
|
if (strings != null && !strings.isEmpty()) {
|
String path = StringUtils.join(strings.toArray(), "/");
|
boolean copyFileNc = FileUtilS.copyFileNc(docFile.getFilePath(),path + "/"+ mdcEquipment.getEquipmentId(),
|
docFile.getFileEncodeName(),
|
docFile.getFileName(),docFile.getFileSuffix());
|
if (!copyFileNc) {
|
ExceptionCast.cast(ActivitiCode.ACT_FILE_ERROR);
|
} else {
|
FileUtilS.deleteZipFromToSend(path + "/"+ mdcEquipment.getEquipmentId(),
|
docFile.getFileName(),docFile.getFileSuffix());
|
}
|
}
|
}
|
//注意----区分工控网与涉密网！！！ 涉密网进行NC文件的拷贝，工控网负责进行解析NC文件
|
if (deployType.equals(DeployEnum.SMW.getCode())) {
|
handleFileProcessing(docFile, mdcEquipment, secretFolder);
|
}
|
return synchronizedFlagService.updateFlag(1);
|
}else if(up.getStatus() == 3) {
|
//拒绝操作 什么也不做
|
return true;
|
}else {
|
ExceptionCast.cast(ActivitiCode.ACT_APPROVE_ERROR);
|
}
|
return false;
|
}
|
|
@Override
|
@Transactional(rollbackFor = {Exception.class})
|
public boolean applyBatchAssignFile(AssignFileRequest assignFileRequest) {
|
if(assignFileRequest == null)
|
ExceptionCast.cast(CommonCode.INVALID_PARAM);
|
String[] deviceIds = assignFileRequest.getDeviceIds();
|
if(deviceIds == null || deviceIds.length < 1)
|
ExceptionCast.cast(ActivitiCode.ACT_ASSIGN_DEVICE_NONE);
|
AssignFileStream stream;
|
for(String id : deviceIds) {
|
stream = new AssignFileStream();
|
stream.setProcessId(assignFileRequest.getProcessId());
|
stream.setStepId(assignFileRequest.getStepId());
|
stream.setDocId(assignFileRequest.getDocId());
|
stream.setFileId(assignFileRequest.getFileId());
|
stream.setApplyReason(assignFileRequest.getApplyReason());
|
stream.setDeviceId(id);
|
Result b = applyAssignFile(stream);
|
if(!b.isSuccess())
|
ExceptionCast.cast(ActivitiCode.ACT_APPLY_ERROR);
|
}
|
return true;
|
}
|
|
@Override
|
@Transactional(rollbackFor = {Exception.class})
|
public boolean approveBatchAssignFile(ApproveBatchRequest approveBatchRequest) {
|
if(approveBatchRequest == null)
|
ExceptionCast.cast(CommonCode.INVALID_PARAM);
|
List<TaskRequest> list = approveBatchRequest.getTaskArr();
|
if(list == null || list.isEmpty())
|
ExceptionCast.cast(CommonCode.INVALID_PARAM);
|
return synchronizedFlagService.updateFlag(1);
|
}
|
|
@Override
|
public Result<?> findPageList(int page, int size, AssignFileStreamQueryRequest request) {
|
if(page < 1 || size < 1) {
|
ExceptionCast.cast(CommonCode.INVALID_PAGE);
|
}
|
LoginUser user = (LoginUser) SecurityUtils.getSubject().getPrincipal();
|
String userId = user.getId();
|
if(!ValidateUtil.validateString(userId))
|
ExceptionCast.cast(UcenterCode.UCENTER_ACCOUNT_NOT_EXIST);
|
LambdaQueryWrapper<AssignFileStreamExt> lambdaQueryWrapper = Wrappers.lambdaQuery();
|
lambdaQueryWrapper.eq(AssignFileStreamExt::getApproveUserId, userId);
|
lambdaQueryWrapper.orderByDesc(AssignFileStreamExt::getApproveTime);
|
IPage<AssignFileStreamExt> pageData = new Page<>(page, size);
|
if(request != null) {
|
if(ValidateUtil.validateString(request.getAscStr())) {
|
String[] ascArr = request.getAscStr().split(",");
|
// ((Page<AssignFileStreamExt>) pageData).setAsc(ascArr);
|
}
|
if(ValidateUtil.validateString(request.getDescStr())) {
|
String[] descStr = request.getDescStr().split(",");
|
// ((Page<AssignFileStreamExt>) pageData).setDesc(descStr);
|
}
|
}
|
IPage<AssignFileStreamExt> streamExtIPage = super.getBaseMapper().findByPage(pageData, lambdaQueryWrapper);
|
return Result.ok(streamExtIPage);
|
}
|
|
@Override
|
public QueryPageResponseResult<AssignFileStreamExt> findPageListByDocId(int page, int size, String docId) {
|
if(page < 1 || size < 1) {
|
ExceptionCast.cast(CommonCode.INVALID_PAGE);
|
}
|
if(!ValidateUtil.validateString(docId))
|
ExceptionCast.cast(ActivitiCode.ACT_DOC_ID_NONE);
|
QueryWrapper<AssignFileStreamExt> queryWrapper = Wrappers.query();
|
queryWrapper.eq("a.doc_id", docId);
|
queryWrapper.orderByDesc("approve_time");
|
IPage<AssignFileStreamExt> pageData = new Page<>(page, size);
|
IPage<AssignFileStreamExt> streamExtIPage = super.getBaseMapper().findByPage(pageData, queryWrapper);
|
return new QueryPageResponseResult<>(CommonCode.SUCCESS, streamExtIPage);
|
}
|
|
@Override
|
public Boolean getFlowableEnable(){
|
if(flowableEnable != null) {
|
return flowableEnable;
|
}
|
return false;
|
}
|
|
@Override
|
@Transactional(rollbackFor = {Exception.class})
|
public boolean transferDocFile(String pnCode, String deviceNo) {
|
List<ProcessStream> streams = processStreamService.validateDeviceProcessInfo(pnCode, deviceNo);
|
DeviceInfo deviceInfo = deviceInfoService.getByDeviceNo(deviceNo);
|
if(deviceInfo == null)
|
ExceptionCast.cast(DeviceCode.DEVICE_NOT_EXIST);
|
//删除原来设备下的所有文档
|
docRelativeService.deleteByDocAttr(7, deviceInfo.getDeviceId());
|
List<DocInfo> docInfoList = docInfoService.getByProcessIds(streams);
|
if(docInfoList == null || docInfoList.isEmpty())
|
ExceptionCast.cast(DocumentCode.DOC_NOT_EXIST);
|
LoginUser user = (LoginUser) SecurityUtils.getSubject().getPrincipal();
|
String userId = user.getId();
|
if(!ValidateUtil.validateString(userId))
|
ExceptionCast.cast(UcenterCode.UCENTER_ACCOUNT_NOT_EXIST);
|
for(DocInfo docInfo : docInfoList) {
|
DocFile docFile = docFileService.getById(docInfo.getPublishFileId());
|
if(docFile == null)
|
ExceptionCast.cast(ActivitiCode.ACT_FILE_ERROR);
|
//插入文档到设备发送文档
|
DocClassification classification = classificationService.getByCode(SEND_CODE);
|
if(classification == null)
|
ExceptionCast.cast(DocumentCode.DOC_CLASS_ERROR);
|
DocRelative docRelative = new DocRelative();
|
docRelative.setDocId(docInfo.getDocId());
|
docRelative.setClassificationId(classification.getClassificationId());
|
docRelative.setAttributionType(7);
|
docRelative.setAttributionId(deviceInfo.getDeviceId());
|
boolean b = docRelativeService.save(docRelative);
|
if(!b)
|
ExceptionCast.cast(ActivitiCode.ACT_APPROVE_ERROR);
|
//插入文件传输任务表
|
ToEquipmentTask equipmentTask = new ToEquipmentTask();
|
//不能直接从doc中拿fileId 和version 可能会存在斌更
|
//equipmentTask.setFileId(docInfo.getPublishFileId());
|
//equipmentTask.setDocVersion(docInfo.getPublishVersion());
|
equipmentTask.setDocId(docInfo.getDocId());
|
equipmentTask.setSyncFlag(1);
|
equipmentTask.setDeviceNo(deviceInfo.getDeviceNo());
|
equipmentTask.setDeviceId(deviceInfo.getDeviceId());
|
equipmentTask.setDepartId(deviceInfo.getDepartId());
|
//文件相关信息
|
equipmentTask.setFileId(docFile.getFileId());
|
equipmentTask.setDocVersion(docFile.getDocVersion());
|
equipmentTask.setFileName(docInfo.getDocName());
|
equipmentTask.setFileEncodeName(docFile.getFileEncodeName());
|
equipmentTask.setFilePath(docFile.getFilePath());
|
equipmentTask.setFileSuffix(docFile.getFileSuffix());
|
equipmentTask.setFileSize(docFile.getFileSize());
|
b = equipmentTaskService.save(equipmentTask);
|
if(!b) {
|
ExceptionCast.cast(ActivitiCode.ACT_APPROVE_ERROR);
|
}
|
}
|
return synchronizedFlagService.updateFlag(1);
|
}
|
|
//传参验证
|
private void validateParams(AssignFileStream stream) {
|
if (stream == null) {
|
ExceptionCast.cast(CommonCode.INVALID_PARAM);
|
}
|
if (!ValidateUtil.validateString(stream.getAttributionId()) || !ValidateUtil.validateString(stream.getDocId())
|
|| !ValidateUtil.validateString(stream.getFileId()) || !ValidateUtil.validateString(stream.getAttributionType())) {
|
ExceptionCast.cast(CommonCode.INVALID_PARAM);
|
}
|
if (!ValidateUtil.validateString(stream.getDeviceId())) {
|
ExceptionCast.cast(ActivitiCode.ACT_ASSIGN_DEVICE_NONE);
|
}
|
LoginUser user = (LoginUser) SecurityUtils.getSubject().getPrincipal();
|
String userId = user.getId();
|
if (!ValidateUtil.validateString(userId)) {
|
ExceptionCast.cast(UcenterCode.UCENTER_ACCOUNT_NOT_EXIST);
|
}
|
}
|
|
//获取文件信息
|
private DocInfo getDocInfo(AssignFileStream stream) {
|
DocInfo docInfo = docInfoService.getByDocAttrAndDocId(stream.getDocId(), Integer.parseInt(stream.getAttributionType()), stream.getAttributionId());
|
if (docInfo == null || docInfo.getDocStatus() == 3) {
|
ExceptionCast.cast(ActivitiCode.ACT_DOC_ERROR);
|
}
|
return docInfo;
|
}
|
|
//获取文件
|
private void handleExistingDeviceDoc(DocFile docFile, MdcEquipment mdcEquipment, String deviceId) {
|
List<String> strings = iMdcProductionService.findListParentTreeAll(mdcEquipment.getEquipmentId());
|
if (strings != null && !strings.isEmpty()) {
|
String path = StringUtils.join(strings.toArray(), "/");
|
boolean copyFileNc = FileUtilS.copyFileNcToBak(path + "/" + mdcEquipment.getEquipmentId(),
|
docFile.getFileName(), docFile.getFileSuffix());
|
if (!copyFileNc) {
|
ExceptionCast.cast(ActivitiCode.ACT_FILE_ERROR);
|
} else {
|
DocInfo deviceDoc = docInfoService.getByDocAttrAndDocId(deviceId, 7, deviceId);
|
boolean doc = docRelativeService.deleteDocByAttr(deviceDoc.getDocId(), 7, deviceId);
|
if (!doc) {
|
ExceptionCast.cast(ActivitiCode.ACT_DOC_ERROR_DELEVE);
|
}
|
}
|
}
|
}
|
|
private PermissionStreamNew getPermissionStreams(AssignFileStream stream) {
|
PermissionStreamNew permissionStreamNew = permissionService.getPermissionStreams(stream);
|
if (permissionStreamNew == null) {
|
ExceptionCast.cast(ActivitiCode.ACT_NODE_DEPART_NONE);
|
}
|
return permissionStreamNew ;
|
}
|
|
//封装数据
|
private void saveBusinessObject(AssignFileStream stream, String userId) {
|
String streamId = IdWorker.getIdStr();
|
stream.setStreamId(streamId);
|
stream.setApplyUserId(userId);
|
stream.setApplyTime(DateUtil.getNow());
|
stream.setStatus(1);
|
boolean b = super.save(stream);
|
if (!b) {
|
ExceptionCast.cast(ActivitiCode.ACT_BUSINESS_SAVE_ERROR);
|
}
|
}
|
|
//拾取任务
|
private void completeTask(ProcessInstance processInstance, String userId) {
|
Task task = taskService.createTaskQuery().processDefinitionKey(PROCESS_KEY).taskAssignee(userId)
|
.processInstanceId(processInstance.getId()).singleResult();
|
if (task == null) {
|
ExceptionCast.cast(ActivitiCode.ACT_APPROVE_USERS_NONE);
|
}
|
taskService.complete(task.getId());
|
}
|
|
//获取设备
|
private MdcEquipment getMdcEquipment(AssignFileStream stream) {
|
MdcEquipment mdcEquipment = iMdcEquipmentService.getById(stream.getDeviceId());
|
if (mdcEquipment == null) {
|
ExceptionCast.cast(ActivitiCode.ACT_ASSIGN_DEVICE_NONE);
|
}
|
return mdcEquipment;
|
}
|
|
//获取文件
|
private DocFile getDocFile(AssignFileStream stream) {
|
DocFile docFile = docFileService.getById(stream.getFileId());
|
if (docFile == null) {
|
ExceptionCast.cast(ActivitiCode.ACT_FILE_ERROR);
|
}
|
return docFile;
|
}
|
|
//插入文件传输任务表
|
private void handleFileTransfer(MdcEquipment mdcEquipment, DocFile docFile) {
|
List<String> strings = iMdcProductionService.findListParentTreeAll(mdcEquipment.getId());
|
if (strings != null && !strings.isEmpty()) {
|
String path = StringUtils.join(strings.toArray(), "/");
|
boolean copyFileNc = FileUtilS.copyFileNc(docFile.getFilePath(), path + "/" + mdcEquipment.getEquipmentId(),
|
docFile.getFileEncodeName(),
|
docFile.getFileName(), docFile.getFileSuffix());
|
if (!copyFileNc) {
|
ExceptionCast.cast(ActivitiCode.ACT_FILE_ERROR);
|
} else {
|
FileUtilS.deleteZipFromToSend(path + "/" + mdcEquipment.getEquipmentId(),
|
docFile.getFileName(), docFile.getFileSuffix());
|
}
|
} else {
|
throw new RuntimeException("文件传输路径获取失败");
|
}
|
}
|
|
//封装处理文件
|
private void handleFileProcessing(DocFile docFile, MdcEquipment mdcEquipment, String secretFolder) {
|
if (!docFile.getFileSuffix().equals("zip") && !docFile.getFileSuffix().equals("rar")) {
|
String size = FileUtilS.fileSizeNC(docFile.getFilePath(), docFile.getFileEncodeName());
|
List<String> strings = iMdcProductionService.findListParentTreeAll(mdcEquipment.getId());
|
if (strings != null && !strings.isEmpty()) {
|
DncPassLog passInfoTxt = new DncPassLog();
|
|
String path = StringUtils.join(strings.toArray(), "/");
|
Date dateFirst = DateUtil.getNow();
|
passInfoTxt.setDayTime(DateUtil.format(dateFirst,DateUtil.STR_YEARMONTHDAY));
|
/*查询最后一条记录*/
|
//休眠 500毫秒
|
DncPassLog dncPassLog = dncPassLogService.findDayTime(DateUtil.format(dateFirst,DateUtil.STR_YEARMONTHDAY));
|
int fileTxt = 0, fileNc =0;
|
if (dncPassLog !=null) {
|
fileTxt = dncPassLog.getSequenceNumber() + 1;
|
} else {
|
fileTxt = 1;
|
}
|
fileNc = fileTxt + 1;
|
//处理文件名称 文件路径
|
String sequence = String.format("%06d",fileTxt);
|
String sequenceNc = String.format("%06d",fileNc);
|
passInfoTxt.setSequenceNumber(fileTxt);
|
passInfoTxt.setSequenceOrder(sequence);
|
passInfoTxt.setCreateTime(dateFirst);
|
System.out.println(DateUtil.format(dateFirst,DateUtil.STR_DATE_TIME));
|
passInfoTxt.setPassType("02");
|
dncPassLogService.save(passInfoTxt);
|
|
DncPassLog passInfoNc = new DncPassLog();
|
passInfoNc.setSequenceNumber(fileNc);
|
passInfoNc.setSequenceOrder(sequenceNc);
|
passInfoNc.setDayTime(DateUtil.format(dateFirst,DateUtil.STR_YEARMONTHDAY));
|
passInfoNc.setPassType("02");
|
passInfoNc.setPassName(docFile.getFileName());
|
try {
|
Thread.sleep(1000);
|
Date date = new Date();
|
passInfoNc.setCreateTime(date);
|
System.out.println(DateUtil.format(date,DateUtil.STR_DATE_TIME));
|
} catch (InterruptedException e) {
|
e.printStackTrace();
|
}
|
|
dncPassLogService.save(passInfoNc);
|
NcTxtFilePathInfo ncTxt = new NcTxtFilePathInfo();
|
ncTxt.setEquipmentId(mdcEquipment.getEquipmentId());
|
ncTxt.setFileNcName("10A"+DateUtil.format(dateFirst,DateUtil.STR_YEARMONTHDAY)+sequenceNc);
|
ncTxt.setFileTxtName("10A"+DateUtil.format(dateFirst,DateUtil.STR_YEARMONTHDAY)+sequence);
|
ncTxt.setFilePath(path + "/" + mdcEquipment.getEquipmentId() + "/");
|
ncTxt.setOrigFileName(docFile.getFileName());
|
ncTxt.setOrigFileSuffix(docFile.getFileSuffix());
|
ncTxt.setFileAddOrDelete(1);
|
String loFilePath = secretFolder +"/"+ ncTxt.getFileTxtName() + ".nc";
|
try {
|
String allList = ncTxt.getFileTxtName() + "\n"
|
+ ncTxt.getFileNcName() + "\n"
|
+ ncTxt.getOrigFileName() + "\n"
|
+ ncTxt.getOrigFileSuffix() + "\n"
|
+ ncTxt.getFilePath() + "\n"
|
+ ncTxt.getEquipmentId() + "\n"
|
+ ncTxt.getFileAddOrDelete().toString() + "\n"
|
+ size + "\n";
|
FileUtilS.fileWriterSql(loFilePath, allList);
|
boolean copyFileNc = FileUtilS.copyFileUpName(path + "/" + mdcEquipment.getEquipmentId() + "/send/" +
|
docFile.getFileName(),
|
secretFolder +"/"+ncTxt.getFileNcName(),
|
docFile.getFileSuffix(), "NC");
|
if (!copyFileNc) {
|
FileUtilS.deleteNcFile(loFilePath);
|
}
|
} catch (IOException e) {
|
throw new RuntimeException("文件处理失败", e);
|
}
|
}
|
}
|
}
|
|
@Override
|
public void afterFlowHandle(FlowMyBusiness business) {
|
business.getTaskNameId();//接下来审批的节点
|
business.getValues();//前端传进来的参数
|
business.getActStatus();
|
}
|
|
@Override
|
public Object getBusinessDataById(String dataId) {
|
return this.getById(dataId);
|
}
|
|
@Override
|
public Map<String, Object> flowValuesOfTask(String taskNameId, Map<String, Object> values) {
|
return null;
|
}
|
|
@Override
|
public List<String> flowCandidateUsernamesOfTask(String taskNameId, Map<String, Object> values) {
|
return null;
|
}
|
}
|
