package com.ld.igds.inout.manager;
|
|
import com.ld.igds.check.CheckStandardManager;
|
import com.ld.igds.check.dto.CheckItemData;
|
import com.ld.igds.check.dto.CheckUpdateResult;
|
import com.ld.igds.constant.RespCodeEnum;
|
import com.ld.igds.data.Page;
|
import com.ld.igds.data.PageResponse;
|
import com.ld.igds.file.CoreFileService;
|
import com.ld.igds.file.dto.FileData;
|
import com.ld.igds.inout.InoutConstant;
|
import com.ld.igds.inout.dto.InoutCheckData;
|
import com.ld.igds.inout.dto.InoutCheckParam;
|
import com.ld.igds.inout.dto.InoutData;
|
import com.ld.igds.inout.dto.InoutParam;
|
import com.ld.igds.inout.service.InoutService;
|
import com.ld.igds.m.service.InoutCommonService;
|
import com.ld.igds.models.InoutConf;
|
import com.ld.igds.models.InoutPrice;
|
import com.ld.igds.models.InoutSysConf;
|
import com.ld.igds.util.ContextUtil;
|
import com.ld.igds.util.DateUtil;
|
import org.apache.commons.lang3.StringUtils;
|
import org.apache.commons.lang3.time.DateFormatUtils;
|
import org.apache.commons.lang3.time.DateUtils;
|
import org.springframework.stereotype.Component;
|
import org.springframework.transaction.annotation.Transactional;
|
|
import javax.annotation.Resource;
|
import java.util.Arrays;
|
import java.util.Date;
|
import java.util.List;
|
|
/**
|
* 出入库相关业务1
|
*
|
* @author
|
*/
|
@Component
|
public class InoutManager {
|
|
@Resource
|
private InoutService inoutService;
|
@Resource
|
private CoreFileService fileService;
|
@Resource
|
private InoutCommonService inoutCommonService;
|
@Resource
|
private CheckStandardManager checkStandardManager;
|
@Resource
|
private InoutEventControlManager inoutEventControl;
|
@Resource
|
private CoreFileService coreFileService;
|
|
/**
|
* 直接从数据库查询，不考虑信息状态
|
*
|
* @param param
|
* @return
|
*/
|
public PageResponse<InoutData> inoutQueryBack(InoutParam param) {
|
if (StringUtils.isEmpty(param.getPlateNum())
|
&& StringUtils.isEmpty(param.getIntelCard())
|
&& StringUtils.isEmpty(param.getUserId())) {
|
|
return new PageResponse<>(RespCodeEnum.CODE_1007.getCode(),
|
"查询参数不完整，查询失败！");
|
}
|
|
// 获取三天以内最后一天记录
|
param.setStart(DateUtil.getNewByDay(new Date(), -3));
|
param.setType(null);
|
param.setProgress(null);
|
|
InoutData result = inoutService.getLastRecord(param);
|
|
if (null == result) {
|
return new PageResponse<>(RespCodeEnum.CODE_1007.getCode(),
|
"根据当前条件未查询到车辆信息！");
|
}
|
|
if (InoutConstant.PROGRESS_RECORD.equals(result.getProgress())) {
|
return new PageResponse<>(RespCodeEnum.CODE_2000.getCode(),
|
"当前车辆流程已经结束", result);
|
}
|
|
if (!InoutConstant.PROGRESS_CARD_BACK.equals(result.getProgress())) {
|
return new PageResponse<>(RespCodeEnum.CODE_1008.getCode(),
|
"当前车辆流程不在当前环节，无法执行出库", result);
|
}
|
|
return new PageResponse<>(RespCodeEnum.CODE_0000, result);
|
}
|
|
/**
|
* 首先从缓存中获取，缓存中，从数据库中获取
|
*
|
* @param param
|
* @return
|
*/
|
public PageResponse<InoutData> inoutQuery(InoutParam param) {
|
if (StringUtils.isEmpty(param.getPlateNum())
|
&& StringUtils.isEmpty(param.getIntelCard())
|
&& StringUtils.isEmpty(param.getUserId())) {
|
|
return new PageResponse<>(RespCodeEnum.CODE_1007.getCode(),
|
"查询参数不完整，查询失败！");
|
}
|
|
InoutData result;
|
String progress = param.getProgress();
|
try {
|
param.setProgress(null);
|
result = inoutService.inoutProgressQuery(param);
|
if (null == result) {
|
return new PageResponse<>(RespCodeEnum.CODE_2000.getCode(),
|
"系统为查询到执行中的车辆信息", null);
|
}
|
|
// 如果没有流程条件说明不需要做判断，直接返回
|
if (StringUtils.isEmpty(progress)) {
|
return new PageResponse<>(RespCodeEnum.CODE_0000, result);
|
}
|
|
// 流程类型验证
|
if (!result.getType().equals(param.getType())) {
|
String msg = "流程错误：当前车辆流程为【入库】";
|
if (InoutConstant.TYPE_OUT.equals(result.getType()))
|
msg = "流程错误：当前车辆流程为【出库】";
|
return new PageResponse<>(RespCodeEnum.CODE_2000.getCode(),
|
msg, result);
|
}
|
|
// 流程环节验证
|
if (progress.equals(InoutConstant.PROGRESS_WEIGHT_TAG)) {
|
if (result.getProgress().equals(
|
InoutConstant.PROGRESS_WEIGHT_EMPTY)
|
|| result.getProgress().equals(
|
InoutConstant.PROGRESS_WEIGHT_FULL)) {
|
// 表示当前流程正常
|
} else {
|
return new PageResponse<>(RespCodeEnum.CODE_2000.getCode(),
|
"提示：非当前环节，请到"
|
+ InoutConstant.getProcessName(
|
param.getType(),
|
result.getProgress()), result);
|
}
|
} else {
|
if (!result.getProgress().equals(progress)) {
|
return new PageResponse<>(RespCodeEnum.CODE_2000.getCode(),
|
"提示：非当前环节，请到"
|
+ InoutConstant.getProcessName(
|
param.getType(),
|
result.getProgress()), result);
|
}
|
}
|
|
return new PageResponse<>(RespCodeEnum.CODE_0000, result);
|
|
} catch (Exception e) {
|
return new PageResponse<>(RespCodeEnum.CODE_2000.getCode(),
|
e.getMessage());
|
}
|
}
|
|
|
/**
|
* 化验结果不通过时校验配置信息
|
*
|
* @param data
|
* @return
|
*/
|
private InoutData checkNoPass(InoutData data) {
|
InoutSysConf inoutSysConf = inoutCommonService.getCacheInoutSysConf(
|
data.getCompanyId(), data.getDeptId());
|
|
if (inoutSysConf.getNoPassNext().equals(
|
InoutConstant.CHECK_NOPASS_RECORD)) {
|
// 流程结束
|
data.setProgress(InoutConstant.PROGRESS_RECORD);
|
data.setCompleteTime(new Date());
|
}
|
if (inoutSysConf.getNoPassNext()
|
.equals(InoutConstant.CHECK_NOPASS_BACK)) {
|
// 离库收卡
|
data.setProgress(InoutConstant.PROGRESS_CARD_BACK);
|
}
|
return data;
|
}
|
|
/**
|
* 更新质检信息
|
*
|
* @param data
|
* @return
|
*/
|
private InoutData updateCheckItems(InoutData data, boolean toSave) throws Exception {
|
|
if (null == data.getCheckItems()) return data;
|
|
//设置没有质检ID，取消执行持久化
|
if (!toSave) data.setCheckId(null);
|
|
// 更新检验项数据
|
CheckUpdateResult checkUpdateResult = checkStandardManager.updateCheckItems(data.getCheckId(), data.getCompanyId(), data.getCheckItems());
|
|
if (data.getDeCheck() == 0) {
|
data.setDeCheck(checkUpdateResult.getDeSum());
|
}
|
if (data.getAddCheck() == 0) {
|
data.setAddCheck(checkUpdateResult.getAddSum());
|
}
|
|
return data;
|
}
|
|
/**
|
* 从缓存中获取下一流程
|
*
|
* @return
|
*/
|
private String getNextProgress(String curProgress, String type,
|
InoutSysConf sysConf) {
|
String nextProgress = null;
|
List<String> list = null;
|
if (InoutConstant.TYPE_IN.equals(type)) {
|
list = Arrays.asList(sysConf.getProgressIn().split("-"));
|
}
|
if (InoutConstant.TYPE_OUT.equals(type)) {
|
list = Arrays.asList(sysConf.getProgressOut().split("-"));
|
}
|
if (list != null) {
|
for (int i = 0; i < list.size() - 1; i++) {
|
if (curProgress.equals(list.get(i))) {
|
nextProgress = list.get(i + 1);
|
break;
|
}
|
}
|
}
|
return nextProgress;
|
}
|
|
/**
|
* 根据数据当前状态和下一个状态，更新基础信息
|
*
|
* @param data
|
* @return
|
*/
|
private InoutData updateBasicInfo(InoutData data, String curProgress,
|
String nextProgress) {
|
|
if (InoutConstant.PROGRESS_REGISTER.equals(curProgress)) {
|
data.setRegisterTime(new Date());
|
data.setRegisterUser(ContextUtil.getLoginUserCName());
|
data.setProgress(nextProgress);
|
}
|
|
if (InoutConstant.PROGRESS_CHECK.equals(data.getProgress())) {
|
if (StringUtils.isEmpty(data.getCheckUser())) {
|
data.setCheckUser(ContextUtil.getLoginUserCName());
|
}
|
data.setProgress(nextProgress);
|
return data;
|
}
|
|
if (InoutConstant.PROGRESS_WEIGHT_EMPTY.equals(curProgress)) {
|
data.setEmptyWeightTime(new Date());
|
data.setEmptyWeightUser(ContextUtil.getLoginUserCName());
|
data.setProgress(nextProgress);
|
}
|
|
if (InoutConstant.PROGRESS_WEIGHT_FULL.equals(curProgress)) {
|
data.setFullWeightTime(new Date());
|
data.setFullWeightUser(ContextUtil.getLoginUserCName());
|
data.setProgress(nextProgress);
|
}
|
|
if (InoutConstant.PROGRESS_HANDLE.equals(curProgress)) {
|
if (null == data.getHandleUser()) {
|
data.setHandleUser(ContextUtil.getLoginUserCName());
|
}
|
data.setProgress(nextProgress);
|
}
|
|
// 如果下一个数据状态=流程结束，直接补充完整信息
|
if (InoutConstant.PROGRESS_RECORD.equals(nextProgress)) {
|
data.setCompleteTime(DateUtils.addMinutes(new Date(), 2));
|
data.setCompleteUser(ContextUtil.getLoginUserCName());
|
data.setProgress(nextProgress);
|
}
|
|
return data;
|
}
|
|
/**
|
* 卡回收逻辑处理
|
*
|
* @param data
|
* @return
|
*/
|
public PageResponse<InoutData> submitCardBack(InoutData data) {
|
try {
|
// 如果当前数据已经结束
|
if (InoutConstant.PROGRESS_RECORD.equals(data.getProgress())) {
|
|
// 删除缓存
|
inoutService.delFromCache(data.getDeptId(), data.getType(),
|
data.getId());
|
|
return new PageResponse<>(RespCodeEnum.CODE_0000.getCode(),
|
"当车辆流程已经完成，卡片已回收", data);
|
}
|
|
// 如果当前流程不是卡回收
|
if (!InoutConstant.PROGRESS_CARD_BACK.equals(data.getProgress())) {
|
|
return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(),
|
"当前流程环节不正确，不能执行卡回收", data);
|
}
|
|
// 如果当前流程状态是卡回收状态，就是完成流程。
|
if (InoutConstant.PROGRESS_CARD_BACK.equals(data.getProgress())) {
|
return submitComplete(data);
|
}
|
|
} catch (Exception e) {
|
return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(),
|
"后端执行异常：" + e.getMessage());
|
}
|
|
return new PageResponse<>(RespCodeEnum.CODE_0000.getCode(), "执行成功",
|
data);
|
}
|
|
|
public PageResponse<InoutData> submitComplete(InoutData data)
|
throws Exception {
|
|
if (StringUtils.isEmpty(data.getId())
|
|| StringUtils.isEmpty(data.getType())
|
|| StringUtils.isEmpty(data.getProgress())) {
|
|
return new PageResponse<>(RespCodeEnum.CODE_1007.getCode(),
|
"没有获取到车辆信息。", data);
|
}
|
|
data.setUpdateTime(new Date());
|
if (null == data.getCompleteTime()) {
|
data.setCompleteTime(DateUtil.getNewByMinute(new Date(), 2));
|
}
|
if (null == data.getCompleteUser()) {
|
data.setCompleteUser(ContextUtil.getLoginUserCName());
|
}
|
|
// 设置流程节点直接完成
|
InoutParam param = new InoutParam();
|
param.setCompanyId(data.getCompanyId());
|
param.setId(data.getId());
|
param.setType(data.getType());
|
param.setDeptId(data.getDeptId());
|
param.setIntelCard(data.getIntelCard());
|
param.setUserId(data.getCompleteUser());
|
param.setDepotId(data.getDepotId());
|
param.setCompleteTime(new Date());
|
param.setProgress(InoutConstant.PROGRESS_RECORD);
|
|
String msg = inoutService.toComplete(param);
|
|
if (null != msg) {
|
return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(), msg);
|
}
|
data.setCompleteTime(param.getCompleteTime());
|
data.setProgress(InoutConstant.PROGRESS_RECORD);
|
inoutService.updateInoutCache(data);
|
// 流程完成收事件
|
inoutEventControl.onInoutComplete(data);
|
|
return new PageResponse<>(RespCodeEnum.CODE_0000.getCode(), null, data);
|
}
|
|
/**
|
* 补单操作 补单因为完成时间不确定，所以需要系统根据当前数据进行自动检测，调整原来流水信息和库存
|
*
|
* @param data
|
* @return
|
* @throws Exception
|
*/
|
public String addInoutData(InoutData data) throws Exception {
|
|
if (data.getSettleWeight() <= 0.0) {
|
return "系统：补单数据要求结算重量必须大于0";
|
}
|
|
// 补单数据直接到结果状态
|
data.setRecordStatus(InoutConstant.RECORD_STATUS_ADD);
|
data.setProgress(InoutConstant.PROGRESS_RECORD);
|
if (InoutConstant.STATUS_NONE.equals(data.getCheckStatus())) {
|
data.setCheckStatus(InoutConstant.STATUS_PASS);
|
}
|
|
String loginUser = ContextUtil.getLoginUserCName();
|
if (StringUtils.isEmpty(data.getRegisterUser())) {
|
data.setRegisterUser(loginUser);
|
}
|
if (StringUtils.isEmpty(data.getFullWeightUser())) {
|
data.setFullWeightUser(loginUser);
|
}
|
if (StringUtils.isEmpty(data.getEmptyWeightUser())) {
|
data.setEmptyWeightUser(loginUser);
|
}
|
if (StringUtils.isEmpty(data.getHandleUser())) {
|
data.setHandleUser(loginUser);
|
}
|
if (StringUtils.isEmpty(data.getCompleteUser())) {
|
data.setCompleteUser(loginUser);
|
}
|
|
if (null == data.getCompleteTime()) {
|
data.setCompleteTime(new Date());
|
}
|
// 注册时间比完成时间早一个小时
|
data.setRegisterTime(DateUtils.addMinutes(new Date(), -80));
|
|
if (StringUtils.isEmpty(data.getUserId())) {
|
data.setUserId(InoutConstant.DEFAULT_ID_CARD);
|
}
|
if (null == data.getIntelCard()) {
|
data.setIntelCard(data.getUserId());
|
}
|
if (null != data.getCheckItems() && StringUtils.isEmpty(data.getCheckUser())) {
|
data.setCheckUser(loginUser);
|
}
|
|
|
if (InoutConstant.TYPE_IN.equals(data.getType())) {
|
if (null == data.getFullWeightTime()) {
|
data.setFullWeightTime(DateUtils.addMinutes(new Date(), -50));
|
}
|
if (null == data.getEmptyWeightTime()) {
|
data.setEmptyWeightTime(DateUtils.addMinutes(new Date(), -10));
|
}
|
|
if (data.getCompleteTime().before(data.getEmptyWeightTime())) {
|
data.setEmptyWeightTime(DateUtils.addMinutes(data.getCompleteTime(), -10));
|
}
|
if (data.getEmptyWeightTime().before(data.getFullWeightTime())) {
|
data.setFullWeightTime(DateUtils.addMinutes(data.getEmptyWeightTime(), -40));
|
}
|
if (data.getFullWeightTime().before(data.getRegisterTime())) {
|
data.setRegisterTime(DateUtils.addMinutes(data.getFullWeightTime(), -30));
|
}
|
|
data = this.updateCheckItems(data, false);
|
} else {
|
if (null == data.getEmptyWeightTime()) {
|
data.setEmptyWeightTime(DateUtils.addMinutes(new Date(), -50));
|
}
|
if (null == data.getFullWeightTime()) {
|
data.setFullWeightTime(DateUtils.addMinutes(new Date(), -10));
|
}
|
if (data.getCompleteTime().before(data.getFullWeightTime())) {
|
data.setFullWeightTime(DateUtils.addMinutes(data.getCompleteTime(), -10));
|
}
|
if (data.getFullWeightTime().before(data.getEmptyWeightTime())) {
|
data.setEmptyWeightTime(DateUtils.addMinutes(data.getEmptyWeightTime(), -40));
|
}
|
if (data.getEmptyWeightTime().before(data.getRegisterTime())) {
|
data.setRegisterTime(DateUtils.addMinutes(data.getFullWeightTime(), -30));
|
}
|
}
|
|
|
//先保存主表，后执行子表
|
inoutService.insertData(data);
|
|
if (InoutConstant.TYPE_IN.equals(data.getType())) {
|
this.updateCheckItems(data, true);
|
}
|
fileService.saveInoutFiles(data.getFiles(), data.getCompanyId(), data.getId(), null);
|
return null;
|
}
|
|
/**
|
* 修改操作 修改逻辑说明：修改数据需要获取原数据库中的数据进行对比。
|
*
|
* @param data
|
* @return
|
* @throws Exception
|
*/
|
@Transactional
|
public String updateInoutData(InoutData data) throws Exception {
|
|
if (InoutConstant.RECORD_STATUS_DEL.equals(data.getRecordStatus())) {
|
return "系统：已经删除的数据不支持修改！";
|
}
|
|
|
if (InoutConstant.PROGRESS_RECORD.equals(data.getProgress())) {
|
return "系统：流程已经结束的数据不支持修改！";
|
}
|
|
// 保存检测项目
|
if (InoutConstant.TYPE_IN.equals(data.getType())) {
|
data = updateCheckItems(data, true);
|
}
|
|
return inoutService.updateData(data);
|
}
|
|
|
/**
|
* 异常终止操作 设置异常 为了避免页面数据缓存，需要重新获取最新数据判断
|
*
|
* @param data
|
* @return
|
* @throws Exception
|
*/
|
public String errorInoutData(InoutData data) throws Exception {
|
InoutParam param = new InoutParam();
|
param.setCompanyId(data.getCompanyId());
|
param.setId(data.getId());
|
|
param.setMsg(" 于" + DateFormatUtils.format(new Date(), "yyyy-MM-dd HH:mm") + " 被 " + ContextUtil.getLoginUserCName() + " 执行终止，原因：" + data.getRemarks());
|
|
data = inoutService.inoutQueryById(param);
|
|
// if (InoutConstant.PROGRESS_RECORD.equals(data.getProgress())) {
|
// return "流程结束的数据不支持异常处理！";
|
// }
|
if (InoutConstant.RECORD_STATUS_DEL.equals(data.getRecordStatus())) {
|
return "当前信息已做异常处理，不支持重复执行！";
|
}
|
|
|
param.setDeptId(data.getDeptId());
|
param.setType(data.getType());
|
return inoutService.inoutStop(param);
|
}
|
|
/**
|
* 快速结束操作 流程没有结束的单据进行结束
|
*
|
* @param data
|
* @return
|
*/
|
public String completeInoutData(InoutData data) throws Exception {
|
// 从新查询数据
|
InoutParam param = new InoutParam();
|
param.setId(data.getId());
|
param.setCompanyId(data.getCompanyId());
|
param.setType(data.getType());
|
InoutData cuData = inoutService.inoutQueryById(param);
|
if (null == cuData) {
|
return "当前车辆流程状态已经变化，请刷新页面重新操作！";
|
}
|
|
if (!cuData.getProgress().equals(data.getProgress())) {
|
return "当前车辆流程状态已经变化，请刷新页面重新操作！";
|
}
|
|
if (InoutConstant.RECORD_STATUS_DEL.equals(cuData.getRecordStatus())) {
|
return "当前信息已经被异常终止，不支持当前处理！";
|
}
|
if (InoutConstant.PROGRESS_RECORD.equals(cuData.getProgress())) {
|
return "流程已完成的数据，不支持完成！";
|
}
|
|
if (null == data.getCompleteTime()) {
|
return "请填写完成时间！！";
|
}
|
if (StringUtils.isEmpty(data.getDepotId())) {
|
return "请填写仓库信息！";
|
}
|
if (StringUtils.isEmpty(data.getFoodYear())) {
|
return "请填写粮食年份信息！";
|
}
|
if (StringUtils.isEmpty(data.getFoodVariety())) {
|
return "请填写粮食品种信息！";
|
}
|
|
if (data.getSettleWeight() <= 0) {
|
return "请填写结算净重信息！";
|
}
|
|
String msg = inoutService.quickComplete(data);
|
|
|
return msg;
|
}
|
|
/**
|
* 出入库登记初始化
|
*
|
* @param conf 车牌识别配置信息
|
*/
|
public void initInoutRegister(InoutConf conf) {
|
inoutEventControl.initInoutRegister(conf);
|
}
|
|
/**
|
* 出入库注册数据提交，入库登记和出入库登记使用同一个方法
|
*
|
* @param data
|
* @return
|
* @throws Exception
|
*/
|
public PageResponse<InoutData> submitRegisterInout(InoutData data) throws Exception {
|
|
// 首先判断流程中是否有已经存在的车辆信息未执行完成，直接从数据库中查询
|
InoutParam param = new InoutParam();
|
param.setCompanyId(data.getCompanyId());
|
param.setPlateNum(data.getPlateNum());
|
param.setIntelCard(data.getIntelCard());
|
param.setType(data.getType());
|
param.setStart(DateUtil.getNewByDay(null, -10));
|
|
int num = inoutService.checkExist(param);
|
if (num > 0) {
|
return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(),
|
"当前车牌或智慧卡有正在执行流程未结束，请联系管理员", data);
|
}
|
|
// 获取系统参数配置
|
InoutSysConf inoutSysConf = inoutCommonService.getCacheInoutSysConf(
|
data.getCompanyId(), data.getDeptId());
|
if (null == inoutSysConf) {
|
return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(),
|
"提示：当前库区未配置出入库流程信息，请联系管理员", data);
|
}
|
List<FileData> files = data.getFiles();
|
// 获取下一个流程状态
|
String curProgress = data.getProgress();
|
String nextProgress = getNextProgress(curProgress, data.getType(),
|
inoutSysConf);
|
|
data = updateBasicInfo(data, curProgress, nextProgress);
|
|
String msg = inoutService.insertData(data);
|
|
if (null != msg) {
|
return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(), msg, data);
|
}
|
|
if (null != files && files.size() > 0) {
|
// 执行附件信息
|
fileService.saveInoutFiles(files, data.getCompanyId(), data.getId(), curProgress);
|
}
|
|
//登记完成事件
|
inoutEventControl.onInoutRegister(data);
|
|
return new PageResponse<>(RespCodeEnum.CODE_0000.getCode(), "执行成功",
|
data);
|
}
|
|
public PageResponse<InoutData> submitWeightIn(InoutData data) throws Exception {
|
// 获取系统参数配置
|
InoutSysConf inoutSysConf = inoutCommonService.getCacheInoutSysConf(
|
data.getCompanyId(), data.getDeptId());
|
if (null == inoutSysConf) {
|
return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(),
|
"提示：当前系统中流程配置异常，请联系管理员", data);
|
}
|
List<FileData> files = data.getFiles();
|
// 获取下一个流程状态
|
String curProgress = data.getProgress();
|
String nextProgress = getNextProgress(curProgress, data.getType(),
|
inoutSysConf);
|
data = updateBasicInfo(data, curProgress, nextProgress);
|
|
// 入库称重可能调整质检单
|
data = updateCheckItems(data, true);
|
|
// 执行数据更新
|
String msg = inoutService.updateData(data);
|
|
if (null != msg) {
|
return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(), msg,
|
data);
|
}
|
|
if (null != files && files.size() > 0) {
|
// 执行附件信息
|
fileService.saveInoutFiles(files, data.getCompanyId(), data.getId(), curProgress);
|
}
|
|
// 称重完成事件
|
inoutEventControl.onInoutWeight(data, curProgress, nextProgress);
|
|
return new PageResponse<>(RespCodeEnum.CODE_0000.getCode(), "执行成功", data);
|
}
|
|
public PageResponse<InoutData> submitWeightOut(InoutData data)
|
throws Exception {
|
// 获取系统参数配置
|
InoutSysConf inoutSysConf = inoutCommonService.getCacheInoutSysConf(
|
data.getCompanyId(), data.getDeptId());
|
if (null == inoutSysConf) {
|
return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(),
|
"提示：当前系统中流程配置异常，请联系管理员", data);
|
}
|
|
// 获取下一个流程状态
|
String curProgress = data.getProgress();
|
String nextProgress = getNextProgress(curProgress, data.getType(),
|
inoutSysConf);
|
data = updateBasicInfo(data, curProgress, nextProgress);
|
|
// 执行数据更新
|
String msg = inoutService.updateData(data);
|
|
if (null != msg) {
|
return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(), msg,
|
data);
|
}
|
|
// 执行附件信息
|
fileService.saveInoutFiles(data.getFiles(), data.getCompanyId(),
|
data.getId(), curProgress);
|
|
|
// 称重完成事件
|
inoutEventControl.onInoutWeight(data, curProgress, nextProgress);
|
|
return new PageResponse<>(RespCodeEnum.CODE_0000.getCode(), "执行成功", data);
|
}
|
|
public PageResponse<InoutData> submitHandle(InoutData data)
|
throws Exception {
|
|
if (null == data.getHandleUser()) {
|
data.setHandleUser(ContextUtil.getLoginUserCName());
|
}
|
|
// 获取系统参数配置
|
InoutSysConf inoutSysConf = inoutCommonService.getCacheInoutSysConf(data.getCompanyId(), data.getDeptId());
|
if (null == inoutSysConf) {
|
return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(),
|
"提示：当前系统中流程配置异常，请联系管理员", data);
|
}
|
|
// 获取下一个流程状态
|
String curProgress = data.getProgress();
|
String nextProgress = getNextProgress(curProgress, data.getType(), inoutSysConf);
|
data = updateBasicInfo(data, curProgress, nextProgress);
|
|
// 执行数据更新
|
String msg = inoutService.updateDataByHandle(data);
|
|
if (null != msg) {
|
return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(), msg, data);
|
}
|
|
// 执行附件信息
|
fileService.saveInoutFiles(data.getFiles(), data.getCompanyId(), data.getId(), curProgress);
|
|
// 值仓完成触发事件
|
inoutEventControl.onInoutHandle(data, curProgress, nextProgress);
|
|
return new PageResponse<>(RespCodeEnum.CODE_0000.getCode(), "执行成功", data);
|
}
|
|
/**
|
* 根据条件获取扦样数据
|
*
|
* @param param
|
* @return
|
*/
|
public PageResponse<Page<InoutCheckData>> pageSampleData(
|
InoutCheckParam param) {
|
|
if (StringUtils.isEmpty(param.getCompanyId())) {
|
param.setCompanyId(ContextUtil.getCompanyId());
|
}
|
if (StringUtils.isEmpty(param.getDeptId())) {
|
param.setDeptId(ContextUtil.subDeptId(null));
|
}
|
|
// 若查询条件为已扦样，则流程置空；若未扦样，则流程不处理，仍为扦样化验流程(CHECK)
|
if (!"NONE".equals(param.getSampleStatus())) {
|
param.setProgress(null);
|
}
|
|
// 获取扦样数据
|
Page<InoutCheckData> sampleList = inoutService.pageSampleData(param);
|
|
if (null == sampleList.getRecords()
|
|| sampleList.getRecords().isEmpty()) {
|
return new PageResponse<>(RespCodeEnum.CODE_2000.getCode(),
|
"获取到数据信息为空");
|
}
|
return new PageResponse<>(RespCodeEnum.CODE_0000, sampleList);
|
}
|
|
|
public PageResponse<InoutCheckData> submitSample(InoutCheckData data) throws Exception {
|
|
// 获取业务数据信息
|
InoutParam param = new InoutParam();
|
param.setCompanyId(data.getCompanyId());
|
param.setId(data.getId());
|
InoutData curData = inoutService.inoutProgressQuery(param);
|
|
|
if (null == curData) {
|
return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(),
|
"没有获取到入库业务数据信息，更新失败", data);
|
}
|
if (InoutConstant.PROGRESS_RECORD.equals(curData.getProgress())) {
|
return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(),
|
"当前流程已经结束，不支持修改");
|
}
|
|
// 扦样时间和扦样人
|
if (StringUtils.isEmpty(data.getSampleUser())) {
|
data.setSampleUser(ContextUtil.getLoginUserCName());
|
}
|
|
if (null == data.getSampleTime()) {
|
data.setSampleTime(new Date());
|
}
|
|
String msg = inoutService.updateSampleData(data);
|
|
if (null != msg) {
|
return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(), msg);
|
}
|
|
// 扦样完成触发事件
|
inoutEventControl.onInSimple(data);
|
|
return new PageResponse<>(RespCodeEnum.CODE_0000.getCode(), "执行成功");
|
}
|
|
public PageResponse<InoutCheckData> submitCheck(InoutCheckData data) throws Exception {
|
|
// 获取系统参数配置
|
InoutSysConf inoutSysConf = inoutCommonService.getCacheInoutSysConf(data.getCompanyId(), data.getDeptId());
|
if (null == inoutSysConf) {
|
return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(),
|
"提示：当前库区未配置出入库流程信息，请联系管理员", data);
|
}
|
|
// 获取业务数据信息
|
InoutParam param = new InoutParam();
|
param.setCompanyId(data.getCompanyId());
|
param.setId(data.getId());
|
InoutData curData = inoutService.inoutProgressQuery(param);
|
|
if (null == curData) {
|
return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(),
|
"没有获取到入库业务数据信息，更新失败", data);
|
}
|
|
if (InoutConstant.PROGRESS_RECORD.equals(curData.getProgress())) {
|
return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(),
|
"当前流程已经结束，不支持修改");
|
}
|
|
// 更新化验项信息
|
CheckUpdateResult checkResult = checkStandardManager.updateCheckItems(data.getCheckId(), data.getCompanyId(), data.getCheckItems());
|
if (StringUtils.isNotEmpty(checkResult.getMsg())) {
|
return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(),
|
"后台执行异常：" + checkResult.getMsg(), data);
|
}
|
|
// 设置化验信息
|
if (checkResult.getDeSum() > 0) {
|
curData.setDeCheck(checkResult.getDeSum());
|
data.setDeCheck(checkResult.getDeSum());
|
}
|
if (checkResult.getAddSum() > 0) {
|
curData.setAddCheck(checkResult.getAddSum());
|
data.setAddCheck(checkResult.getAddSum());
|
}
|
if (null == data.getCheckTime()) {
|
curData.setCheckTime(new Date());
|
data.setCheckTime(new Date());
|
}
|
curData.setCheckUser(data.getCheckUser());
|
curData.setCheckStatus(data.getCheckStatus());
|
curData.setFoodYear(data.getFoodYear());
|
|
|
// 获取下一个流程状态
|
String curProgress = curData.getProgress();
|
String nextProgress = getNextProgress(curProgress, curData.getType(), inoutSysConf);
|
curData = updateBasicInfo(curData, curProgress, nextProgress);
|
|
// 若化验结果不合格，判断配置后续流程
|
if (InoutConstant.STATUS_UNPASS.equals(curData.getCheckStatus())) {
|
curData = checkNoPass(curData);
|
}
|
|
curData.setProgress(curData.getProgress());
|
curData.setType(curData.getType());
|
curData.setFoodLevel(data.getFoodLevel());
|
curData.setFoodVariety(data.getFoodVariety());
|
curData.setPrice(data.getPrice());
|
curData.setRemarks(data.getRemarks());
|
curData.setCheckItems(data.getCheckItems());
|
curData.setCheckTime(data.getCheckTime());
|
curData.setDepotId(data.getDepotId());
|
|
if (StringUtils.isEmpty(data.getCheckUser())) {
|
curData.setCheckUser(ContextUtil.getLoginUserCName());
|
}
|
if (null == data.getCheckTime()) {
|
curData.setCheckTime(new Date());
|
}
|
|
String msg = inoutService.updateCheckData(curData);
|
|
if (null != msg) {
|
return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(), msg);
|
}
|
|
|
// 质检完成触发事件
|
inoutEventControl.onInCheck(data, curProgress, nextProgress);
|
|
return new PageResponse<>(RespCodeEnum.CODE_0000.getCode(), "执行成功");
|
}
|
|
public PageResponse<InoutCheckData> submitCheckData(InoutCheckData data) throws Exception {
|
|
|
// 获取业务数据信息
|
InoutParam param = new InoutParam();
|
param.setCompanyId(data.getCompanyId());
|
param.setId(data.getId());
|
InoutData curData = inoutService.inoutProgressQuery(param);
|
|
if (null == curData) {
|
return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(),
|
"没有获取到入库业务数据信息，更新失败", data);
|
}
|
|
if (InoutConstant.PROGRESS_RECORD.equals(curData.getProgress())) {
|
return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(),
|
"当前流程已经结束，不支持修改");
|
}
|
|
// 更新化验项信息
|
CheckUpdateResult checkResult = checkStandardManager.updateCheckItems(data.getCheckId(), data.getCompanyId(), data.getCheckItems());
|
if (StringUtils.isNotEmpty(checkResult.getMsg())) {
|
return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(),
|
"后台执行异常：" + checkResult.getMsg(), data);
|
}
|
|
curData.setType(curData.getType());
|
curData.setFoodLevel(data.getFoodLevel());
|
curData.setFoodVariety(data.getFoodVariety());
|
curData.setPrice(data.getPrice());
|
curData.setDepotId(data.getDepotId());
|
curData.setCheckItems(data.getCheckItems());
|
|
String msg = inoutService.updateCheckData(curData);
|
if (null != msg) {
|
return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(), msg);
|
}
|
|
return new PageResponse<>(RespCodeEnum.CODE_0000.getCode(), "保存成功");
|
}
|
|
/**
|
* @param param
|
* @return
|
*/
|
public PageResponse<Page<InoutCheckData>> pageCheckData(
|
InoutCheckParam param) {
|
|
if (StringUtils.isEmpty(param.getCompanyId())) {
|
param.setCompanyId(ContextUtil.getCompanyId());
|
}
|
if (StringUtils.isEmpty(param.getDeptId())) {
|
param.setDeptId(ContextUtil.subDeptId(null));
|
}
|
// 如果是已化验，则将流程状态置空，如果是未化验，则流程状态不处理，仍是CHECK状态
|
if (!"NONE".equals(param.getCheckStatus())) {
|
param.setProgress(null);
|
}
|
|
Page<InoutCheckData> checkList = inoutService.pageCheckData(param);
|
|
if (null == checkList.getRecords() || checkList.getRecords().isEmpty()) {
|
return new PageResponse<>(RespCodeEnum.CODE_2000.getCode(),
|
"获取到数据信息为空");
|
}
|
return new PageResponse<>(RespCodeEnum.CODE_0000, checkList);
|
}
|
|
/**
|
* 获取化验项信息
|
*
|
* @param param
|
* @return
|
*/
|
public PageResponse<List<CheckItemData>> getCheckItemData(
|
InoutCheckParam param) {
|
|
try {
|
List<CheckItemData> result = checkStandardManager.listCheckItem(
|
param.getCompanyId(), param.getCheckId(),
|
param.getFoodVariety());
|
|
return new PageResponse<>(RespCodeEnum.CODE_0000, result);
|
} catch (Exception e) {
|
return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(), "后台异常："
|
+ e.getMessage(), null);
|
}
|
}
|
|
|
/**
|
* 获取单价信息
|
*
|
* @param param
|
* @return
|
*/
|
public PageResponse<InoutPrice> getPrice(InoutCheckParam param) {
|
try {
|
|
List<InoutPrice> price = inoutService.getPrice(param);
|
if (null == price || price.isEmpty()) {
|
return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(),
|
"未获取到粮食定价配置信息");
|
}
|
return new PageResponse<>(RespCodeEnum.CODE_0000, price.get(0));
|
|
} catch (Exception e) {
|
return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(), "后台异常："
|
+ e.getMessage(), null);
|
}
|
}
|
|
/**
|
* @param param
|
* @return
|
*/
|
public PageResponse<InoutCheckData> inoutDataByCheckId(InoutCheckParam param) {
|
if (StringUtils.isEmpty(param.getCheckId())) {
|
return new PageResponse<>(RespCodeEnum.CODE_1007.getCode(),
|
"查询参数不完整，查询失败！");
|
}
|
|
InoutCheckData result;
|
try {
|
param.setProgress(InoutConstant.PROGRESS_CHECK);
|
result = inoutService.inoutDataByCheckId(param);
|
if (null == result) {
|
return new PageResponse<>(RespCodeEnum.CODE_2000.getCode(),
|
"系统未查询到执行中的车辆信息", null);
|
}
|
|
return new PageResponse<>(RespCodeEnum.CODE_0000, result);
|
|
} catch (Exception e) {
|
return new PageResponse<>(RespCodeEnum.CODE_2000.getCode(),
|
e.getMessage());
|
}
|
}
|
|
public void initInoutWeight(List<InoutConf> listInoutConf, String sort) {
|
inoutEventControl.initInoutWeight(listInoutConf, sort);
|
}
|
|
}
|
