package com.gkhy.safePlatform.equipment.service.impl;
|
|
import cn.hutool.core.util.IdUtil;
|
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
|
import com.gkhy.safePlatform.account.rpc.apimodel.AccountUserService;
|
import com.gkhy.safePlatform.account.rpc.apimodel.model.resp.UserInfoRPCRespDTO;
|
import com.gkhy.safePlatform.commons.co.ContextCacheUser;
|
import com.gkhy.safePlatform.commons.enums.ResultCodes;
|
import com.gkhy.safePlatform.commons.exception.BusinessException;
|
import com.gkhy.safePlatform.commons.query.PageQuery;
|
import com.gkhy.safePlatform.commons.utils.StringUtils;
|
import com.gkhy.safePlatform.commons.vo.ResultVO;
|
import com.gkhy.safePlatform.commons.vo.SearchResultVO;
|
import com.gkhy.safePlatform.equipment.entity.*;
|
import com.gkhy.safePlatform.equipment.enums.*;
|
import com.gkhy.safePlatform.equipment.excepiton.EquipmentException;
|
import com.gkhy.safePlatform.equipment.model.dto.req.*;
|
import com.gkhy.safePlatform.equipment.model.dto.req.db.SafeMaterialDetailDBQuery;
|
import com.gkhy.safePlatform.equipment.model.dto.resp.SafeMaterialClassifyStockDto;
|
import com.gkhy.safePlatform.equipment.model.dto.resp.SafeMaterialDetailDto;
|
import com.gkhy.safePlatform.equipment.model.dto.resp.SafeRfidMaterialDetailDto;
|
import com.gkhy.safePlatform.equipment.service.SafeMaterialDetailService;
|
import com.gkhy.safePlatform.equipment.service.baseService.*;
|
import org.apache.dubbo.config.annotation.DubboReference;
|
import org.redisson.api.RLock;
|
import org.redisson.api.RedissonClient;
|
import org.springframework.beans.BeanUtils;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.springframework.util.CollectionUtils;
|
|
import java.time.LocalDateTime;
|
import java.time.ZoneId;
|
import java.time.ZonedDateTime;
|
import java.util.*;
|
import java.util.concurrent.TimeUnit;
|
import java.util.stream.Collectors;
|
|
@Service("SafeMaterialDetailService")
|
public class SafeMaterialDetailServiceImpl implements SafeMaterialDetailService {
|
@Autowired
|
private SafeMaterialInfoService safeMaterialInfoService;
|
@Autowired
|
private SafeMaterialDetailInfoService safeMaterialDetailInfoService;
|
|
@Autowired
|
private SafeMaterialClassifyInfoService safeMaterialClassifyInfoService;
|
|
@DubboReference(check = false)
|
private AccountUserService accountUserService;
|
|
@Autowired
|
private RedissonClient redissonClient;
|
|
@Autowired
|
private MaterialReceiveRecordsBaseInfoService materialReceiveRecordsBaseInfoService;
|
|
@Autowired
|
private MaterialReceiveRecordsInfoService materialReceiveRecordsInfoService;
|
|
|
@Override
|
@Transactional
|
public ResultVO save(SafeMaterialDetailAddReq req) {
|
//判断物资是否存在
|
SafeMaterialDO safeMaterialDO = safeMaterialInfoService.queryById(req.getSmId());
|
if(null == safeMaterialDO){
|
throw new EquipmentException(EquipmentResultCodes.DATA_NOT_EXIST,"该种物资不存在！");
|
}
|
if(null == ValidTypeEnum.getByCode(req.getValidType())){
|
throw new EquipmentException(ResultCodes.CLIENT_PARAM_ILLEGAL,"有效期类型不合法！");
|
}
|
if(req.getValidType().equals(ValidTypeEnum.SHORT_TERM.getCode()) && null == req.getValidTime()){
|
throw new EquipmentException(ResultCodes.CLIENT_PARAM_NULL,"有效期时间不可为空！");
|
}
|
//获取数据量
|
Integer totalCount = safeMaterialDetailInfoService.getTotalCount();
|
List<SafeMaterialDetailInfo> list = new ArrayList<>();
|
|
//RFID起始不为空计算一下
|
if(StringUtils.isNotBlank(req.getStartRfid()) && StringUtils.isNotBlank(req.getEndRfid())){
|
int start = 0;
|
int end = 0;
|
String prefix = "";
|
try{
|
prefix = req.getStartRfid().substring(0,req.getStartRfid().length()-8);
|
start = Integer.parseInt(req.getStartRfid().substring(req.getStartRfid().length()-8));
|
end = Integer.parseInt(req.getEndRfid().substring(req.getEndRfid().length()-8));
|
}catch (Exception e){
|
throw new EquipmentException(ResultCodes.CLIENT_PARAM_ILLEGAL,"起始RFID不合法！");
|
}
|
if((end-start+1) != req.getWareHousingCount()){
|
throw new EquipmentException(ResultCodes.CLIENT_PARAM_ILLEGAL,"RFID起始和入库数量不能对应！");
|
}
|
for(int i = 0;i < req.getWareHousingCount();i++){
|
String countStr = String.valueOf(start+i);
|
String rfid = "0000000".substring(0,(8 - countStr.length()))+countStr;
|
SafeMaterialDetailInfo materialDetailInfo = new SafeMaterialDetailInfo();
|
materialDetailInfo.setId(IdUtil.getSnowflake(0,0).nextId());
|
materialDetailInfo.setBigClassifyId(safeMaterialDO.getBigClassifyId());
|
materialDetailInfo.setSmallClassifyId(safeMaterialDO.getSmallClassifyId());
|
materialDetailInfo.setName(safeMaterialDO.getMaterialName());
|
materialDetailInfo.setSmId(req.getSmId());
|
materialDetailInfo.setConsumable(safeMaterialDO.getConsumable());
|
materialDetailInfo.setStatus(MaterialStatusEnum.INTACT.getCode());
|
materialDetailInfo.setRemark(MaterialStatusEnum.INTACT.getValue());
|
materialDetailInfo.setValidType(req.getValidType());
|
if(req.getValidType().equals(ValidTypeEnum.SHORT_TERM.getCode())){
|
materialDetailInfo.setValidTime(req.getValidTime());
|
}
|
materialDetailInfo.setValidStatus(ValidStatusEnum.YES.getCode());
|
materialDetailInfo.setIrStatus(IssueReceiptEnum.IN_THE_LIBRARY.getCode());
|
materialDetailInfo.setWareHousingTime(LocalDateTime.now());
|
materialDetailInfo.setRfid(prefix+rfid);
|
materialDetailInfo.setMaterialNo(generateMaterialNo(totalCount+i));
|
list.add(materialDetailInfo);
|
}
|
}else{
|
//不分配FRID
|
for(int i = 0;i < req.getWareHousingCount();i++){
|
SafeMaterialDetailInfo materialDetailInfo = new SafeMaterialDetailInfo();
|
materialDetailInfo.setId(IdUtil.getSnowflake(0,0).nextId());
|
materialDetailInfo.setBigClassifyId(safeMaterialDO.getBigClassifyId());
|
materialDetailInfo.setSmallClassifyId(safeMaterialDO.getSmallClassifyId());
|
materialDetailInfo.setName(safeMaterialDO.getMaterialName());
|
materialDetailInfo.setSmId(req.getSmId());
|
materialDetailInfo.setConsumable(safeMaterialDO.getConsumable());
|
materialDetailInfo.setStatus(MaterialStatusEnum.INTACT.getCode());
|
materialDetailInfo.setRemark(MaterialStatusEnum.INTACT.getValue());
|
materialDetailInfo.setValidType(req.getValidType());
|
if(req.getValidType().equals(ValidTypeEnum.SHORT_TERM.getCode())){
|
materialDetailInfo.setValidTime(req.getValidTime());
|
}
|
materialDetailInfo.setValidStatus(ValidStatusEnum.YES.getCode());
|
materialDetailInfo.setIrStatus(IssueReceiptEnum.IN_THE_LIBRARY.getCode());
|
materialDetailInfo.setWareHousingTime(LocalDateTime.now());
|
materialDetailInfo.setMaterialNo(generateMaterialNo(totalCount+i));
|
list.add(materialDetailInfo);
|
}
|
}
|
//填充物资管理数据
|
SafeMaterialBO safeMaterialBO = new SafeMaterialBO();
|
safeMaterialBO.setId(req.getSmId());
|
safeMaterialBO.setStockCount(req.getWareHousingCount());
|
safeMaterialBO.setTotalCount(req.getWareHousingCount());
|
|
//加分布式锁，防止重复创建规则
|
RLock lock = redissonClient.getLock("LOCK_SMD_SAVE");
|
try {
|
lock.lock(10, TimeUnit.SECONDS);
|
//批量入库
|
safeMaterialDetailInfoService.saveBatch(list);
|
//修改数量
|
safeMaterialInfoService.updateCountById(safeMaterialBO);
|
|
//发送消息
|
/*if(req.getValidType().equals(ValidTypeEnum.SHORT_TERM.getCode()) && null != req.getValidTime()){
|
for(SafeMaterialDetailInfo materialDetailInfo:list){
|
SafeMaterialMsg safeMaterialMsg = new SafeMaterialMsg();
|
safeMaterialMsg.setId(materialDetailInfo.getId());
|
safeMaterialMsg.setValidTime(conversionTimeType(materialDetailInfo.getValidTime()));
|
rocketMQTemplateHelper.syncSend(safeMaterialTopic,safeMaterialMsg);
|
}
|
}*/
|
//创建成功，释放锁
|
lock.unlock();
|
}catch (EquipmentException e) {
|
e.printStackTrace();
|
throw new EquipmentException(e.getCode(), e.getMessage());
|
}catch (Exception e) {
|
e.printStackTrace();
|
throw new BusinessException(ResultCodes.SERVER_ERROR);
|
}finally {
|
if(lock.isLocked()){
|
lock.unlock();
|
}
|
}
|
|
return new ResultVO<>(ResultCodes.OK);
|
}
|
|
/**
|
* 批量入库
|
* @param req
|
* @return
|
*/
|
@Override
|
@Transactional
|
public ResultVO saveBatch(SafeMaterialDetailAddReq req) {
|
//判断物资是否存在
|
SafeMaterialDO safeMaterialDO = safeMaterialInfoService.queryById(req.getSmId());
|
if(null == safeMaterialDO){
|
throw new EquipmentException(EquipmentResultCodes.DATA_NOT_EXIST,"该种物资不存在！");
|
}
|
if(null == ValidTypeEnum.getByCode(req.getValidType())){
|
throw new EquipmentException(ResultCodes.CLIENT_PARAM_ILLEGAL,"有效期类型不合法！");
|
}
|
if(req.getValidType().equals(ValidTypeEnum.SHORT_TERM.getCode()) && null == req.getValidTime()){
|
throw new EquipmentException(ResultCodes.CLIENT_PARAM_NULL,"有效期时间不可为空！");
|
}
|
//获取数据量
|
Integer totalCount = safeMaterialDetailInfoService.getTotalCount();
|
List<SafeMaterialDetailInfo> list = new ArrayList<>();
|
|
for(int i = 0;i < req.getWareHousingCount();i++){
|
SafeMaterialDetailInfo materialDetailInfo = new SafeMaterialDetailInfo();
|
materialDetailInfo.setId(IdUtil.getSnowflake(0,0).nextId());
|
materialDetailInfo.setBigClassifyId(safeMaterialDO.getBigClassifyId());
|
materialDetailInfo.setSmallClassifyId(safeMaterialDO.getSmallClassifyId());
|
materialDetailInfo.setName(safeMaterialDO.getMaterialName());
|
materialDetailInfo.setSmId(req.getSmId());
|
materialDetailInfo.setConsumable(safeMaterialDO.getConsumable());
|
materialDetailInfo.setStatus(MaterialStatusEnum.INTACT.getCode());
|
materialDetailInfo.setRemark(MaterialStatusEnum.INTACT.getValue());
|
materialDetailInfo.setValidType(req.getValidType());
|
if(req.getValidType().equals(ValidTypeEnum.SHORT_TERM.getCode())){
|
materialDetailInfo.setValidTime(req.getValidTime());
|
}
|
materialDetailInfo.setValidStatus(ValidStatusEnum.YES.getCode());
|
materialDetailInfo.setIrStatus(IssueReceiptEnum.IN_THE_LIBRARY.getCode());
|
materialDetailInfo.setWareHousingTime(LocalDateTime.now());
|
materialDetailInfo.setRfid(req.getRfid());
|
materialDetailInfo.setMaterialNo(generateMaterialNo(totalCount+i));
|
list.add(materialDetailInfo);
|
}
|
//填充物资管理数据
|
SafeMaterialBO safeMaterialBO = new SafeMaterialBO();
|
safeMaterialBO.setId(req.getSmId());
|
safeMaterialBO.setStockCount(req.getWareHousingCount());
|
safeMaterialBO.setTotalCount(req.getWareHousingCount());
|
|
//加分布式锁，防止重复创建规则
|
RLock lock = redissonClient.getLock("LOCK_SMD_SAVEBATCH");
|
try {
|
lock.lock(10, TimeUnit.SECONDS);
|
//批量入库
|
safeMaterialDetailInfoService.saveBatch(list);
|
//修改数量
|
safeMaterialInfoService.updateCountById(safeMaterialBO);
|
//创建成功，释放锁
|
lock.unlock();
|
}catch (EquipmentException e) {
|
e.printStackTrace();
|
throw new EquipmentException(e.getCode(), e.getMessage());
|
}catch (Exception e) {
|
e.printStackTrace();
|
throw new BusinessException(ResultCodes.SERVER_ERROR);
|
}finally {
|
if(lock.isLocked()){
|
lock.unlock();
|
}
|
}
|
return new ResultVO<>(ResultCodes.OK);
|
}
|
|
/**
|
* 编辑
|
* @param req
|
* @return
|
*/
|
@Transactional
|
@Override
|
public ResultVO update(SafeMaterialDetailReq req) {
|
//获取该条数据
|
SafeMaterialDetailInfo vo = safeMaterialDetailInfoService.queryById(req.getId());
|
if(null == vo){
|
throw new EquipmentException(EquipmentResultCodes.DATA_NOT_EXIST);
|
}
|
//有效类型不为空
|
if(null != req.getValidType()){
|
if(null == ValidTypeEnum.getByCode(req.getValidType())){
|
throw new EquipmentException(ResultCodes.CLIENT_PARAM_ILLEGAL,"有效期类型不合法！");
|
}else{
|
if(req.getValidType().equals(ValidTypeEnum.SHORT_TERM.getCode()) && null == req.getValidTime()){
|
throw new EquipmentException(ResultCodes.CLIENT_PARAM_NULL,"有效期时间不可为空！");
|
}else{
|
if(req.getValidTime().before(new Date())){
|
throw new EquipmentException(ResultCodes.CLIENT_PARAM_NULL,"有效期时间小于当前时间！");
|
}
|
}
|
}
|
}
|
//填充物资管理数据
|
SafeMaterialBO safeMaterialBO = new SafeMaterialBO();
|
safeMaterialBO.setId(vo.getSmId());
|
safeMaterialBO.setStockCount(0);
|
//填充数据
|
SafeMaterialDetailInfo safeMaterialDetailInfo = new SafeMaterialDetailInfo();
|
safeMaterialDetailInfo.setId(req.getId());
|
safeMaterialDetailInfo.setRfid(req.getRfid());
|
safeMaterialDetailInfo.setSmId(req.getSmId());
|
safeMaterialDetailInfo.setValidType(req.getValidType());
|
safeMaterialDetailInfo.setValidTime(req.getValidTime());
|
if(ValidStatusEnum.NO.getCode().equals(vo.getValidStatus())){
|
//无效情况
|
if(vo.getStatus().equals(MaterialStatusEnum.OVERDUE.getCode())){
|
//过期
|
safeMaterialDetailInfo.setValidStatus(ValidStatusEnum.YES.getCode());
|
safeMaterialDetailInfo.setStatus(MaterialStatusEnum.INTACT.getCode());
|
safeMaterialDetailInfo.setRemark(MaterialStatusEnum.INTACT.getValue());
|
safeMaterialBO.setStockCount(1);
|
}
|
}
|
|
|
//加分布式锁，防止重复创建规则
|
RLock lock = redissonClient.getLock("LOCK_SMD_UPDATE");
|
try {
|
lock.lock(10, TimeUnit.SECONDS);
|
//修改
|
safeMaterialDetailInfoService.updateById(safeMaterialDetailInfo);
|
if(null != safeMaterialBO){
|
safeMaterialInfoService.updateCountById(safeMaterialBO);
|
}
|
//创建成功，释放锁
|
lock.unlock();
|
}catch (EquipmentException e) {
|
e.printStackTrace();
|
throw new EquipmentException(e.getCode(), e.getMessage());
|
}catch (Exception e) {
|
e.printStackTrace();
|
throw new BusinessException(ResultCodes.SERVER_ERROR);
|
}finally {
|
if(lock.isLocked()){
|
lock.unlock();
|
}
|
}
|
return new ResultVO(ResultCodes.OK);
|
}
|
|
/**
|
* 批量-重新入库
|
* @param
|
* @return
|
*/
|
@Override
|
public ResultVO receiptBatch(ParamForm paramForm) {
|
//加分布式锁，防止重复创建规则
|
RLock lock = redissonClient.getLock("LOCK_SMD_RECEIPTBATCH");
|
try {
|
lock.lock(10, TimeUnit.SECONDS);
|
//验证
|
List<SafeMaterialDetailInfo> list = safeMaterialDetailInfoService.getListByIds(paramForm.getIds());
|
List<SafeMaterialDetailInfo> selectList = list
|
.stream()
|
.filter(item -> item.getIrStatus().equals(IssueReceiptEnum.OUT_OF_LIBRARY.getCode()) && item.getConsumable().equals(ConsumableEnum.NO.getCode()))
|
.collect(Collectors.toList());
|
if(selectList.size() != paramForm.getIds().size()){
|
throw new EquipmentException(ResultCodes.CLIENT_PARAM_ILLEGAL,"已入库或耗材物资不可重复入库！");
|
}
|
//修改为入库状态
|
safeMaterialDetailInfoService.updateReceiptStatusByIds(paramForm.getIds(),IssueReceiptEnum.IN_THE_LIBRARY.getCode());
|
//创建成功，释放锁
|
lock.unlock();
|
}catch (EquipmentException e) {
|
e.printStackTrace();
|
throw new EquipmentException(e.getCode(), e.getMessage());
|
}catch (Exception e) {
|
e.printStackTrace();
|
throw new BusinessException(ResultCodes.SERVER_ERROR);
|
}finally {
|
if(lock.isLocked()){
|
lock.unlock();
|
}
|
}
|
return new ResultVO(ResultCodes.OK);
|
}
|
|
/**
|
* 逻辑删除 -批量删除
|
* @param
|
* @return
|
*/
|
@Transactional
|
@Override
|
public ResultVO deleteBatch(ContextCacheUser currentUser,ParamForm paramForm) {
|
//加分布式锁，防止重复创建规则
|
RLock lock = redissonClient.getLock("LOCK_SMD_DELETEBATCH");
|
try {
|
lock.lock(10, TimeUnit.SECONDS);
|
//获取所有物资管理
|
List<SafeMaterialInfo> safeMaterialInfoList = safeMaterialInfoService.listByDepId(currentUser.getDepId());
|
List<Long> idList = paramForm.getIds();
|
List<SafeMaterialDetailInfo> list = safeMaterialDetailInfoService.getListByIds(idList);
|
List<SafeMaterialDetailInfo> collect = list.stream().filter(item -> item.getIrStatus().equals(IssueReceiptEnum.OUT_OF_LIBRARY.getCode())).collect(Collectors.toList());
|
if(collect.size()>0){
|
throw new EquipmentException(ResultCodes.SERVER_DEL_ERROR,"出库物资不可删除！");
|
}
|
List<SafeMaterialBO> safeMaterialBOList = new ArrayList<>();
|
for(SafeMaterialInfo materialInfo:safeMaterialInfoList){
|
List<SafeMaterialDetailInfo> selectList = list.stream().filter(item -> item.getSmId().equals(materialInfo.getId())).collect(Collectors.toList());
|
if(selectList.size()>0){
|
//物资管理
|
SafeMaterialBO safeMaterialBO = new SafeMaterialBO();
|
safeMaterialBO.setId(materialInfo.getId());
|
safeMaterialBO.setStockCount(-selectList.size());
|
safeMaterialBO.setTotalCount(-selectList.size());
|
safeMaterialBOList.add(safeMaterialBO);
|
}
|
}
|
//删除
|
safeMaterialDetailInfoService.deleteBatch(paramForm.getIds());
|
//修改库存
|
safeMaterialInfoService.updateStockCount(safeMaterialBOList);
|
//创建成功，释放锁
|
lock.unlock();
|
}catch (EquipmentException e) {
|
e.printStackTrace();
|
throw new EquipmentException(e.getCode(), e.getMessage());
|
}catch (Exception e) {
|
e.printStackTrace();
|
throw new BusinessException(ResultCodes.SERVER_ERROR);
|
}finally {
|
if(lock.isLocked()){
|
lock.unlock();
|
}
|
}
|
return new ResultVO(ResultCodes.OK);
|
}
|
|
/**
|
* 批量出库 - 根据ids
|
* @param req
|
* @return
|
*/
|
@Transactional
|
@Override
|
public void deliveryBatchByIds(MterialDeliveryReq req,ContextCacheUser currentUser) {
|
//获取认领人信息
|
UserInfoRPCRespDTO userInfo = getUserInfo(req.getReceiveUid());
|
//加分布式锁，防止重复创建规则
|
RLock lock = redissonClient.getLock("LOCK_SMD_DELIVERYBATCHBYIDS");
|
try {
|
lock.lock(10, TimeUnit.SECONDS);
|
//验证
|
List<SafeMaterialDetailInfo> list = safeMaterialDetailInfoService.getListByIds(req.getIds());
|
List<SafeMaterialDetailInfo> selectList = list
|
.stream()
|
.filter(item -> item.getIrStatus().equals(IssueReceiptEnum.IN_THE_LIBRARY.getCode()) && item.getValidStatus().equals(ValidStatusEnum.YES.getCode()))
|
.collect(Collectors.toList());
|
if(selectList.size() != req.getIds().size()){
|
throw new EquipmentException(ResultCodes.CLIENT_PARAM_ILLEGAL,"已出库物资或无效物资，不可出库！");
|
}
|
//获取该部门的所管理物资
|
List<SafeMaterialInfo> safeMaterialInfoList = safeMaterialInfoService.listByDepId(currentUser.getDepId());
|
List<MaterialReceiveRecordsBaseInfo> receiveRecordsBaseInfoList = new ArrayList<>();
|
List<MaterialReceiveRecordsInfo> receiveRecordsInfoList = new ArrayList<>();
|
List<SafeMaterialBO> safeMaterialBOList = new ArrayList<>();
|
List<SafeMaterialDetailInfo> safeMaterialDetailInfoList = new ArrayList<>();
|
//循环
|
for(SafeMaterialInfo safeMaterialInfo:safeMaterialInfoList){
|
List<SafeMaterialDetailInfo> collectList = list.stream().filter(item -> safeMaterialInfo.getId().equals(item.getSmId())).collect(Collectors.toList());
|
if(collectList.size()>0){
|
//物资管理
|
SafeMaterialBO safeMaterialBO = new SafeMaterialBO();
|
safeMaterialBO.setId(safeMaterialInfo.getId());
|
safeMaterialBO.setStockCount(-collectList.size());
|
safeMaterialBOList.add(safeMaterialBO);
|
|
//总记录
|
MaterialReceiveRecordsBaseInfo receiveRecordsBaseInfo = new MaterialReceiveRecordsBaseInfo();
|
receiveRecordsBaseInfo.setId(IdUtil.getSnowflake(0,0).nextId());
|
receiveRecordsBaseInfo.setMaterialName(safeMaterialInfo.getMaterialName());
|
receiveRecordsBaseInfo.setReceiveUid(userInfo.getUid());
|
receiveRecordsBaseInfo.setReceiveUname(userInfo.getUsername());
|
receiveRecordsBaseInfo.setReceiveCount(collectList.size());
|
receiveRecordsBaseInfo.setRevertCount(0);
|
receiveRecordsBaseInfo.setConsumeCount(0);
|
if(ConsumableEnum.YES.getCode().equals(safeMaterialInfo.getConsumable())){
|
receiveRecordsBaseInfo.setStatus(MaterialReceiveRecordsStatusEnum.CONSUMABLE_RETURN_NO.getCode());
|
receiveRecordsBaseInfo.setConsumeCount(0);
|
}else{
|
receiveRecordsBaseInfo.setStatus(MaterialReceiveRecordsStatusEnum.RETURN_NO.getCode());
|
receiveRecordsBaseInfo.setConsumeCount(collectList.size());
|
}
|
receiveRecordsBaseInfo.setSmId(safeMaterialInfo.getId());
|
receiveRecordsBaseInfoList.add(receiveRecordsBaseInfo);
|
//循环详细物资
|
for(SafeMaterialDetailInfo safeMaterialDetailInfo:collectList){
|
//领取物资清单记录
|
MaterialReceiveRecordsInfo materialReceiveRecordsInfo = new MaterialReceiveRecordsInfo();
|
materialReceiveRecordsInfo.setId(IdUtil.getSnowflake(0,0).nextId());
|
materialReceiveRecordsInfo.setMaterialName(safeMaterialDetailInfo.getName());
|
materialReceiveRecordsInfo.setMaterialNo(safeMaterialDetailInfo.getMaterialNo());
|
materialReceiveRecordsInfo.setReceiveBaseId(receiveRecordsBaseInfo.getId());
|
if(ConsumableEnum.YES.getCode().equals(safeMaterialDetailInfo.getConsumable())){
|
materialReceiveRecordsInfo.setRevertStatus(MaterialRevertStatusEnum.DEPLETION.getCode());
|
materialReceiveRecordsInfo.setMaterialStatus(MaterialStatusEnum.OTHER.getCode());
|
materialReceiveRecordsInfo.setRemark("耗材");
|
}else{
|
materialReceiveRecordsInfo.setRevertStatus(MaterialRevertStatusEnum.REVERT_NO.getCode());
|
materialReceiveRecordsInfo.setMaterialStatus(MaterialStatusEnum.INTACT.getCode());
|
materialReceiveRecordsInfo.setRemark(MaterialStatusEnum.INTACT.getValue());
|
}
|
materialReceiveRecordsInfo.setReceiveTime(LocalDateTime.now());
|
materialReceiveRecordsInfo.setReceiveUid(userInfo.getUid());
|
materialReceiveRecordsInfo.setReceiveUname(userInfo.getUsername());
|
materialReceiveRecordsInfo.setSmdId(safeMaterialDetailInfo.getId());
|
materialReceiveRecordsInfo.setRfid(safeMaterialDetailInfo.getRfid());
|
receiveRecordsInfoList.add(materialReceiveRecordsInfo);
|
//物资清单
|
SafeMaterialDetailInfo materialDetailInfo = new SafeMaterialDetailInfo();
|
materialDetailInfo.setId(safeMaterialDetailInfo.getId());
|
materialDetailInfo.setReceiveUid(userInfo.getUid());
|
materialDetailInfo.setReceiveUname(userInfo.getRealName());
|
materialDetailInfo.setIrStatus(IssueReceiptEnum.OUT_OF_LIBRARY.getCode());
|
materialDetailInfo.setDeliveryTime(LocalDateTime.now());
|
if(ConsumableEnum.YES.getCode().equals(safeMaterialDetailInfo.getConsumable())){
|
materialDetailInfo.setValidStatus(ValidStatusEnum.NO.getCode());
|
materialDetailInfo.setStatus(MaterialStatusEnum.OTHER.getCode());
|
materialDetailInfo.setRemark("耗材");
|
}
|
safeMaterialDetailInfoList.add(materialDetailInfo);
|
}
|
|
}
|
|
}
|
//修改物资管理数量
|
safeMaterialInfoService.updateStockCount(safeMaterialBOList);
|
//修改物资清单的状态
|
safeMaterialDetailInfoService.updateBatchById(safeMaterialDetailInfoList);
|
//插入领取总记录
|
materialReceiveRecordsBaseInfoService.saveBatch(receiveRecordsBaseInfoList);
|
//插入领取清单
|
materialReceiveRecordsInfoService.saveBatch(receiveRecordsInfoList);
|
//创建成功，释放锁
|
lock.unlock();
|
}catch (EquipmentException e) {
|
e.printStackTrace();
|
throw new EquipmentException(e.getCode(), e.getMessage());
|
}catch (Exception e) {
|
e.printStackTrace();
|
throw new BusinessException(ResultCodes.SERVER_ERROR);
|
}finally {
|
if(lock.isLocked()){
|
lock.unlock();
|
}
|
}
|
}
|
|
|
|
@Transactional
|
@Override
|
public void deliveryBatchBySmId(MterialRandomDeliveryReq req,ContextCacheUser currentUser) {
|
SafeMaterialDO safeMaterialDO = safeMaterialInfoService.queryById(req.getSmId());
|
if(null == safeMaterialDO){
|
throw new EquipmentException(EquipmentResultCodes.DATA_NOT_EXIST,"物资不存在，无法出库！");
|
}
|
SafeMaterialDetailDBQuery query = new SafeMaterialDetailDBQuery();
|
query.setSmId(safeMaterialDO.getId());
|
query.setCount(req.getCount());
|
query.setRfid(req.getRfid());
|
query.setIrStatus(IssueReceiptEnum.IN_THE_LIBRARY.getCode());
|
query.setValidStatus(ValidStatusEnum.YES.getCode());
|
UserInfoRPCRespDTO userInfo = getUserInfo(req.getReceiveUid());
|
List<SafeMaterialDetailInfo> safeMaterialDetailInfoList = new ArrayList<>();
|
//加分布式锁，防止重复创建规则
|
RLock lock = redissonClient.getLock("LOCK_SMD_DELIVERYBATCHRANDOM");
|
try {
|
lock.lock(10, TimeUnit.SECONDS);
|
//获取有效数量
|
Integer validStockCount = safeMaterialDetailInfoService.getValidStockCount(req.getSmId());
|
if(req.getCount() > validStockCount){
|
throw new EquipmentException(ResultCodes.CLIENT_PARAM_ILLEGAL,"出库数量不可大于有效库存数量！");
|
}
|
if(StringUtils.isNotBlank(req.getRfid())){
|
safeMaterialDetailInfoList = safeMaterialDetailInfoService.getListBySmIdAndRfid(query);
|
}else{
|
safeMaterialDetailInfoList = safeMaterialDetailInfoService.getListBySmId(query);
|
}
|
if(safeMaterialDetailInfoList.size()< req.getCount()){
|
throw new EquipmentException(ResultCodes.CLIENT_PARAM_ILLEGAL,"库存数量不足！");
|
}
|
//物资管理
|
SafeMaterialBO safeMaterialBO = new SafeMaterialBO();
|
safeMaterialBO.setId(req.getSmId());
|
safeMaterialBO.setStockCount(-req.getCount());
|
//领取记录
|
MaterialReceiveRecordsBaseInfo receiveRecordsBaseInfo = new MaterialReceiveRecordsBaseInfo();
|
receiveRecordsBaseInfo.setId(IdUtil.getSnowflake(0,0).nextId());
|
receiveRecordsBaseInfo.setMaterialName(safeMaterialDO.getMaterialName());
|
receiveRecordsBaseInfo.setReceiveUid(userInfo.getUid());
|
receiveRecordsBaseInfo.setReceiveUname(userInfo.getUsername());
|
receiveRecordsBaseInfo.setReceiveCount(req.getCount());
|
receiveRecordsBaseInfo.setRevertCount(0);
|
receiveRecordsBaseInfo.setConsumeCount(0);
|
if(ConsumableEnum.YES.getCode().equals(safeMaterialDO.getConsumable())){
|
receiveRecordsBaseInfo.setStatus(MaterialReceiveRecordsStatusEnum.CONSUMABLE_RETURN_NO.getCode());
|
receiveRecordsBaseInfo.setConsumeCount(req.getCount());
|
}else{
|
receiveRecordsBaseInfo.setStatus(MaterialReceiveRecordsStatusEnum.RETURN_NO.getCode());
|
receiveRecordsBaseInfo.setConsumeCount(0);
|
|
}
|
receiveRecordsBaseInfo.setSmId(safeMaterialDO.getId());
|
//物资领取清单
|
List<MaterialReceiveRecordsInfo> receiveRecordsInfoList = new ArrayList<>();
|
//物资清单
|
List<SafeMaterialDetailInfo> updateDetailList = new ArrayList<>();
|
for(SafeMaterialDetailInfo safeMaterialDetailInfo:safeMaterialDetailInfoList){
|
//领取物资清单记录
|
MaterialReceiveRecordsInfo materialReceiveRecordsInfo = new MaterialReceiveRecordsInfo();
|
materialReceiveRecordsInfo.setId(IdUtil.getSnowflake(0,0).nextId());
|
materialReceiveRecordsInfo.setMaterialName(safeMaterialDetailInfo.getName());
|
materialReceiveRecordsInfo.setMaterialNo(safeMaterialDetailInfo.getMaterialNo());
|
materialReceiveRecordsInfo.setReceiveBaseId(receiveRecordsBaseInfo.getId());
|
if(ConsumableEnum.YES.getCode().equals(safeMaterialDetailInfo.getConsumable())){
|
materialReceiveRecordsInfo.setRevertStatus(MaterialRevertStatusEnum.DEPLETION.getCode());
|
materialReceiveRecordsInfo.setMaterialStatus(MaterialStatusEnum.OTHER.getCode());
|
materialReceiveRecordsInfo.setRemark("耗材");
|
}else{
|
materialReceiveRecordsInfo.setRevertStatus(MaterialRevertStatusEnum.REVERT_NO.getCode());
|
materialReceiveRecordsInfo.setMaterialStatus(MaterialStatusEnum.INTACT.getCode());
|
materialReceiveRecordsInfo.setRemark(MaterialStatusEnum.INTACT.getValue());
|
}
|
materialReceiveRecordsInfo.setReceiveTime(LocalDateTime.now());
|
materialReceiveRecordsInfo.setReceiveUid(userInfo.getUid());
|
materialReceiveRecordsInfo.setReceiveUname(userInfo.getUsername());
|
materialReceiveRecordsInfo.setSmdId(safeMaterialDetailInfo.getId());
|
materialReceiveRecordsInfo.setRfid(safeMaterialDetailInfo.getRfid());
|
receiveRecordsInfoList.add(materialReceiveRecordsInfo);
|
//物资清单
|
SafeMaterialDetailInfo materialDetailInfo = new SafeMaterialDetailInfo();
|
materialDetailInfo.setId(safeMaterialDetailInfo.getId());
|
materialDetailInfo.setReceiveUid(userInfo.getUid());
|
materialDetailInfo.setReceiveUname(userInfo.getRealName());
|
materialDetailInfo.setIrStatus(IssueReceiptEnum.OUT_OF_LIBRARY.getCode());
|
materialDetailInfo.setDeliveryTime(LocalDateTime.now());
|
if(ConsumableEnum.YES.getCode().equals(safeMaterialDetailInfo.getConsumable())){
|
materialDetailInfo.setValidStatus(ValidStatusEnum.NO.getCode());
|
materialDetailInfo.setStatus(MaterialStatusEnum.OTHER.getCode());
|
materialDetailInfo.setRemark("耗材");
|
}
|
updateDetailList.add(materialDetailInfo);
|
}
|
//修改物资清单状态
|
safeMaterialDetailInfoService.updateBatchById(updateDetailList);
|
//修改物资管理库存
|
safeMaterialInfoService.updateCountById(safeMaterialBO);
|
//插入领取总记录
|
materialReceiveRecordsBaseInfoService.save(receiveRecordsBaseInfo);
|
//插入领取清单
|
materialReceiveRecordsInfoService.saveBatch(receiveRecordsInfoList);
|
//创建成功，释放锁
|
lock.unlock();
|
}catch (EquipmentException e) {
|
e.printStackTrace();
|
throw new EquipmentException(e.getCode(), e.getMessage());
|
}catch (Exception e) {
|
e.printStackTrace();
|
throw new BusinessException(ResultCodes.SERVER_ERROR);
|
}finally {
|
if(lock.isLocked()){
|
lock.unlock();
|
}
|
}
|
}
|
|
/**
|
* 特殊作业物资出库
|
* @param req
|
* @return
|
*/
|
@Override
|
public void deliveryBatchSpw(MaterialSpwReq req) {
|
//验证
|
if(null == req.getClaimantId()){
|
throw new EquipmentException(ResultCodes.CLIENT_PARAM_NULL,"认领人不可为空！");
|
}
|
List<MaterialSpwDeliveryReq> deliveryReqList = req.getDeliveryReqList();
|
if(CollectionUtils.isEmpty(deliveryReqList)){
|
throw new EquipmentException(ResultCodes.CLIENT_PARAM_NULL,"出库物资不可为空！");
|
}
|
//获取小类物资
|
List<Long> smallClassifyIds = deliveryReqList
|
.stream()
|
.map(MaterialSpwDeliveryReq::getSmallClassifyId)
|
.collect(Collectors.toList());
|
List<Long> depIds = deliveryReqList
|
.stream()
|
.map(MaterialSpwDeliveryReq::getDepId)
|
.collect(Collectors.toList());
|
if(smallClassifyIds.size() == 0 || depIds.size() == 0){
|
throw new EquipmentException(ResultCodes.CLIENT_PARAM_NULL,"部门/仓库或者物资类型(小类)不可为空!");
|
}
|
|
List<SafeMaterialClassifyStockDO> classifyStockList= safeMaterialDetailInfoService.getSmallClassifyStockByIds(smallClassifyIds);
|
//根据物资种类获取有效在库物资
|
List<SafeMaterialDetailDO> listBySmallClassifyIds = safeMaterialDetailInfoService.getListBySmallClassifyIds(smallClassifyIds,depIds);
|
|
for(MaterialSpwDeliveryReq deliveryReq:deliveryReqList){
|
if(null == deliveryReq.getDepId()){
|
throw new EquipmentException(ResultCodes.CLIENT_PARAM_NULL,"部门或仓库不可为空!");
|
}
|
if(null == deliveryReq.getCount()){
|
throw new EquipmentException(ResultCodes.CLIENT_PARAM_ILLEGAL,"出库数量不可为空！");
|
}
|
if(null == deliveryReq.getSmallClassifyId()){
|
throw new EquipmentException(ResultCodes.CLIENT_PARAM_NULL,"物资类型(小类)不可为空！");
|
}
|
List<SafeMaterialClassifyStockDO> collect = classifyStockList
|
.stream()
|
.filter(cs -> cs.getSmallClassifyId().equals(deliveryReq.getSmallClassifyId()) && cs.getDepId().equals(deliveryReq.getDepId()) && cs.getStockCount() >= deliveryReq.getCount())
|
.collect(Collectors.toList());
|
if(collect.size() == 0){
|
throw new EquipmentException(ResultCodes.CLIENT_PARAM_ILLEGAL,"库存不足！");
|
}
|
}
|
UserInfoRPCRespDTO userInfo = getUserInfo(req.getClaimantId());
|
List<Long> ids = new ArrayList<>();
|
//循环数据
|
for(MaterialSpwDeliveryReq deliveryReq:deliveryReqList){
|
//过滤出rfid存在的数据
|
List<SafeMaterialDetailDO> selectRfidNotNull = listBySmallClassifyIds
|
.stream()
|
.filter(item -> null != item.getRfid() && item.getSmallClassifyId().equals(deliveryReq.getSmallClassifyId()) && item.getDepId().equals(deliveryReq.getDepId()))
|
.collect(Collectors.toList());
|
List<Long> selectIds = new ArrayList<>();
|
if(selectRfidNotNull.size()>0){
|
selectIds = selectRfidNotNull
|
.stream()
|
.map(SafeMaterialDetailDO::getId)
|
.collect(Collectors.toList());
|
}
|
if(selectRfidNotNull.size() >= deliveryReq.getCount()){
|
ids.addAll(selectIds.subList(0,deliveryReq.getCount()));
|
}else{
|
ids.addAll(selectIds);
|
List<SafeMaterialDetailDO> selectRfidIsNull = listBySmallClassifyIds
|
.stream()
|
.filter(item -> null == item.getRfid() && item.getSmallClassifyId().equals(deliveryReq.getSmallClassifyId()) && item.getDepId().equals(deliveryReq.getDepId()))
|
.collect(Collectors.toList());
|
|
List<Long> collect = selectRfidIsNull.subList(0,deliveryReq.getCount()-selectRfidNotNull.size()).stream().map(SafeMaterialDetailDO::getId)
|
.collect(Collectors.toList());
|
ids.addAll(collect);
|
}
|
}
|
SafeMaterialBatchDeliveryBO detailBO = new SafeMaterialBatchDeliveryBO();
|
detailBO.setReceiveUname(userInfo.getUsername());
|
detailBO.setReceiveUid(req.getClaimantId());
|
detailBO.setIds(ids);
|
safeMaterialDetailInfoService.updateDeliveryStatusByIds(detailBO);
|
|
}
|
|
|
/**
|
* 根据rfid获取数据信息
|
* @param rfids
|
* @return
|
*/
|
@Override
|
public List<SafeRfidMaterialDetailDto> getListByRfids(List<String> rfids) {
|
if(CollectionUtils.isEmpty(rfids)){
|
throw new EquipmentException(ResultCodes.CLIENT_PARAM_NULL);
|
}
|
List<SafeMaterialDetailInfoDO> listByRfid = safeMaterialDetailInfoService.getListByRfids(rfids);
|
List<SafeRfidMaterialDetailDto> rfidMaterialDetailDtoList = new ArrayList<>();
|
for (SafeMaterialDetailInfoDO detailInfoDO:listByRfid){
|
SafeRfidMaterialDetailDto detailDto = new SafeRfidMaterialDetailDto();
|
detailDto.setId(detailInfoDO.getId());
|
detailDto.setName(detailInfoDO.getName());
|
detailDto.setBigClassifyId(detailInfoDO.getBigClassifyId());
|
detailDto.setSmallClassifyId(detailInfoDO.getSmallClassifyId());
|
detailDto.setDepId(detailInfoDO.getDepId());
|
rfidMaterialDetailDtoList.add(detailDto);
|
}
|
return rfidMaterialDetailDtoList;
|
}
|
|
@Override
|
@Transactional
|
public SearchResultVO<List<SafeMaterialDetailDto>> listByPage(ContextCacheUser currentUser,PageQuery<SafeMatetrialDetailQuery> pageQuery) {
|
SafeMaterialDetailDBQuery dbQuery = new SafeMaterialDetailDBQuery();
|
if(null != pageQuery.getSearchParams()){
|
BeanUtils.copyProperties(pageQuery.getSearchParams(),dbQuery);
|
dbQuery.setDepId(currentUser.getDepId());
|
}
|
dbQuery.setDepId(currentUser.getDepId());
|
//加分布式锁，防止重复创建规则
|
RLock lock = redissonClient.getLock("LOCK_SMD_MATERIALEXPIRED");
|
try {
|
lock.lock(10, TimeUnit.SECONDS);
|
//执行无效物资过期
|
this.materialExpired();
|
//创建成功，释放锁
|
lock.unlock();
|
}catch (Exception e) {
|
e.printStackTrace();
|
throw new BusinessException(ResultCodes.SERVER_ERROR);
|
}finally {
|
if(lock.isLocked()){
|
lock.unlock();
|
}
|
}
|
Page<SafeMaterialDetailInfo> page = new Page(pageQuery.getPageIndex(),pageQuery.getPageSize());
|
List<SafeMaterialDetailInfoDO> safeMaterialDetailInfoDOS = safeMaterialDetailInfoService.listByPage(page, dbQuery);
|
List<SafeMaterialDetailDto> detailDtoList = new ArrayList<>();
|
for(SafeMaterialDetailInfoDO materialDetailInfoDO : safeMaterialDetailInfoDOS){
|
SafeMaterialDetailDto materialDetailDto = new SafeMaterialDetailDto();
|
BeanUtils.copyProperties(materialDetailInfoDO,materialDetailDto);
|
materialDetailDto.setConsumableName(ConsumableEnum.getByCode(materialDetailInfoDO.getConsumable()).getValue());
|
materialDetailDto.setValidStatusName(ValidStatusEnum.getByCode(materialDetailInfoDO.getValidStatus()).getValue());
|
materialDetailDto.setValidTypeName(ValidTypeEnum.getByCode(materialDetailInfoDO.getValidType()).getValue());
|
materialDetailDto.setIrStatusName(IssueReceiptEnum.getByCode(materialDetailInfoDO.getIrStatus()).getValue());
|
materialDetailDto.setStatusName(MaterialStatusEnum.getByCode(materialDetailInfoDO.getStatus()).getValue());
|
detailDtoList.add(materialDetailDto);
|
}
|
return new SearchResultVO<>(true, page.getCurrent(),page.getSize(), page.getPages(),page.getTotal(),detailDtoList,ResultCodes.OK);
|
}
|
private void materialExpired(){
|
//获取所有物资管理
|
List<SafeMaterialInfo> list = safeMaterialInfoService.list();
|
//获取在库有效物资
|
List<SafeMaterialDetailInfo> unValidList = safeMaterialDetailInfoService.getUnValidList();
|
if(unValidList.size()>0){
|
List<SafeMaterialBO> safeMaterialBOList = new ArrayList<>();
|
List<SafeMaterialDetailInfo> updateValidStatusList = new ArrayList<>();
|
for(SafeMaterialInfo safeMaterialInfo:list){
|
//过滤出该管理下过期物资
|
List<SafeMaterialDetailInfo> expiredList = unValidList.stream().filter(item -> item.getSmId().equals(safeMaterialInfo.getId())).collect(Collectors.toList());
|
if(expiredList.size()>0){
|
//过滤非出库无效物资
|
List<SafeMaterialDetailInfo> expiredAndInLibraryList = expiredList.stream().filter(item -> item.getIrStatus().equals(IssueReceiptEnum.IN_THE_LIBRARY.getCode())).collect(Collectors.toList());
|
if(expiredAndInLibraryList.size()>0){
|
//物资管理
|
SafeMaterialBO safeMaterialBO = new SafeMaterialBO();
|
safeMaterialBO.setId(safeMaterialInfo.getId());
|
safeMaterialBO.setStockCount(-expiredAndInLibraryList.size());
|
safeMaterialBOList.add(safeMaterialBO);
|
}
|
//物资清单
|
for(SafeMaterialDetailInfo detailInfo:expiredList){
|
SafeMaterialDetailInfo safeMaterialDetailInfo = new SafeMaterialDetailInfo();
|
safeMaterialDetailInfo.setId(detailInfo.getId());
|
safeMaterialDetailInfo.setValidStatus(ValidStatusEnum.NO.getCode());
|
if(detailInfo.getStatus().equals(MaterialStatusEnum.INTACT.getCode())){
|
safeMaterialDetailInfo.setStatus(MaterialStatusEnum.OVERDUE.getCode());
|
safeMaterialDetailInfo.setRemark(MaterialStatusEnum.OVERDUE.getValue());
|
}
|
updateValidStatusList.add(safeMaterialDetailInfo);
|
}
|
}
|
}
|
if(safeMaterialBOList.size()>0){
|
safeMaterialInfoService.updateStockCount(safeMaterialBOList);
|
}
|
if(updateValidStatusList.size()>0){
|
safeMaterialDetailInfoService.updateBatchById(updateValidStatusList);
|
}
|
}
|
}
|
@Override
|
public ResultVO queryById(Long id) {
|
if(null == id){
|
throw new EquipmentException(ResultCodes.CLIENT_PARAM_NULL);
|
}
|
SafeMaterialDetailInfo materialDetailInfo = safeMaterialDetailInfoService.queryById(id);
|
SafeMaterialDetailDto detailDto = new SafeMaterialDetailDto();
|
if(materialDetailInfo != null){
|
SafeMaterialDO safeMaterialDO = safeMaterialInfoService.queryById(materialDetailInfo.getSmId());
|
SafeMaterialClassifyInfo classifyInfo = safeMaterialClassifyInfoService.queryById(materialDetailInfo.getBigClassifyId());
|
BeanUtils.copyProperties(materialDetailInfo,detailDto);
|
detailDto.setConsumableName(ConsumableEnum.getByCode(materialDetailInfo.getConsumable()).getValue());
|
detailDto.setValidStatusName(ValidStatusEnum.getByCode(materialDetailInfo.getValidStatus()).getValue());
|
detailDto.setValidTypeName(ValidTypeEnum.getByCode(materialDetailInfo.getValidType()).getValue());
|
detailDto.setIrStatusName(IssueReceiptEnum.getByCode(materialDetailInfo.getIrStatus()).getValue());
|
detailDto.setStatusName(MaterialStatusEnum.getByCode(materialDetailInfo.getStatus()).getValue());
|
if(safeMaterialDO != null){
|
detailDto.setDepName(safeMaterialDO.getDepName());
|
}
|
if(classifyInfo != null){
|
detailDto.setBigClassifyName(classifyInfo.getMaterialClassifyName());
|
}
|
|
}
|
return new ResultVO(ResultCodes.OK,detailDto);
|
}
|
|
/**
|
* 单条-出库
|
* @param req
|
* @return
|
*/
|
@Override
|
@Transactional
|
public void singleDelivery(ContextCacheUser currentUser,SafeMaterialDetailReq req) {
|
if(null == req.getReceiveUid()){
|
throw new EquipmentException(ResultCodes.CLIENT_PARAM_NULL,"领取人不可为空！");
|
}
|
//加分布式锁，防止重复创建规则
|
RLock lock = redissonClient.getLock("LOCK_SMD_SINGLEDELIVERY");
|
try {
|
lock.lock(10, TimeUnit.SECONDS);
|
//获取该条数据
|
SafeMaterialDetailInfo vo = safeMaterialDetailInfoService.queryById(req.getId());
|
if(null == vo){
|
throw new EquipmentException(EquipmentResultCodes.DATA_NOT_EXIST);
|
}
|
if(vo.getValidStatus().equals(ValidStatusEnum.NO.getCode())){
|
throw new EquipmentException(EquipmentResultCodes.MATERIAL_INVALID,"无效物资不可出库");
|
}
|
if(vo.getIrStatus().equals(IssueReceiptEnum.OUT_OF_LIBRARY.getCode())){
|
throw new EquipmentException(EquipmentResultCodes.MATERIAL_OUT_OF_LIBRARY);
|
}
|
//检查认领人
|
UserInfoRPCRespDTO userInfo = getUserInfo(req.getReceiveUid());
|
//详细物资
|
SafeMaterialDetailInfo materialDetailInfo = new SafeMaterialDetailInfo();
|
materialDetailInfo.setId(req.getId());
|
materialDetailInfo.setIrStatus(IssueReceiptEnum.OUT_OF_LIBRARY.getCode());
|
materialDetailInfo.setReceiveUid(req.getReceiveUid());
|
materialDetailInfo.setReceiveUname(userInfo.getUsername());
|
materialDetailInfo.setDeliveryTime(LocalDateTime.now());
|
|
//物资管理库存数量
|
SafeMaterialBO safeMaterialBO = new SafeMaterialBO();
|
safeMaterialBO.setId(vo.getSmId());
|
safeMaterialBO.setStockCount(-1);
|
//出库记录
|
MaterialReceiveRecordsBaseInfo receiveRecordsBaseInfo = new MaterialReceiveRecordsBaseInfo();
|
receiveRecordsBaseInfo.setId(IdUtil.getSnowflake(0,0).nextId());
|
receiveRecordsBaseInfo.setMaterialName(vo.getName());
|
receiveRecordsBaseInfo.setReceiveCount(1);
|
receiveRecordsBaseInfo.setRevertCount(0);
|
receiveRecordsBaseInfo.setConsumeCount(0);
|
receiveRecordsBaseInfo.setReceiveUid(userInfo.getUid());
|
receiveRecordsBaseInfo.setReceiveUname(userInfo.getUsername());
|
receiveRecordsBaseInfo.setSmId(vo.getSmId());
|
//出库物资记录
|
MaterialReceiveRecordsInfo receiveRecordsInfo = new MaterialReceiveRecordsInfo();
|
receiveRecordsInfo.setId(IdUtil.getSnowflake(0,0).nextId());
|
receiveRecordsInfo.setMaterialName(vo.getName());
|
receiveRecordsInfo.setMaterialNo(vo.getMaterialNo());
|
receiveRecordsInfo.setRfid(vo.getRfid());
|
receiveRecordsInfo.setReceiveTime(LocalDateTime.now());
|
receiveRecordsInfo.setReceiveUid(userInfo.getUid());
|
receiveRecordsInfo.setReceiveUname(userInfo.getUsername());
|
receiveRecordsInfo.setReceiveBaseId(receiveRecordsBaseInfo.getId());
|
receiveRecordsInfo.setSmdId(vo.getId());
|
|
if(vo.getConsumable().equals(ConsumableEnum.YES.getCode())){
|
//耗材
|
materialDetailInfo.setValidStatus(ValidStatusEnum.NO.getCode());
|
materialDetailInfo.setStatus(MaterialStatusEnum.OTHER.getCode());
|
materialDetailInfo.setRemark("耗材");
|
receiveRecordsBaseInfo.setStatus(MaterialReceiveRecordsStatusEnum.CONSUMABLE_RETURN_NO.getCode());
|
receiveRecordsInfo.setRevertStatus(MaterialRevertStatusEnum.DEPLETION.getCode());
|
receiveRecordsInfo.setMaterialStatus(MaterialStatusEnum.OTHER.getCode());
|
receiveRecordsInfo.setRemark("耗材");
|
}else{
|
//默认未归还
|
receiveRecordsBaseInfo.setStatus(MaterialReceiveRecordsStatusEnum.RETURN_NO.getCode());
|
receiveRecordsInfo.setRevertStatus(MaterialRevertStatusEnum.REVERT_NO.getCode());
|
receiveRecordsInfo.setMaterialStatus(MaterialStatusEnum.INTACT.getCode());
|
receiveRecordsInfo.setRemark(MaterialStatusEnum.INTACT.getValue());
|
}
|
|
//修改出入库状态为出库
|
safeMaterialDetailInfoService.updateById(materialDetailInfo);
|
//修改物资管理库存
|
safeMaterialInfoService.updateCountById(safeMaterialBO);
|
//物资领取总记录
|
materialReceiveRecordsBaseInfoService.save(receiveRecordsBaseInfo);
|
//物资详细清单
|
materialReceiveRecordsInfoService.save(receiveRecordsInfo);
|
//创建成功，释放锁
|
lock.unlock();
|
}catch (EquipmentException e) {
|
e.printStackTrace();
|
throw new EquipmentException(e.getCode(), e.getMessage());
|
}catch (Exception e) {
|
e.printStackTrace();
|
throw new BusinessException(ResultCodes.SERVER_ERROR);
|
}finally {
|
if(lock.isLocked()){
|
lock.unlock();
|
}
|
}
|
}
|
|
/**
|
* 单条-重新入库
|
* @param id
|
* @return
|
*/
|
|
@Override
|
@Transactional
|
public void singleReceipt(Long id,ContextCacheUser currentUser) {
|
if(null == id){
|
throw new EquipmentException(ResultCodes.CLIENT_PARAM_NULL);
|
}
|
//加分布式锁，防止重复创建规则
|
RLock lock = redissonClient.getLock("LOCK_SMD_SINGLERECEIPT");
|
try {
|
lock.lock(10, TimeUnit.SECONDS);
|
//获取该条数据
|
SafeMaterialDetailInfo vo = safeMaterialDetailInfoService.queryById(id);
|
if(null == vo){
|
throw new EquipmentException(EquipmentResultCodes.DATA_NOT_EXIST,"未查询到该物资出库记录");
|
}
|
//如果是耗材不可重新入库
|
if(vo.getConsumable().equals(ConsumableEnum.YES.getCode())){
|
throw new EquipmentException(EquipmentResultCodes.MATERIAL_CONSUMABLE);
|
}
|
if(vo.getIrStatus().equals(IssueReceiptEnum.IN_THE_LIBRARY.getCode())){
|
throw new EquipmentException(EquipmentResultCodes.MATERIAL_IN_THE_LIBRARY);
|
}
|
//物资管理库存数量
|
SafeMaterialBO safeMaterialBO = new SafeMaterialBO();
|
safeMaterialBO.setId(vo.getSmId());
|
safeMaterialBO.setStockCount(1);
|
|
//获取物资总记录数据
|
MaterialDeliveryRecordDO deliveryRecordDO = materialReceiveRecordsInfoService.getRecordBySmdId(id);
|
SafeMaterialDetailInfo safeMaterialDetailInfo = new SafeMaterialDetailInfo();
|
safeMaterialDetailInfo.setId(vo.getId());
|
safeMaterialDetailInfo.setIrStatus(IssueReceiptEnum.IN_THE_LIBRARY.getCode());
|
safeMaterialDetailInfo.setWareHousingTime(LocalDateTime.now());
|
if(null == deliveryRecordDO){
|
//无领取记录
|
if (vo.getValidStatus().equals(ValidStatusEnum.NO.getCode())) {//无效
|
if(vo.getStatus().equals(MaterialStatusEnum.OVERDUE.getCode())){//过期
|
safeMaterialBO.setStockCount(0);
|
}else{
|
//其他情况,重新入库则改成有效
|
safeMaterialDetailInfo.setValidStatus(ValidStatusEnum.YES.getCode());
|
safeMaterialDetailInfo.setStatus(MaterialStatusEnum.INTACT.getCode());
|
safeMaterialDetailInfo.setRemark(MaterialStatusEnum.INTACT.getValue());
|
}
|
}
|
|
}else{
|
//有领取记录，则归还
|
//获取未归还物资详细记录
|
List<MaterialReceiveRecordsInfo> recordsInfos = materialReceiveRecordsInfoService.getNoReturnRecordByReceiveBaseId(deliveryRecordDO.getReceiveBaseId());
|
//领取总记录填充
|
MaterialReceiveRecordsBaseInfo receiveRecordsBaseInfo = new MaterialReceiveRecordsBaseInfo();
|
receiveRecordsBaseInfo.setId(deliveryRecordDO.getReceiveBaseId());
|
if(recordsInfos.size() > 1) {
|
receiveRecordsBaseInfo.setStatus(MaterialReceiveRecordsStatusEnum.RETURN_PART.getCode());
|
}else {
|
receiveRecordsBaseInfo.setStatus(MaterialReceiveRecordsStatusEnum.RETURN_COMPLETE.getCode());
|
}
|
receiveRecordsBaseInfo.setRevertCount(deliveryRecordDO.getRevertCount()+1);
|
materialReceiveRecordsBaseInfoService.updateById(receiveRecordsBaseInfo);
|
//详细物资领取记录
|
MaterialReceiveRecordsInfo receiveRecordsInfo = new MaterialReceiveRecordsInfo();
|
receiveRecordsInfo.setId(deliveryRecordDO.getReceiveId());
|
receiveRecordsInfo.setRevertStatus(MaterialRevertStatusEnum.REVERT_YES.getCode());
|
receiveRecordsInfo.setRevertTime(LocalDateTime.now());
|
receiveRecordsInfo.setMaterialStatus(MaterialStatusEnum.INTACT.getCode());
|
receiveRecordsInfo.setRemark(MaterialStatusEnum.INTACT.getValue());
|
materialReceiveRecordsInfoService.updateById(receiveRecordsInfo);
|
}
|
|
//修改出入库状态为入库
|
safeMaterialDetailInfoService.updateById(safeMaterialDetailInfo);
|
//修改物资管理库存
|
safeMaterialInfoService.updateCountById(safeMaterialBO);
|
//创建成功，释放锁
|
lock.unlock();
|
}catch (EquipmentException e) {
|
e.printStackTrace();
|
throw new EquipmentException(e.getCode(), e.getMessage());
|
}catch (Exception e) {
|
e.printStackTrace();
|
throw new BusinessException(ResultCodes.SERVER_ERROR);
|
}finally {
|
if(lock.isLocked()){
|
lock.unlock();
|
}
|
}
|
|
}
|
|
|
/**
|
* 逻辑删除 -单条
|
* @param
|
* @return
|
*/
|
@Transactional
|
@Override
|
public ResultVO delete(Long id){
|
if(null == id){
|
throw new EquipmentException(ResultCodes.CLIENT_PARAM_NULL);
|
}
|
//加分布式锁，防止重复创建规则
|
RLock lock = redissonClient.getLock("LOCK_SMD_DELETE");
|
try {
|
//获取该条数据
|
SafeMaterialDetailInfo vo = safeMaterialDetailInfoService.queryById(id);
|
if(null == vo){
|
throw new EquipmentException(EquipmentResultCodes.DATA_NOT_EXIST);
|
}
|
if(vo.getIrStatus().equals(IssueReceiptEnum.OUT_OF_LIBRARY.getCode())){
|
throw new EquipmentException(ResultCodes.SERVER_DEL_ERROR,"出库物资不可删除！");
|
}
|
SafeMaterialDetailInfo materialDetailInfo = new SafeMaterialDetailInfo();
|
materialDetailInfo.setId(id);
|
materialDetailInfo.setDelFlag(1);
|
//物资管理库存数量
|
SafeMaterialBO safeMaterialBO = new SafeMaterialBO();
|
safeMaterialBO.setId(vo.getSmId());
|
|
if(vo.getValidStatus().equals(ValidStatusEnum.YES.getCode())){
|
//有效
|
safeMaterialBO.setStockCount(-1);
|
safeMaterialBO.setTotalCount(-1);
|
}else{
|
//无效
|
safeMaterialBO.setTotalCount(-1);
|
}
|
//删除一条数据
|
safeMaterialDetailInfoService.updateById(materialDetailInfo);
|
//减少库存
|
safeMaterialInfoService.updateCountById(safeMaterialBO);
|
//创建成功，释放锁
|
lock.unlock();
|
}catch (EquipmentException e) {
|
e.printStackTrace();
|
throw new EquipmentException(e.getCode(), e.getMessage());
|
}catch (Exception e) {
|
e.printStackTrace();
|
throw new BusinessException(ResultCodes.SERVER_ERROR);
|
}finally {
|
if(lock.isLocked()){
|
lock.unlock();
|
}
|
}
|
return new ResultVO<>(ResultCodes.OK);
|
}
|
|
/**
|
* 根据小类id（物资种类）获取库存数量
|
* @param smallClassifyIds
|
* @return
|
*/
|
public List<SafeMaterialClassifyStockDto> getSmallClassifyStockByIds(List<Long> smallClassifyIds) {
|
if(CollectionUtils.isEmpty(smallClassifyIds)){
|
throw new EquipmentException(ResultCodes.CLIENT_PARAM_NULL);
|
}
|
List<SafeMaterialClassifyStockDO> classifyStockList= safeMaterialDetailInfoService.getSmallClassifyStockByIds(smallClassifyIds);
|
List<SafeMaterialClassifyStockDto> classifyStockDtoList = new ArrayList<>();
|
for (SafeMaterialClassifyStockDO classifyStockDO:classifyStockList){
|
SafeMaterialClassifyStockDto classifyStockDto = new SafeMaterialClassifyStockDto();
|
BeanUtils.copyProperties(classifyStockDO,classifyStockDto);
|
classifyStockDtoList.add(classifyStockDto);
|
}
|
return classifyStockDtoList;
|
}
|
|
|
private UserInfoRPCRespDTO getUserInfo(Long uid) {
|
UserInfoRPCRespDTO userInfo = new UserInfoRPCRespDTO();
|
ResultVO<UserInfoRPCRespDTO> rpcResult = accountUserService.getUserInfoByUid(uid);
|
if (rpcResult != null && rpcResult.getCode().equals(ResultCodes.OK.getCode())) {
|
if (rpcResult.getData() != null) {
|
userInfo = (UserInfoRPCRespDTO) rpcResult.getData();
|
}else {
|
throw new EquipmentException(EquipmentResultCodes.DATA_NOT_EXIST,"领取人员不存在！");
|
}
|
} else {
|
throw new EquipmentException(ResultCodes.RPC_RESULT_NULL);
|
}
|
return userInfo;
|
}
|
|
private String generateMaterialNo(int count){
|
if(count < 0){
|
return null;
|
}
|
String serialCode = null;
|
String prefix = "NO-";
|
if(count >= 10000){
|
serialCode = "" + (count+1);
|
}else if(count >=0){
|
String countStr = String.valueOf(count+1);
|
serialCode = "10000".substring(0,(5 - countStr.length()))+countStr;
|
}
|
serialCode = prefix + serialCode;
|
return serialCode;
|
}
|
private Date conversionTimeType(LocalDateTime localDateTime){
|
ZoneId zoneId = ZoneId.systemDefault();
|
ZonedDateTime zdt = localDateTime.atZone(zoneId);
|
Date date = Date.from(zdt.toInstant());
|
return date;
|
}
|
}
|
