package com.ld.igds.inout.manager;
|
|
import com.bstek.bdf2.core.business.IUser;
|
import com.ld.igds.check.CheckStandardManager;
|
import com.ld.igds.check.dto.CheckItemData;
|
import com.ld.igds.check.dto.CheckUpdateResult;
|
import com.ld.igds.common.CoreCommonService;
|
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.InoutData;
|
import com.ld.igds.inout.dto.InoutGateDto;
|
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.Depot;
|
import com.ld.igds.models.InoutConf;
|
import com.ld.igds.models.InoutSysConf;
|
import com.ld.igds.util.ContextUtil;
|
import com.ld.igds.util.DateUtil;
|
import com.ld.igds.util.NumberUtil;
|
import com.ld.igds.util.RespUtil;
|
import lombok.extern.slf4j.Slf4j;
|
import org.apache.commons.lang3.StringUtils;
|
import org.apache.commons.lang3.time.DateUtils;
|
import org.springframework.beans.factory.annotation.Autowired;
|
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
|
*/
|
@Slf4j
|
@Component
|
public class InoutManager {
|
|
@Autowired
|
private InoutService inoutService;
|
@Autowired
|
private CoreFileService fileService;
|
@Autowired
|
private CoreCommonService commonService;
|
@Autowired
|
private InoutCommonService inoutManagerService;
|
@Autowired
|
private CheckStandardManager checkStandardManager;
|
@Resource
|
private InoutDeviceManager inoutDeviceManager;
|
|
/**
|
* 当前先从当日缓存中获取数据，如果缓存中没有再从数据库获取
|
*
|
* @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(),
|
"参数不完整，无法获取信息！");
|
}
|
|
if (StringUtils.isEmpty(param.getCompanyId())) {
|
param.setCompanyId(ContextUtil.getCompanyId());
|
}
|
|
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())) {
|
if (InoutConstant.TYPE_IN.equals(result.getType())) {
|
return new PageResponse<>(RespCodeEnum.CODE_2000.getCode(),
|
"系统：当前车辆业务为【入库】", result);
|
} else {
|
return new PageResponse<>(RespCodeEnum.CODE_2000.getCode(),
|
"系统：当前车辆业务为【出库】", 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);
|
}
|
}
|
|
// 根据当前数据判断是否推送
|
inoutService.notifyWeb(result);
|
|
//为当前数据添加化验项目和水分和杂质的化验结果,用于出入库增扣重计算
|
if (InoutConstant.TYPE_IN.equals(result.getType())) {
|
List<CheckItemData> checkItemDataList = inoutService.getCheckCache(result.getCompanyId(), result.getCheckId());
|
result.setCheckItems(checkItemDataList);
|
if (null != checkItemDataList && checkItemDataList.size() > 0) {
|
for (CheckItemData checkItem : checkItemDataList) {
|
if (StringUtils.isEmpty(checkItem.getValue())) {
|
continue;
|
}
|
|
if (InoutConstant.CHECK_ITEM_C01.equals(checkItem.getStandardId())) {
|
result.setWet(Double.valueOf(checkItem.getValue()));
|
}
|
if (InoutConstant.CHECK_ITEM_C02.equals(checkItem.getStandardId())) {
|
result.setImpurity(Double.valueOf(checkItem.getValue()));
|
}
|
}
|
}
|
}
|
|
return new PageResponse<>(RespCodeEnum.CODE_0000, result);
|
|
} catch (Exception e) {
|
return new PageResponse<>(RespCodeEnum.CODE_2000.getCode(),
|
e.getMessage());
|
}
|
}
|
|
public PageResponse<InoutData> outNextStep(InoutData data) throws Exception {
|
String msg;
|
IUser user = ContextUtil.getLoginUser();
|
if (StringUtils.isEmpty(data.getCompanyId())) {
|
data.setCompanyId(user.getCompanyId());
|
}
|
if (StringUtils.isEmpty(data.getDeptId())) {
|
data.setDeptId(ContextUtil.subDeptId(user));
|
}
|
if (StringUtils.isEmpty(data.getIntelCard())) {
|
data.setIntelCard(data.getUserId());
|
}
|
|
String curProgress = data.getProgress();
|
List<FileData> files = data.getFiles();
|
|
// 更新下一个状态和基本信息
|
InoutSysConf inoutSysConf = inoutManagerService.getCacheInoutSysConf(
|
data.getCompanyId(), data.getDeptId());
|
if (null == inoutSysConf
|
|| StringUtils.isEmpty(inoutSysConf.getProgressIn())) {
|
return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(),
|
"当前库区未配置出库流程信息，请联系管理员配置。", data);
|
}
|
data = updateOutBasicInfo(data, inoutSysConf);
|
|
// 如果当前节点是注册，则需要验证下，是否有为完成的流程在执行中
|
if (InoutConstant.PROGRESS_REGISTER.equals(curProgress)) {
|
InoutData progressData = this.inoutProgressQuery(data);
|
if (null != progressData) {
|
return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(),
|
"当前卡片/车牌号有流程未结束。", progressData);
|
}
|
}
|
|
if(null != data.getPrice() && null != data.getRecordWeight()){
|
data.setSettleMoney(NumberUtil.keepPrecision(data.getPrice()*data.getRecordWeight(),2));
|
}
|
|
// 流程完成，直接调用流程完成接口
|
if (InoutConstant.PROGRESS_RECORD.equals(data.getProgress())) {
|
inoutService.updateData(data);
|
// 执行附件信息
|
if (null != files) {
|
fileService.saveInoutFiles(files, data.getCompanyId(),
|
data.getId(), curProgress);
|
}
|
|
// 通知称重主控流程结束
|
inoutDeviceManager.noticeProgressComplete(data);
|
|
return inoutComplete(data);
|
}
|
|
// 调用保存方法执行
|
if (StringUtils.isEmpty(data.getId())) {
|
msg = inoutService.insertData(data);
|
} else {
|
msg = inoutService.updateData(data);
|
}
|
|
// 执行附件信息
|
if (null != files) {
|
fileService.saveInoutFiles(files, data.getCompanyId(),
|
data.getId(), curProgress);
|
}
|
|
if (null != msg) {
|
return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(), msg,
|
data);
|
}
|
return new PageResponse<>(RespCodeEnum.CODE_0000.getCode(), "执行成功",
|
data);
|
}
|
|
public PageResponse<InoutData> inNextStep(InoutData data) throws Exception {
|
String msg;
|
IUser user = ContextUtil.getLoginUser();
|
if (StringUtils.isEmpty(data.getCompanyId())) {
|
data.setCompanyId(user.getCompanyId());
|
}
|
if (StringUtils.isEmpty(data.getDeptId())) {
|
data.setDeptId(ContextUtil.subDeptId(user));
|
}
|
String curProgress = data.getProgress();
|
List<FileData> files = data.getFiles();
|
|
if (StringUtils.isEmpty(data.getIntelCard())) {
|
data.setIntelCard(data.getUserId());
|
}
|
|
// 更新下一个状态和基本信息
|
InoutSysConf inoutSysConf = inoutManagerService.getCacheInoutSysConf(data.getCompanyId(), data.getDeptId());
|
|
if (null == inoutSysConf
|
|| StringUtils.isEmpty(inoutSysConf.getProgressIn())) {
|
return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(),
|
"当前库区未配置入库流程信息，请联系管理员配置。", data);
|
}
|
|
data = updateInBasicInfo(data, inoutSysConf);
|
|
// 如果当前节点是注册，则需要验证下，是否有为完成的流程在执行中
|
if (InoutConstant.PROGRESS_REGISTER.equals(curProgress)) {
|
InoutData progressData = this.inoutProgressQuery(data);
|
if (null != progressData) {
|
return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(),
|
"当前卡片/车牌号有流程未结束。", progressData);
|
}
|
}
|
|
if(null != data.getPrice() && null != data.getRecordWeight()){
|
data.setSettleMoney(NumberUtil.keepPrecision(data.getPrice()*data.getRecordWeight(),2));
|
}
|
|
// 流程完成，直接调用流程完成接口
|
if (InoutConstant.PROGRESS_RECORD.equals(data.getProgress())) {
|
if (StringUtils.isEmpty(data.getCompanyId())) {
|
data.setCompanyId(ContextUtil.getCompanyId());
|
}
|
|
inoutService.updateData(data);
|
// 执行附件信息
|
if (null != files) {
|
fileService.saveInoutFiles(files, data.getCompanyId(),
|
data.getId(), curProgress);
|
}
|
|
// 通知称重主控流程结束
|
inoutDeviceManager.noticeProgressComplete(data);
|
|
return inoutComplete(data);
|
}
|
|
// 调用保存方法执行
|
if (StringUtils.isEmpty(data.getId())) {
|
msg = inoutService.insertData(data);
|
} else {
|
msg = inoutService.updateData(data);
|
}
|
|
// 执行附件信息
|
if (null != files) {
|
fileService.saveInoutFiles(files, data.getCompanyId(),
|
data.getId(), curProgress);
|
}
|
|
if (null != msg) {
|
return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(), msg);
|
}
|
|
return new PageResponse<>(RespCodeEnum.CODE_0000.getCode(), "执行成功",
|
data);
|
}
|
|
public InoutData inoutProgressQuery(InoutData data) throws Exception {
|
InoutParam param = new InoutParam();
|
param.setCompanyId(data.getCompanyId());
|
param.setPlateNum(data.getPlateNum());
|
param.setIntelCard(data.getIntelCard());
|
param.setType(data.getType());
|
|
return inoutService.inoutProgressQuery(param);
|
}
|
|
@Transactional(rollbackFor = Exception.class)
|
public PageResponse<InoutData> updateCheck(InoutData data) throws Exception {
|
|
if (InoutConstant.PROGRESS_RECORD.equals(data.getProgress())) {
|
return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(),
|
"当前流程已经结束，不支持修改", data);
|
}
|
|
CheckUpdateResult checkResult = this.updateCheckItems(data);
|
String tag = checkResult.getMsg();
|
|
if (null != tag) {
|
return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(),
|
"后台执行异常：" + tag, data);
|
}
|
|
// 获取业务数据信息
|
InoutParam param = new InoutParam();
|
param.setCompanyId(data.getCompanyId());
|
param.setId(data.getId());
|
InoutData progressData = inoutService.inoutProgressQuery(param);
|
if (null == progressData) {
|
return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(),
|
"没有获取到出入库业务数据信息，更新失败", data);
|
}
|
if (InoutConstant.PROGRESS_RECORD.equals(progressData.getProgress())) {
|
return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(),
|
"当前流程已经结束，不支持修改");
|
}
|
progressData.setCheckStatus(data.getCheckStatus());
|
|
// 更新下一个状态和基本信息
|
if (InoutConstant.PROGRESS_CHECK.equals(progressData.getProgress())) {
|
progressData = updateInBasicInfo(progressData, null);
|
// 若化验结果不合格，判断配置后续流程
|
if (InoutConstant.STATUS_UNPASS.equals(progressData
|
.getCheckStatus())) {
|
progressData = checkNoPass(progressData);
|
}
|
}
|
progressData.setCheckUser(ContextUtil.getLoginUserCName());
|
if (StringUtils.isNotEmpty(data.getCustomerName())) {
|
progressData.setCustomerId(data.getCustomerId());
|
progressData.setCustomerName(data.getCustomerName());
|
}
|
if (StringUtils.isNotEmpty(data.getDepotId())) {
|
progressData.setDepotId(data.getDepotId());
|
}
|
if (StringUtils.isNotEmpty(data.getFoodVariety())) {
|
progressData.setFoodVariety(data.getFoodVariety());
|
}
|
if (StringUtils.isNotEmpty(data.getFoodLevel())) {
|
progressData.setFoodLevel(data.getFoodLevel());
|
}
|
if (StringUtils.isNotEmpty(data.getFoodLocation())) {
|
progressData.setFoodLocation(data.getFoodLocation());
|
}
|
if (StringUtils.isNotEmpty(data.getFoodYear())) {
|
progressData.setFoodYear(data.getFoodYear());
|
}
|
if (null != data.getPrice()) {
|
progressData.setPrice(data.getPrice());
|
}
|
if (StringUtils.isNotEmpty(data.getRemarks())) {
|
progressData.setRemarks(data.getRemarks());
|
}
|
if (StringUtils.isNotEmpty(data.getNoticeId())) {
|
progressData.setNoticeId(data.getNoticeId());
|
}
|
|
// 回填水分和杂质
|
if (checkResult.getWet() > 0) {
|
progressData.setWet(checkResult.getWet());
|
}
|
|
if (checkResult.getImpurity() > 0) {
|
progressData.setImpurity(checkResult.getImpurity());
|
}
|
|
String msg = inoutService.updateData(progressData);
|
|
if (null != msg) {
|
return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(), msg);
|
}
|
if (InoutConstant.PROGRESS_RECORD.equals(progressData.getProgress())) {
|
|
inoutComplete(progressData);
|
}
|
return new PageResponse<>(RespCodeEnum.CODE_0000.getCode(), "执行成功");
|
}
|
|
/**
|
* 化验结果不通过时校验配置信息
|
*
|
* @param data
|
* @return
|
*/
|
private InoutData checkNoPass(InoutData data) {
|
InoutSysConf inoutSysConf = inoutManagerService.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;
|
}
|
|
private CheckUpdateResult updateCheckItems(InoutData data) {
|
CheckUpdateResult result = new CheckUpdateResult();
|
if (null == data.getCheckItems())
|
return result;
|
try {
|
// 更新检验项数据
|
result = checkStandardManager.updateCheckItems(data.getCheckId(),
|
data.getCompanyId(), data.getCheckItems());
|
|
// 将化验数据存入缓存中
|
inoutService.setCheckCache(data);
|
|
return result;
|
|
} catch (Exception e) {
|
log.error("后台异常：{}", e);
|
result.setMsg("执行异常：" + e.getMessage());
|
}
|
return result;
|
}
|
|
/**
|
* 从缓存中获取下一流程
|
*
|
* @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 updateInBasicInfo(InoutData data, InoutSysConf sysConf) {
|
if (null == sysConf) {
|
sysConf = inoutManagerService.getCacheInoutSysConf(
|
data.getCompanyId(), data.getDeptId());
|
}
|
|
if (InoutConstant.PROGRESS_REGISTER.equals(data.getProgress())) {
|
data.setRegisterTime(new Date());
|
data.setRegisterUser(ContextUtil.getLoginUserCName());
|
data.setProgress(getNextProgress(data.getProgress(),
|
data.getType(), sysConf));
|
|
return data;
|
}
|
|
if (InoutConstant.PROGRESS_WEIGHT_FULL.equals(data.getProgress())) {
|
data.setFullWeightTime(new Date());
|
data.setFullWeightUser(ContextUtil.getLoginUserCName());
|
data.setProgress(getNextProgress(data.getProgress(),
|
data.getType(), sysConf));
|
return data;
|
}
|
if (InoutConstant.PROGRESS_CHECK.equals(data.getProgress())) {
|
data.setCheckUser(ContextUtil.getLoginUserCName());
|
data.setProgress(getNextProgress(data.getProgress(),
|
data.getType(), sysConf));
|
return data;
|
}
|
|
if (InoutConstant.PROGRESS_WEIGHT_EMPTY.equals(data.getProgress())) {
|
data.setEmptyWeightTime(new Date());
|
data.setEmptyWeightUser(ContextUtil.getLoginUserCName());
|
|
data.setProgress(getNextProgress(data.getProgress(),
|
data.getType(), sysConf));
|
|
if (InoutConstant.PROGRESS_RECORD.equals(data.getProgress())) {
|
data.setCompleteTime(DateUtils.addMinutes(new Date(), 2));
|
data.setCompleteUser(ContextUtil.getLoginUserCName());
|
}
|
return data;
|
}
|
|
if (InoutConstant.PROGRESS_HANDLE.equals(data.getProgress())) {
|
|
// 查询缓存中仓库信息，根据仓库id设置值仓人为仓库保管员
|
Depot depot = commonService.getCacheDepot(data.getCompanyId(),
|
data.getDepotId());
|
data.setHandleUser(depot == null ? "" : depot.getStoreKeeperName());
|
data.setProgress(getNextProgress(data.getProgress(),
|
data.getType(), sysConf));
|
return data;
|
}
|
|
if (InoutConstant.PROGRESS_CARD_BACK.equals(data.getProgress())) {
|
data.setCompleteTime(new Date());
|
data.setCompleteUser(ContextUtil.getLoginUserCName());
|
data.setProgress(getNextProgress(data.getProgress(),
|
data.getType(), sysConf));
|
return data;
|
}
|
return data;
|
}
|
|
/**
|
* 根据需要保存的数据，调整下一个流程状态 不同的仓库组织流程可能不一样，需要根据实际调整
|
*
|
* @param data
|
* @return
|
*/
|
private InoutData updateOutBasicInfo(InoutData data, InoutSysConf sysConf) {
|
if (InoutConstant.PROGRESS_REGISTER.equals(data.getProgress())) {
|
data.setRegisterTime(new Date());
|
data.setRegisterUser(ContextUtil.getLoginUserCName());
|
data.setProgress(getNextProgress(data.getProgress(),
|
data.getType(), sysConf));
|
|
return data;
|
}
|
if (InoutConstant.PROGRESS_WEIGHT_EMPTY.equals(data.getProgress())) {
|
data.setEmptyWeightTime(new Date());
|
data.setEmptyWeightUser(ContextUtil.getLoginUserCName());
|
data.setProgress(getNextProgress(data.getProgress(),
|
data.getType(), sysConf));
|
|
return data;
|
}
|
|
if (InoutConstant.PROGRESS_HANDLE.equals(data.getProgress())) {
|
// 查询缓存中仓库信息，根据仓库id设置值仓人为仓库保管员
|
Depot depot = commonService.getCacheDepot(data.getCompanyId(),
|
data.getDepotId());
|
data.setHandleUser(depot == null ? "" : depot.getStoreKeeperName());
|
data.setProgress(getNextProgress(data.getProgress(),
|
data.getType(), sysConf));
|
|
return data;
|
}
|
|
if (InoutConstant.PROGRESS_WEIGHT_FULL.equals(data.getProgress())) {
|
data.setFullWeightTime(new Date());
|
data.setFullWeightUser(ContextUtil.getLoginUserCName());
|
data.setProgress(getNextProgress(data.getProgress(),
|
data.getType(), sysConf));
|
if (InoutConstant.PROGRESS_RECORD.equals(data.getProgress())) {
|
data.setCompleteTime(DateUtils.addMinutes(new Date(), 2));
|
data.setCompleteUser(ContextUtil.getLoginUserCName());
|
}
|
return data;
|
}
|
|
if (InoutConstant.PROGRESS_CARD_BACK.equals(data.getProgress())) {
|
data.setCompleteTime(new Date());
|
data.setCompleteUser(ContextUtil.getLoginUserCName());
|
data.setProgress(getNextProgress(data.getProgress(),
|
data.getType(), sysConf));
|
|
return data;
|
}
|
|
return data;
|
}
|
|
public PageResponse<Page<InoutData>> pageRecordData(InoutParam param) {
|
|
log.debug("分页信息--page={},limit={},cuur={}", param.getPage(),
|
param.getLimit(), param.getCurr());
|
|
Page<InoutData> result = inoutService.pageRecordData(param);
|
|
if (null == result.getRecords() || result.getRecords().isEmpty()) {
|
return new PageResponse<>(RespCodeEnum.CODE_2000.getCode(),
|
"获取到数据信息为空");
|
}
|
|
return new PageResponse<>(RespCodeEnum.CODE_0000, result);
|
}
|
|
/**
|
* @param param
|
* @return
|
*/
|
public PageResponse<Page<InoutData>> pageCheckData(InoutParam param) {
|
// 如果是已化验，则将流程状态置空，如果是未化验，则流程状态不处理，仍是CHECK状态
|
if (!"NONE".equals(param.getCheckStatus())) {
|
param.setProgress(null);
|
}
|
// 设置分库Id
|
String deptId = ContextUtil.subDeptId(null);
|
param.setDeptId(deptId);
|
return pageRecordData(param);
|
}
|
|
|
public PageResponse<InoutData> inoutComplete(InoutData data) throws Exception {
|
|
if (StringUtils.isEmpty(data.getId())
|
|| StringUtils.isEmpty(data.getType())) {
|
|
return new PageResponse<>(RespCodeEnum.CODE_1007.getCode(),
|
"没有获取到车辆信息。", data);
|
}
|
|
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(ContextUtil.getLoginUserCName());
|
param.setDepotId(data.getDepotId());
|
param.setCompleteTime(data.getCompleteTime());
|
if (null == param.getCompleteTime()) {
|
param.setCompleteTime(new Date());
|
}
|
// 设置流程节点直接完成
|
param.setProgress(InoutConstant.PROGRESS_RECORD);
|
|
if (null == data.getCompleteTime()) {
|
data.setCompleteTime(DateUtil.getNewByMinute(new Date(), 2));
|
}
|
String msg = inoutService.toComplete(param);
|
|
if (null != msg) {
|
return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(), msg);
|
}
|
|
// 库存调整
|
commonService.initInoutDepotStore(data);
|
|
return new PageResponse<>(RespCodeEnum.CODE_0000.getCode(), null, data);
|
}
|
|
/**
|
* 扦样化验页面获取检验项条目信息
|
*
|
* @param data
|
* @return
|
*/
|
public PageResponse<List<CheckItemData>> getCheckItem(InoutData data) {
|
|
List<CheckItemData> result = checkStandardManager.listCheckItem(
|
data.getCheckId(), data.getCompanyId(), data.getDeptId(),
|
data.getFoodVariety());
|
|
return new PageResponse<>(RespCodeEnum.CODE_0000, result);
|
}
|
|
/**
|
* 删除并完成
|
*
|
* @param data
|
* @return
|
*/
|
public PageResponse<InoutData> deleteInoutData(InoutData data, String msg) {
|
try {
|
data.setRemarks(msg);
|
String result = this.delInoutData(data, false);
|
if (null != result) {
|
return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(),
|
result, data);
|
}
|
} catch (Exception e) {
|
log.error("后台异常:{}", e);
|
return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(), "后台异常："
|
+ e.getMessage(), data);
|
}
|
return new PageResponse<>(RespCodeEnum.CODE_0000.getCode(), "执行完成",
|
data);
|
}
|
|
/**
|
* 卡回收逻辑处理
|
*
|
* @param data
|
* @return
|
*/
|
public PageResponse<InoutData> inoutBack(InoutData data) {
|
try {
|
// 从缓存中获取最新的数据，如果没有则表示流程已经结束。
|
InoutParam param = new InoutParam();
|
param.setCompanyId(data.getCompanyId());
|
param.setId(data.getId());
|
InoutData curData = inoutService.inoutProgressQuery(param);
|
if (InoutConstant.PROGRESS_RECORD.equals(curData.getProgress())) {
|
return new PageResponse<>(RespCodeEnum.CODE_2000.getCode(),
|
"当前卡流程已经完成，无需执行卡回收", data);
|
}
|
if (InoutConstant.RECORD_STATUS_DEL.equals(curData
|
.getRecordStatus())) {
|
return new PageResponse<>(RespCodeEnum.CODE_2000.getCode(),
|
"当前卡信息已被删除，不能执行卡回收", data);
|
}
|
|
// 如果当前流程状态是卡回收状态，就是完成流程。
|
if (InoutConstant.PROGRESS_CARD_BACK.equals(curData.getProgress())) {
|
return inoutComplete(curData);
|
}
|
|
// 如果是其他状态，则执行删除逻辑
|
return deleteInoutData(curData, "卡回收删除");
|
|
} catch (Exception e) {
|
return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(),
|
"后端执行异常：" + e.getMessage());
|
}
|
}
|
|
/* ============================== 详单页面相关操作 ================================= */
|
|
/**
|
* 补单操作 补单因为完成时间不确定，所以需要系统根据当前数据进行自动检测，调整原来流水信息和库存
|
*
|
* @param data
|
* @return
|
* @throws Exception
|
*/
|
@Transactional
|
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();
|
data.setRegisterUser(loginUser);
|
data.setFullWeightUser(loginUser);
|
data.setEmptyWeightUser(loginUser);
|
data.setHandleUser(loginUser);
|
data.setCompleteUser(loginUser);
|
if (null == data.getCompleteTime()) {
|
data.setCompleteTime(new Date());
|
}
|
// 注册时间比完成时间早一个小时
|
data.setRegisterTime(DateUtil.getNewByMinute(new Date(), -60));
|
|
if (StringUtils.isEmpty(data.getUserId())) {
|
data.setUserId(InoutConstant.DEFAULT_ID_CARD);
|
}
|
if (null == data.getIntelCard()) {
|
data.setIntelCard(data.getUserId());
|
}
|
if (null != data.getCheckItems()) {
|
data.setCheckUser(loginUser);
|
}
|
|
// 保存检测项目
|
if (InoutConstant.TYPE_IN.equals(data.getType())) {
|
|
if (null == data.getFullWeightTime()) {
|
data.setFullWeightTime(DateUtil.getNewByMinute(new Date(), -50));
|
}
|
if (null == data.getHandleEnd()) {
|
data.setHandleEnd(DateUtil.getNewByMinute(new Date(), -40));
|
}
|
if (null == data.getEmptyWeightTime()) {
|
data.setEmptyWeightTime(DateUtil.getNewByMinute(new Date(), -10));
|
}
|
|
// 先执行化验信息保存
|
CheckUpdateResult checkResult = checkStandardManager.updateCheckItems(data.getCheckId(), data.getCompanyId(),data.getCheckItems());
|
if (null != checkResult) {
|
if (null == data.getWet())data.setWet(checkResult.getWet());
|
if (null == data.getImpurity())data.setImpurity(checkResult.getImpurity());
|
}
|
} else {
|
if (null == data.getEmptyWeightTime()) {
|
data.setEmptyWeightTime(DateUtil.getNewByMinute(new Date(), -50));
|
}
|
if (null == data.getHandleEnd()) {
|
data.setHandleEnd(DateUtil.getNewByMinute(new Date(), -40));
|
}
|
if (null == data.getFullWeightTime()) {
|
data.setFullWeightTime(DateUtil.getNewByMinute(new Date(), -10));
|
}
|
}
|
|
// 添加补单数据
|
String msg = inoutService.insertData(data);
|
|
// 初始化验证出入库库存
|
commonService.initInoutDepotStore(data);
|
return msg;
|
}
|
|
/**
|
* 修改操作 修改逻辑说明：修改数据需要获取原数据库中的数据进行对比。
|
*
|
* @param data
|
* @return
|
* @throws Exception
|
*/
|
@javax.transaction.Transactional(rollbackOn = Exception.class)
|
public String updateInoutData(InoutData data) throws Exception {
|
|
if (InoutConstant.RECORD_STATUS_DEL.equals(data.getRecordStatus())) {
|
return "系统：已经删除的数据不支持修改！";
|
}
|
if (InoutConstant.RECORD_STATUS_ERROR.equals(data.getRecordStatus())) {
|
return "系统：异常终止的数据不支持修改！";
|
}
|
|
// 如果流程未结束，只更新数据
|
if (!InoutConstant.PROGRESS_RECORD.equals(data.getProgress())) {
|
return inoutService.updateData(data);
|
}
|
|
// 如果是已经完成的数据，先获取到修改直接的数据根据数据进行对比
|
InoutParam param = new InoutParam();
|
param.setId(data.getId());
|
param.setCompanyId(data.getCompanyId());
|
param.setType(data.getType());
|
InoutData record = inoutService.inoutQueryById(param);
|
|
if (null == record) {
|
return "当前修改数据已经不存在！";
|
}
|
|
// 避免数据库中的数据已经被其他人修改
|
if (InoutConstant.RECORD_STATUS_DEL.equals(record.getRecordStatus())) {
|
return "系统：已经删除的数据不支持修改！";
|
}
|
if (InoutConstant.RECORD_STATUS_ERROR.equals(record.getRecordStatus())) {
|
return "系统：异常终止的数据不支持修改！";
|
}
|
|
// 保存检测项目
|
if (InoutConstant.TYPE_IN.equals(data.getType())) {
|
// 先执行化验信息保存
|
CheckUpdateResult checkResult = checkStandardManager
|
.updateCheckItems(data.getCheckId(), data.getCompanyId(),
|
data.getCheckItems());
|
if (null != checkResult) {
|
if (null == data.getWet())
|
data.setWet(checkResult.getWet());
|
if (null == data.getImpurity())
|
data.setImpurity(checkResult.getImpurity());
|
}
|
}
|
|
// 更新数据
|
inoutService.updateData(data);
|
// this.autoCheckByUpdate(data, record);
|
return null;
|
}
|
|
/**
|
* 删除操作 删除数据为软删除，删除数据后需要根据删除情况联动库存等信息
|
*
|
* @param data
|
* @param selected
|
* 是否已经查询过数据
|
* @return
|
* @throws Exception
|
*/
|
@Transactional
|
public String delInoutData(InoutData data, boolean selected)
|
throws Exception {
|
|
// 避免页面缓存首先获取数据库中最新的当前数据信息
|
InoutParam param = new InoutParam();
|
param.setCompanyId(data.getCompanyId());
|
param.setId(data.getId());
|
param.setMsg(" [" + ContextUtil.getLoginUserCName() + "]执行删除，原因："
|
+ data.getRemarks());
|
|
if (!selected) {
|
data = inoutService.inoutQueryById(param);
|
|
if (InoutConstant.RECORD_STATUS_DEL.equals(data.getRecordStatus())) {
|
return "已经删除的数据，不支持重复删除！";
|
}
|
if (InoutConstant.RECORD_STATUS_ERROR
|
.equals(data.getRecordStatus())) {
|
return "当前数据已经被标记为异常，不支持删除！";
|
}
|
}
|
|
// 执行删除
|
param.setProgress(InoutConstant.PROGRESS_RECORD);
|
param.setRecordStatus(InoutConstant.RECORD_STATUS_DEL);
|
param.setType(data.getType());
|
inoutService.deleteData(param);
|
|
// 如果流程未结束，直接删除，不牵扯到联动调整
|
if (!InoutConstant.PROGRESS_RECORD.equals(data.getProgress())) {
|
return null;
|
}
|
return null;
|
}
|
|
/**
|
* 异常终止操作 设置异常 为了避免页面数据缓存，需要重新获取最新数据判断
|
*
|
* @param data
|
* @return
|
* @throws Exception
|
*/
|
@Transactional
|
public String errorInoutData(InoutData data){
|
|
InoutParam param = new InoutParam();
|
param.setCompanyId(data.getCompanyId());
|
param.setId(data.getId());
|
param.setMsg(" [" + ContextUtil.getLoginUserCName() + "]执行异常终止，原因："
|
+ data.getRemarks());
|
data = inoutService.inoutQueryById(param);
|
|
if (InoutConstant.RECORD_STATUS_DEL.equals(data.getRecordStatus())) {
|
return "已经删除的数据，不支持异常处理！";
|
}
|
if (InoutConstant.RECORD_STATUS_ERROR.equals(data.getRecordStatus())) {
|
return "不支持重复异常处理！";
|
}
|
if (InoutConstant.PROGRESS_RECORD.equals(data.getProgress())) {
|
return "流程结束的数据不支持异常处理！";
|
}
|
|
return inoutService.inoutStop(param);
|
}
|
|
/**
|
* 快速结束操作 流程没有结束的单据进行结束
|
*
|
* @param data
|
* @return
|
*/
|
public String completeInoutData(InoutData data) throws Exception {
|
if (InoutConstant.RECORD_STATUS_DEL.equals(data.getRecordStatus())) {
|
return "已经删除的数据，不支持完成！";
|
}
|
if (InoutConstant.RECORD_STATUS_ERROR.equals(data.getRecordStatus())) {
|
return "异常终止的数据，不支持完成！";
|
}
|
if (InoutConstant.PROGRESS_RECORD.equals(data.getProgress())) {
|
return "流程已完成的数据，不支持完成！";
|
}
|
|
// 从新查询数据
|
InoutParam param = new InoutParam();
|
param.setId(data.getId());
|
param.setCompanyId(data.getCompanyId());
|
param.setType(data.getType());
|
InoutData cuData = inoutService.inoutProgressQuery(param);
|
if (null == cuData) {
|
return "当前车辆流程状态已经变化，请刷新页面重新操作！";
|
}
|
if (!cuData.getProgress().equals(data.getProgress())) {
|
return "当前车辆流程状态已经变化，请刷新页面重新操作！";
|
}
|
|
if (null == data.getCompleteTime()) {
|
return "请填写完成时间！！";
|
}
|
if (StringUtils.isEmpty(data.getDepotId())) {
|
return "请填写仓库信息！";
|
}
|
if (StringUtils.isEmpty(data.getCustomerId())) {
|
return "请填写往来单位信息！";
|
}
|
if (StringUtils.isEmpty(data.getFoodYear())) {
|
return "请填写粮食年份信息！";
|
}
|
if (StringUtils.isEmpty(data.getFoodVariety())) {
|
return "请填写粮食品种信息！";
|
}
|
|
if (data.getSettleWeight() <= 0) {
|
return "请填写结算净重信息！";
|
}
|
|
String msg = inoutService.quickComplete(data);
|
|
if (null == msg) {
|
data.setProgress(InoutConstant.PROGRESS_RECORD);
|
commonService.initInoutDepotStore(data);
|
}
|
return msg;
|
}
|
|
public void initLpr(InoutConf conf) {
|
inoutDeviceManager.initLpr(conf);
|
}
|
|
/**
|
* 获取出入库设备配置信息
|
*
|
* @param companyId
|
* @param deptId
|
* @return
|
*/
|
public List<InoutConf> getListInoutConf(String companyId, String deptId) {
|
return inoutManagerService.getCacheInoutConf(companyId, deptId);
|
}
|
|
/**
|
* 操作道闸设备
|
* @param param
|
* @return
|
*/
|
public PageResponse<List<CheckItemData>> gateCtrl(InoutGateDto param){
|
|
return new PageResponse<>(RespCodeEnum.CODE_0000.getCode(), "", null);
|
}
|
}
|
