package com.ld.igds.inout.service.impl;
|
|
import com.bstek.dorado.data.entity.EntityUtils;
|
import com.ld.igds.common.CoreCommonService;
|
import com.ld.igds.constant.BizType;
|
import com.ld.igds.constant.Constant;
|
import com.ld.igds.constant.RedisConst;
|
import com.ld.igds.data.CommonData;
|
import com.ld.igds.data.Page;
|
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.mapper.InoutCheckMapper;
|
import com.ld.igds.inout.mapper.InoutRecordMapper;
|
import com.ld.igds.inout.service.InoutService;
|
import com.ld.igds.models.Depot;
|
import com.ld.igds.models.InoutPrice;
|
import com.ld.igds.util.ContextUtil;
|
import com.ld.igds.util.DateUtil;
|
import com.ld.igds.util.RedisUtil;
|
import com.ld.igds.websocket.WebSocketServer;
|
import lombok.extern.slf4j.Slf4j;
|
import org.apache.commons.lang3.StringUtils;
|
import org.apache.commons.lang3.time.DateFormatUtils;
|
import org.springframework.beans.BeanUtils;
|
import org.springframework.stereotype.Component;
|
|
import javax.annotation.Resource;
|
import java.util.*;
|
import java.util.concurrent.ExecutorService;
|
import java.util.concurrent.Executors;
|
import java.util.concurrent.FutureTask;
|
|
@Slf4j
|
@Component
|
public class InoutServiceImpl implements InoutService {
|
|
@Resource
|
private InoutRecordMapper inoutMapper;
|
@Resource
|
private InoutCheckMapper inoutCheckMapper;
|
@Resource
|
private RedisUtil redisUtil;
|
@Resource
|
private CoreCommonService commonService;
|
|
@Override
|
public InoutData inoutProgressQuery(InoutParam param) throws Exception {
|
if (StringUtils.isEmpty(param.getCompanyId())) {
|
param.setCompanyId(ContextUtil.getCompanyId());
|
}
|
|
// 首先从缓存中获取，如果没有则从数据库获取
|
InoutData result = this.getFromInoutCache(param);
|
if (null != result) {
|
return result;
|
}
|
|
|
List<InoutData> list = inoutMapper.inoutProgressQuery(param);
|
if (null == list || list.size() == 0)
|
return null;
|
if (list.size() == 1) {
|
return list.get(0);
|
} else {
|
throw new Exception("当前条件下存在多个满足条件的数据，请核查！！");
|
}
|
}
|
|
@Override
|
public InoutData inoutQueryById(InoutParam param) {
|
if (StringUtils.isEmpty(param.getCompanyId())) {
|
param.setCompanyId(ContextUtil.getCompanyId());
|
}
|
if (null == param.getId())
|
return null;
|
|
// 首先从缓存中获取，如果没有则从数据库获取
|
InoutData result = this.getFromInoutCache(param);
|
|
if (null != result) {
|
return result;
|
}
|
|
result = inoutMapper.inoutQueryById(param);
|
|
return result;
|
}
|
|
@Override
|
public String deleteData(InoutParam param) throws Exception {
|
if (StringUtils.isEmpty(param.getCompanyId())) {
|
param.setCompanyId(ContextUtil.getCompanyId());
|
}
|
if (StringUtils.isEmpty(param.getId())) {
|
return "没有获取到被删除数据的ID，无法删除！";
|
}
|
|
inoutMapper.deleteData(param);
|
|
delFromCache(param.getDeptId(), param.getType(), param.getId());
|
|
return null;
|
}
|
|
@Override
|
public String inoutStop(InoutParam param) {
|
if (StringUtils.isEmpty(param.getCompanyId())) {
|
param.setCompanyId(ContextUtil.getCompanyId());
|
}
|
|
// 缓存中删除
|
delFromCache(param.getDeptId(), param.getType(), param.getId());
|
|
param.setProgress(InoutConstant.PROGRESS_RECORD);
|
param.setRecordStatus(InoutConstant.RECORD_STATUS_ERROR);
|
|
inoutMapper.inoutStop(param);
|
|
return null;
|
}
|
|
@Override
|
public String insertData(InoutData data) {
|
try {
|
data.setUpdateTime(new Date());
|
|
if (null == data.getDeptId()) {
|
data.setDeptId(ContextUtil.subDeptId(null));
|
}
|
|
String id = this.createId(data.getRegisterTime(), data.getCompanyId());
|
if (StringUtils.isEmpty(data.getId())) {
|
if (InoutConstant.TYPE_IN.equals(data.getType())) {
|
data.setId("R_" + id);
|
} else if (InoutConstant.TYPE_OUT.equals(data.getType())) {
|
data.setId("C_" + id);
|
} else if (Constant.LOSS_OVER_OVER.equals(data.getType())) {
|
data.setId("R_" + id);
|
} else if (Constant.LOSS_OVER_LOSS.equals(data.getType())) {
|
data.setId("C_" + id);
|
} else {
|
data.setId("M_" + id);
|
}
|
}
|
if (StringUtils.isEmpty(data.getCheckId())) {
|
data.setCheckId(id);
|
}
|
|
if (null == data.getUserName()) {
|
data.setUserName("");
|
}
|
|
inoutMapper.insertData(data);
|
|
updateInoutCache(data);
|
|
} catch (Exception e) {
|
log.error("------------出入库执行保存出错---{}", e);
|
return "后台异常：" + e.getMessage();
|
}
|
|
return null;
|
}
|
|
|
@Override
|
public String updateData(InoutData data) throws Exception {
|
|
data.setUpdateTime(new Date());
|
if (StringUtils.isEmpty(data.getCompanyId())) {
|
data.setCompanyId(ContextUtil.getCompanyId());
|
}
|
InoutData newData;
|
if (EntityUtils.isEntity(data)) {
|
newData = new InoutData();
|
BeanUtils.copyProperties(data, newData, new String[]{"checkItems", "files"});
|
} else {
|
newData = data;
|
}
|
|
inoutMapper.updateData(newData);
|
|
//更新缓存
|
updateInoutCache(newData);
|
|
return null;
|
}
|
|
@Override
|
public String updateDataByHandle(InoutData data) {
|
data.setUpdateTime(new Date());
|
|
if (StringUtils.isEmpty(data.getCompanyId())) {
|
data.setCompanyId(ContextUtil.getCompanyId());
|
}
|
InoutData newData;
|
if (EntityUtils.isEntity(data)) {
|
newData = new InoutData();
|
BeanUtils.copyProperties(data, newData, new String[]{"checkItems", "files"});
|
} else {
|
newData = data;
|
}
|
|
inoutMapper.updateDataByHandle(newData);
|
|
//更新缓存
|
updateInoutCache(newData);
|
|
return null;
|
}
|
|
@Override
|
public Page<InoutData> pageRecordData(InoutParam param) {
|
|
if (StringUtils.isEmpty(param.getCompanyId())) {
|
param.setCompanyId(ContextUtil.getCompanyId());
|
}
|
Page<InoutData> page = new Page<>(param.getPage(), param.getLimit());
|
page.setSearchCount(true);
|
|
if (null != param.getStart()) {
|
param.setStart(DateUtil.getCurZero(param.getStart()));
|
}
|
|
if (null != param.getEnd()) {
|
param.setEnd(DateUtil.getNextZero(param.getEnd()));
|
}
|
|
// 设置车牌的模糊查询条件
|
if (null != param.getPlateNum()) {
|
param.setPlateNum("%" + param.getPlateNum() + "%");
|
}
|
|
// 设置身份证号的模糊查询条件
|
if (null != param.getUserId()) {
|
param.setUserId("%" + param.getUserId() + "%");
|
}
|
|
List<InoutData> records = inoutMapper.pageRecordData(page, param);
|
//判断入库重量是否为空，为空则赋值结算重量
|
if (records != null) {
|
for (InoutData record : records) {
|
if (record.getRecordWeight() == null || record.getRecordWeight() == 0.0) {
|
record.setRecordWeight(record.getSettleWeight());
|
}
|
}
|
}
|
page.setRecords(records);
|
|
return page;
|
}
|
|
@Override
|
public List<InoutData> listRecordData(InoutParam param) {
|
if (StringUtils.isEmpty(param.getCompanyId())) {
|
param.setCompanyId(ContextUtil.getCompanyId());
|
}
|
List<InoutData> records = inoutMapper.listRecordData(param);
|
|
return records;
|
}
|
|
@Override
|
public String validate(String intelCard, String plateNum) {
|
InoutParam param = new InoutParam();
|
param.setCompanyId(ContextUtil.getCompanyId());
|
param.setIntelCard(intelCard);
|
param.setPlateNum(plateNum);
|
|
int i = inoutMapper.validateInoutData(param);
|
|
if (i > 0) {
|
return "当前卡或者车辆出入库未完成！";
|
}
|
return null;
|
}
|
|
@Override
|
public String toComplete(InoutParam param) throws Exception {
|
|
param.setUpdateTime(new Date());
|
|
if (null == param.getCompanyId()) {
|
param.setCompanyId(ContextUtil.getDefaultCompanyId());
|
}
|
|
// 清除缓存
|
this.delFromCache(param.getDeptId(), param.getType(), param.getId());
|
|
|
inoutMapper.toComplete(param);
|
|
return null;
|
}
|
|
@Override
|
public String quickComplete(InoutData data) throws Exception {
|
if (null == data.getCompanyId()) {
|
data.setCompanyId(ContextUtil.getCompanyId());
|
}
|
if (null == data.getCompleteTime()) {
|
data.setCompleteTime(new Date());
|
}
|
if (null == data.getCompleteTime()) {
|
data.setCompleteTime(new Date());
|
}
|
if (null == data.getEmptyWeightTime()) {
|
data.setEmptyWeightTime(new Date());
|
}
|
|
|
//调整时间差
|
if (InoutConstant.TYPE_IN.equals(data.getType())) {
|
|
if (data.getFullWeightTime().after(data.getEmptyWeightTime()))
|
data.setFullWeightTime(DateUtil.getNewByMinute(data.getEmptyWeightTime(), -50));
|
|
if (data.getCompleteTime().before(data.getEmptyWeightTime()))
|
data.setCompleteTime(DateUtil.getNewByMinute(data.getEmptyWeightTime(), 5));
|
}
|
|
//调整时间差
|
if (InoutConstant.TYPE_OUT.equals(data.getType())) {
|
|
if (data.getEmptyWeightTime().after(data.getFullWeightTime()))
|
data.setEmptyWeightTime(DateUtil.getNewByMinute(data.getFullWeightTime(), -50));
|
|
if (data.getCompleteTime().before(data.getFullWeightTime()))
|
data.setCompleteTime(DateUtil.getNewByMinute(data.getFullWeightTime(), 10));
|
}
|
|
|
if (InoutConstant.STATUS_NONE.equals(data.getCheckStatus())) {
|
data.setCheckStatus(InoutConstant.STATUS_PASS);
|
}
|
// 设置流程结束
|
data.setProgress(InoutConstant.PROGRESS_RECORD);
|
|
|
if (null == data.getFoodType()) {
|
// 根据仓库信息获取缓存
|
Depot depot = commonService.getCacheDepot(data.getCompanyId(), data.getDepotId());
|
data.setFoodType(depot.getFoodType());
|
}
|
|
inoutMapper.updateData(data);
|
|
updateInoutCache(data);
|
|
return null;
|
}
|
|
@Override
|
public void updateInoutCache(InoutData data) {
|
|
data.setFiles(null);
|
data.setCheckItems(null);
|
|
if (InoutConstant.PROGRESS_RECORD.equals(data.getProgress())) {
|
|
delFromCache(data.getDeptId(), data.getType(), data.getId());
|
|
setCompleteInoutCache(data.getDeptId(), data);
|
|
} else {
|
setInoutCache(data.getDeptId(), data);
|
}
|
|
|
}
|
|
|
public void delFromCache(String deptId, String type, String id) {
|
if (StringUtils.isEmpty(deptId)) {
|
return;
|
}
|
if (StringUtils.isEmpty(type)) {
|
return;
|
}
|
if (StringUtils.isEmpty(id)) {
|
return;
|
}
|
//从未完成列表中删除
|
String key = this.buildInoutKey(deptId, InoutConstant.KEY_INOUT_LIST, type, id);
|
redisUtil.del(key);
|
}
|
|
@Override
|
public List<InoutData> getListInoutCache(String deptId) {
|
|
String pattern = RedisConst.buildKey(deptId, InoutConstant.KEY_INOUT_LIST);
|
Set<String> keys = redisUtil.keys(pattern);
|
if (null == keys || keys.isEmpty()) {
|
return null;
|
}
|
List<InoutData> list = new ArrayList<>();
|
for (String key : keys) {
|
list.add((InoutData) redisUtil.get(key));
|
}
|
return list;
|
}
|
|
@Override
|
public List<InoutData> getCompleteListInoutCache(String deptId) {
|
String pattern = RedisConst.buildKey(deptId, InoutConstant.KEY_INOUT_COMPLETE_LIST);
|
Set<String> keys = redisUtil.keys(pattern);
|
|
if (null == keys || keys.isEmpty()) {
|
return null;
|
}
|
List<InoutData> list = new ArrayList<>();
|
for (String key : keys) {
|
list.add((InoutData) redisUtil.get(key));
|
}
|
return list;
|
}
|
|
@Override
|
public InoutData getFromInoutCache(InoutParam param) {
|
if (StringUtils.isEmpty(param.getDeptId())) {
|
param.setDeptId(ContextUtil.subDeptId(null));
|
}
|
|
List<InoutData> list = getListInoutCache(param.getDeptId());
|
if (null == list || list.isEmpty())
|
return null;
|
|
String intelCard = param.getIntelCard(), plateNum = param.getPlateNum(),
|
id = param.getId(), userId = param.getUserId();
|
|
for (InoutData data : list) {
|
|
if (StringUtils.isNotEmpty(id) && data.getId().equals(id)) {
|
return data;
|
}
|
if (StringUtils.isNotEmpty(intelCard) && data.getIntelCard().equals(intelCard)) {
|
return data;
|
}
|
if (StringUtils.isNotEmpty(plateNum) && data.getPlateNum().equals(plateNum)) {
|
return data;
|
}
|
if (StringUtils.isNotEmpty(userId) && data.getUserId().equals(userId)) {
|
return data;
|
}
|
}
|
return null;
|
}
|
|
@Override
|
public Page<InoutData> pageUnCompleteData(InoutParam param) {
|
|
if (StringUtils.isEmpty(param.getCompanyId())) {
|
param.setCompanyId(ContextUtil.getCompanyId());
|
}
|
Page<InoutData> page = new Page<InoutData>(param.getPage(), param.getLimit());
|
page.setSearchCount(true);
|
|
if (null != param.getStart()) {
|
param.setStart(DateUtil.getCurZero(param.getStart()));
|
}
|
|
if (null != param.getEnd()) {
|
param.setEnd(DateUtil.getNextZero(param.getEnd()));
|
}
|
// 设置单据号模糊查询
|
if (null != param.getId()) {
|
param.setId("%" + param.getId() + "%");
|
}
|
|
// 设置往来单位名称的模糊查询条件
|
if (StringUtils.isNotEmpty(param.getCustomerName())) {
|
param.setCustomerName("%" + param.getCustomerName() + "%");
|
}
|
|
List<InoutData> records = inoutMapper.pageUnCompleteData(page, param);
|
page.setRecords(records);
|
|
return page;
|
}
|
|
@Override
|
public InoutData getLastRecord(InoutParam param) {
|
return inoutMapper.getLastRecord(param);
|
}
|
|
@Override
|
public String addInoutDataByLossOver(InoutData data) {
|
|
// 获取上一车的流水数据
|
// InoutData inoutData = this.getLastRecord(data.getCompanyId(), data.getDepotId());
|
|
// // 设置流水的库存
|
// if (InoutConstant.TYPE_IN.equals(inoutData.getType())) {
|
// data.setCurStorage(inoutData.getCurStorage()
|
// + inoutData.getSettleWeight());
|
// } else if (InoutConstant.TYPE_OUT.equals(inoutData.getType())) {
|
// data.setCurStorage(inoutData.getCurStorage()
|
// - inoutData.getSettleWeight());
|
// }
|
|
// 添加补单数据
|
this.insertData(data);
|
|
return data.getId();
|
}
|
|
@Override
|
public void delInoutDataByLossOver(InoutParam param) {
|
inoutMapper.deleteData(param);
|
}
|
|
@Override
|
public void setCheckCache(InoutData data) {
|
|
String cacheKey = RedisConst.buildKey(data.getCompanyId(), data.getCheckId());
|
|
//化验结果存入缓存3天
|
redisUtil.set(cacheKey, data.getCheckItems(), 60 * 60 * 24 * 3);
|
}
|
|
|
/**
|
* 出入库流程ID创建 202001030001 202001030001
|
*
|
* @param registerTime 登记时间，和组织编码
|
* @return
|
*/
|
@Override
|
public String createId(Date registerTime, String companyId) {
|
|
// 时间戳标签
|
String timeKey = DateFormatUtils.format(registerTime, "yyyyMMdd");
|
|
// 从缓存中获取已有的组织编码
|
String cacheKey = RedisConst.buildKey(companyId,
|
InoutConstant.CACHE_RECORD_ID);
|
|
String cacheId = (String) redisUtil.get(cacheKey);
|
|
if (null != cacheId && cacheId.indexOf(timeKey) >= 0) {
|
String temp = cacheId.substring(cacheId.length() - 4);
|
Integer i = Integer.valueOf(temp);
|
i++;
|
temp = String.valueOf(i);
|
if (temp.length() == 1) {
|
cacheId = timeKey + "000" + temp;
|
}
|
if (temp.length() == 2) {
|
cacheId = timeKey + "00" + temp;
|
}
|
if (temp.length() == 3) {
|
cacheId = timeKey + "0" + temp;
|
}
|
if (temp.length() == 4) {
|
cacheId = timeKey + temp;
|
}
|
} else {
|
Map<String, Object> result = inoutMapper.getMaxId("%_" + timeKey
|
+ "%", companyId);
|
|
if (null == result) {
|
cacheId = timeKey + "0001";
|
} else {
|
String temp = (String) result.get("maxId");
|
// 获取最后四位
|
int i = Integer.valueOf(temp.substring(temp.length() - 4));
|
i++;
|
temp = String.valueOf(i);
|
if (temp.length() == 1) {
|
cacheId = timeKey + "000" + temp;
|
}
|
if (temp.length() == 2) {
|
cacheId = timeKey + "00" + temp;
|
}
|
if (temp.length() == 3) {
|
cacheId = timeKey + "0" + temp;
|
}
|
if (temp.length() == 4) {
|
cacheId = timeKey + temp;
|
}
|
}
|
}
|
|
// 更新缓存
|
redisUtil.set(cacheKey, cacheId);
|
|
return cacheId;
|
}
|
|
@Override
|
public double sumRecordWeight(InoutParam param) {
|
CommonData result = inoutMapper.sumRecordWeight(param);
|
return result.getNumValue1();
|
}
|
|
@Override
|
public int checkExist(InoutParam param) {
|
return inoutMapper.checkExist(param);
|
}
|
|
/**
|
* 未完成流程存入缓存
|
*
|
* @param deptId
|
* @param data
|
*/
|
private void setInoutCache(String deptId, InoutData data) {
|
String key = this.buildInoutKey(deptId, InoutConstant.KEY_INOUT_LIST, data.getType(), data.getId());
|
redisUtil.set(key, data, InoutConstant.KEY_INOUT_LIST_TIME);
|
}
|
|
/**
|
* 设置完成的流水存入缓存
|
*
|
* @param deptId
|
* @param data
|
*/
|
private void setCompleteInoutCache(String deptId, InoutData data) {
|
String key = this.buildInoutKey(deptId, InoutConstant.KEY_INOUT_COMPLETE_LIST, data.getType(), data.getId());
|
//设置缓存到第二天凌晨(计算当前时间到第二天凌晨的时间差秒数)
|
redisUtil.set(key, data, DateUtil.getNowToNextDaySeconds());
|
}
|
|
/**
|
* 推送到大屏，判断只有当大屏在线时候才处理当前逻辑，避免页面卡顿，调用子任务完成推送
|
*
|
* @param companyId 组织编号
|
* @param deptId 分库编号
|
* @param progress 流转节点
|
*/
|
public void notifyToScreen(String companyId, String deptId, String progress) {
|
|
// 推送到大屏
|
List<InoutData> curList = this.getListInoutCache(deptId);
|
|
List<InoutData> completeList = this.getCompleteListInoutCache(deptId);
|
|
|
if (null == WebSocketServer.contextOnLineMap.get(BizType.SCREEN
|
.getCode())) {
|
WebSocketServer.contextOnLineMap.put(BizType.SCREEN.getCode(),
|
false);
|
}
|
if (null == WebSocketServer.contextOnLineMap.get(BizType.SCREEN_INOUT
|
.getCode())) {
|
WebSocketServer.contextOnLineMap.put(
|
BizType.SCREEN_INOUT.getCode(), false);
|
}
|
if (null == WebSocketServer.contextOnLineMap.get(BizType.SCREEN_CHECK
|
.getCode())) {
|
WebSocketServer.contextOnLineMap.put(
|
BizType.SCREEN_CHECK.getCode(), false);
|
}
|
|
if (WebSocketServer.contextOnLineMap.get(BizType.SCREEN.getCode())
|
|| WebSocketServer.contextOnLineMap.get(BizType.SCREEN_INOUT
|
.getCode())
|
|| WebSocketServer.contextOnLineMap.get(BizType.SCREEN_CHECK
|
.getCode())) {
|
|
|
// 创建一个子任务进行推送信息
|
FutureTask<String> futureTask = new FutureTask<>(new NotifyScreenTask(curList, completeList, deptId));
|
|
ExecutorService executorService = Executors.newCachedThreadPool();
|
executorService.submit(futureTask);
|
executorService.shutdown();
|
}
|
}
|
|
/**
|
* 创建出入库key
|
*
|
* @param deptId
|
* @param key
|
* @param type
|
* @param bizId
|
* @return
|
*/
|
public String buildInoutKey(String deptId, String key, String type, String bizId) {
|
return Constant.APP_NAME + ":" + deptId + ":" + key + ":" + type + ":" + bizId;
|
}
|
|
@Override
|
public Page<InoutCheckData> pageSampleData(InoutCheckParam param) {
|
|
//设置起始和截止时间
|
if (null != param.getStart()) {
|
param.setStart(DateUtil.getCurZero(param.getStart()));
|
}
|
if (null != param.getEnd()) {
|
param.setEnd(DateUtil.getNextZero(param.getEnd()));
|
}
|
|
// 设置车牌和检验单据的模糊查询
|
if (StringUtils.isNotEmpty(param.getPlateNum())) {
|
param.setPlateNum("%" + param.getPlateNum() + "%");
|
}
|
if (StringUtils.isNotEmpty(param.getCheckId())) {
|
param.setCheckId("%" + param.getCheckId() + "%");
|
}
|
|
Page<InoutCheckData> page = new Page<>(param.getPage(), param.getLimit());
|
page.setSearchCount(true);
|
|
List<InoutCheckData> records = inoutCheckMapper.pageSampleData(page, param);
|
page.setRecords(records);
|
|
return page;
|
}
|
|
@Override
|
public String updateSampleData(InoutCheckData data) {
|
if (StringUtils.isEmpty(data.getCompanyId())) {
|
data.setCompanyId(ContextUtil.getCompanyId());
|
}
|
if (StringUtils.isEmpty(data.getDeptId())) {
|
data.setCompanyId(ContextUtil.subDeptId(null));
|
}
|
|
int num = inoutCheckMapper.updateSampleData(data);
|
|
return null;
|
}
|
|
@Override
|
public Page<InoutCheckData> pageCheckData(InoutCheckParam param) {
|
|
//设置起始和截止时间
|
if (null != param.getStart()) {
|
param.setStart(DateUtil.getCurZero(param.getStart()));
|
}
|
if (null != param.getEnd()) {
|
param.setEnd(DateUtil.getNextZero(param.getEnd()));
|
}
|
|
// 设置检验单据的模糊查询
|
if (StringUtils.isNotEmpty(param.getCheckId())) {
|
param.setCheckId("%" + param.getCheckId() + "%");
|
}
|
|
Page<InoutCheckData> page = new Page<>(param.getPage(), param.getLimit());
|
page.setSearchCount(true);
|
|
List<InoutCheckData> records = inoutCheckMapper.pageCheckData(page, param);
|
page.setRecords(records);
|
|
return page;
|
}
|
|
@Override
|
public String updateCheckData(InoutData data) {
|
data.setUpdateTime(new Date());
|
int num = inoutCheckMapper.updateCheckData(data);
|
|
//更新缓存
|
updateInoutCache(data);
|
|
return null;
|
}
|
|
@Override
|
public List<InoutPrice> getPrice(InoutCheckParam param) {
|
if (null == param.getStart()) {
|
param.setStart(new Date());
|
}
|
if (null == param.getEnd()) {
|
param.setEnd(new Date());
|
}
|
return inoutCheckMapper.getPrice(param);
|
}
|
}
|
