package com.nanometer.smartlab.service;

import com.nanometer.smartlab.dao.*;
import com.nanometer.smartlab.entity.*;
import com.nanometer.smartlab.entity.enumtype.ApplyStatus;
import com.nanometer.smartlab.entity.enumtype.ArrivalStatus;
import com.nanometer.smartlab.entity.enumtype.EmailSendStatus;
import com.nanometer.smartlab.entity.enumtype.OperateStatus;
import com.nanometer.smartlab.entity.enumtype.StoreType;
import com.nanometer.smartlab.exception.AlarmCode;
import com.nanometer.smartlab.exception.AlarmException;
import com.nanometer.smartlab.exception.BusinessException;
import com.nanometer.smartlab.exception.ExceptionEnumCode;
import com.nanometer.smartlab.util.MessageUtil;
import com.nanometer.smartlab.util.StringToolUtils;
import org.apache.commons.lang.StringUtils;
import org.apache.log4j.Logger;
import org.springframework.beans.BeanUtils;
import org.springframework.context.annotation.Lazy;
import org.springframework.dao.DataAccessException;
import org.springframework.dao.DataIntegrityViolationException;
import org.springframework.dao.DuplicateKeyException;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.sql.Timestamp;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * Created by johnny on 17/12/14.
 */
@Service("opeOrderService")
public class OpeOrderServiceImpl implements OpeOrderService {

    private static Logger logger = Logger.getLogger(OpeOrderService.class);

    @Resource(name = "opeOrderDao")
    OpeOrderDao opeOrderDao;
    @Resource
    private OpeApplyOrderService opeApplyOrderService;
    @Resource
    private SysSequenceService sysSequenceService;
    @Resource
    private OpeApplyService opeApplyService;
    @Lazy
    @Resource
    private OpeReagentStatusService opeReagentStatusService;
    @Lazy
    @Resource
    private OpeWarehouseReserveService opeWarehouseReserveService;
    @Lazy
    @Resource
    private OpeUseFlowService opeUseFlowService;
    @Resource
    EmailStatusDao emailStatusDao;

    @Resource(name="baseMetaDao")
    BaseMetaDao baseMetaDao;

    @Resource
    DangerousEncodeMapper dangerousEncodeMapper;

    @Resource
    OpeReagentCodeDao opeReagentCodeDao;
    @Resource
    OpeApplyDao opeApplyDao;

    @Transactional(propagation = Propagation.REQUIRED)
    public List<OpeOrder> getOpeOrderList(String orderCode, String orderName, Timestamp startTime, Timestamp endTime, Integer status, String orderUserName,
                                          Integer first, Integer pageSize) {
        try {
            Map<String, Object> params = new HashMap<String, Object>();
            if (StringUtils.isNotBlank(orderCode)) {
                params.put("orderCode", "%" + orderCode + "%");
            }
            if (StringUtils.isNotBlank(orderName)) {
                params.put("orderName", "%" + orderName + "%");
            }
            params.put("startTime", startTime);
            params.put("endTime", endTime);
            params.put("status", status);
            if (StringUtils.isNotBlank(orderUserName)) {
                params.put("orderUserName", "%" + orderUserName + "%");
            }
            params.put("first", first);
            params.put("pageSize", pageSize);
            return this.opeOrderDao.getOpeOrderList(params);
        } catch (DataAccessException e) {
            logger.error(e.getMessage(), e);
            throw new BusinessException(ExceptionEnumCode.DB_ERR, MessageUtil.getMessageByCode(ExceptionEnumCode.DB_ERR.getCode()), e);
        }
    }

    @Transactional(propagation = Propagation.REQUIRED)
    public int getOpeOrderTotalCount(String orderCode, String orderName, Timestamp startTime, Timestamp endTime, Integer status, String orderUserName) {
        try {
            Map<String, Object> params = new HashMap<String, Object>();
            if (StringUtils.isNotBlank(orderCode)) {
                params.put("orderCode", "%" + orderCode + "%");
            }
            if (StringUtils.isNotBlank(orderName)) {
                params.put("orderName", "%" + orderName + "%");
            }
            params.put("startTime", startTime);
            params.put("endTime", endTime);
            params.put("status", status);
            if (StringUtils.isNotBlank(orderUserName)) {
                params.put("orderUserName", "%" + orderUserName + "%");
            }
            return this.opeOrderDao.getOpeOrderTotalCount(params);
        } catch (DataAccessException e) {
            logger.error(e.getMessage(), e);
            throw new BusinessException(ExceptionEnumCode.DB_ERR, MessageUtil.getMessageByCode(ExceptionEnumCode.DB_ERR.getCode()), e);
        }
    }

    @Transactional(propagation = Propagation.REQUIRED)
    public OpeOrder getOpeOrder(Long id) {
        try {
            return this.opeOrderDao.getOpeOrder(id);
        } catch (DataAccessException e) {
            logger.error(e.getMessage(), e);
            throw new BusinessException(ExceptionEnumCode.DB_ERR, MessageUtil.getMessageByCode(ExceptionEnumCode.DB_ERR.getCode()), e);
        }
    }

    @Transactional(propagation = Propagation.REQUIRED)
    public OpeOrder insertOpeOrder(OpeOrder opeOrder) {
        try {
            this.opeOrderDao.insertOpeOrder(opeOrder);
            return opeOrder;
        } catch (DuplicateKeyException ex) {
            logger.warn(ex.getMessage(), ex);
            throw new AlarmException(AlarmCode.DATA_DUPLICATE, MessageUtil.getMessage(AlarmCode.DATA_DUPLICATE.getCode()));
        } catch (DataIntegrityViolationException ex) {
            logger.warn(ex.getMessage(), ex);
            throw new AlarmException(AlarmCode.DATA_CONFICT, MessageUtil.getMessage(AlarmCode.DATA_CONFICT.getCode()));
        } catch (DataAccessException ex) {
            logger.error(ex.getMessage(), ex);
            throw new BusinessException(ExceptionEnumCode.DB_ERR, MessageUtil.getMessageByCode(ExceptionEnumCode.DB_ERR.getCode()), ex);
        }
    }

    @Transactional(propagation = Propagation.REQUIRED)
    public boolean updateOpeOrder(OpeOrder opeOrder) {
        try {
            int row = this.opeOrderDao.updateOpeOrder(opeOrder);

            return row != 0;
        } catch (DuplicateKeyException ex) {
            logger.warn(ex.getMessage(), ex);
            throw new AlarmException(AlarmCode.DATA_DUPLICATE, MessageUtil.getMessage(AlarmCode.DATA_DUPLICATE.getCode()));
        } catch (DataIntegrityViolationException ex) {
            logger.warn(ex.getMessage(), ex);
            throw new AlarmException(AlarmCode.DATA_CONFICT, MessageUtil.getMessage(AlarmCode.DATA_CONFICT.getCode()));
        } catch (DataAccessException ex) {
            logger.error(ex.getMessage(), ex);
            throw new BusinessException(ExceptionEnumCode.DB_ERR, MessageUtil.getMessageByCode(ExceptionEnumCode.DB_ERR.getCode()), ex);
        }
    }

    @Transactional(propagation = Propagation.REQUIRED)
    public boolean deleteOpeOrder(List<OpeOrder> opeOrderList) {
        try {
            if (opeOrderList == null || opeOrderList.size() == 0) {
                return false;
            }

            List<Long> ids = new ArrayList<Long>();
            for (OpeOrder opeOrder : opeOrderList) {
                ids.add(opeOrder.getId());

                // 取消订单对应的申购
                this.cancelOrderApply(opeOrder.getId());
            }

            int row = this.opeOrderDao.deleteOpeOrder(ids);
            return row != 0;
        } catch (DataIntegrityViolationException ex) {
            logger.warn(ex.getMessage(), ex);
            throw new AlarmException(AlarmCode.DATA_CONFICT, MessageUtil.getMessage(AlarmCode.DATA_CONFICT.getCode()));
        } catch (DataAccessException ex) {
            logger.error(ex.getMessage(), ex);
            throw new BusinessException(ExceptionEnumCode.DB_ERR, MessageUtil.getMessageByCode(ExceptionEnumCode.DB_ERR.getCode()), ex);
        }
    }

    @Transactional(propagation = Propagation.REQUIRED)
    public void  createOpeOrder(OpeOrder opeOrder, List<OpeApply> opeApplyList, SysUser orderUser) {
        if (opeOrder == null
                || opeApplyList == null
                || orderUser == null) {
            return;
        }
        opeOrder.setOrderCode(this.sysSequenceService.getOrderCode());
        opeOrder.setStatus(ApplyStatus.PENDING_PURCHASE);
        opeOrder.setConsigneeUserId(null);
        opeOrder.setOrderUserId(orderUser.getId());
        opeOrder.setArrivalTime(null);
        opeOrder.setSupplierId(opeApplyList.get(0).getReagent().getSupplierId());
        opeOrder.setSupplierName(opeApplyList.get(0).getReagent().getSupplierName());
        this.insertOpeOrder(opeOrder);
        List<OpeApplyOrder> opeApplyOrderList = opeApplyList.stream().map(item -> {
            OpeApplyOrder opeApplyOrder = new OpeApplyOrder();
            opeApplyOrder.setOpeOrderId(opeOrder.getId());
            opeApplyOrder.setOpeApplyId(item.getId());
            return opeApplyOrder;
        }).collect(Collectors.toList());
        this.opeApplyOrderService.batchInsertOpeApplyOrder(opeApplyOrderList);
        this.opeApplyService.updateOpeApplyStatus(ApplyStatus.PENDING_PURCHASE,null,opeApplyList.stream().map(OpeApply::getId).collect(Collectors.toList()));
        synchronized(this) {
            generateReagentCode(opeOrder.getId(), opeApplyList);
        }
    }

//    public void  generateReagentCode(Long orderId,List<OpeApply> opeApplyList){
//        List<OpeReagentCode> opeReagentCodeList=new ArrayList<>();
//        for(OpeApply opeApply:opeApplyList) {
//            String applyCode=opeApply.getApplyCode();
//            String name = opeApply.getReagent().getName();
//            if (StringUtils.isBlank(name)) {
//                throw new BusinessException(ExceptionEnumCode.SYS_ERR, "试剂名称为空");
//            }
//            DangerousEncode dangerousEncode = this.dangerousEncodeMapper.selectByName(name);
//            if (dangerousEncode == null) {
//                throw new BusinessException(ExceptionEnumCode.SYS_ERR, "未录入危化品编码");
//            }
//            String containerNumber = dangerousEncode.getContainerNumber();
//            if(StringUtils.isBlank(containerNumber)||containerNumber.length()!=2){
//                throw new BusinessException(ExceptionEnumCode.SYS_ERR, String.format("试剂<%s>柜码不存在或者编码位数不是两位",name));
//            }
//            String factoryfactory = "0";
//            String specifications = "0";
//            String reagentCode = dangerousEncode.getReagentCode();
//            if (StringUtils.isBlank(reagentCode)) {
//                throw new BusinessException(ExceptionEnumCode.SYS_ERR, String.format("试剂<%s>试剂名称码不存在",name));
//            }
//            if(reagentCode.length()<4){
//                reagentCode= StringToolUtils.addZeroForNum(reagentCode,4);
//            }else{
//                reagentCode = reagentCode.substring(reagentCode.length() - 4, reagentCode.length());
//            }
//            String feature = dangerousEncode.getFeature();
//            if (StringUtils.isBlank(feature)||feature.length()!=4) {
//                throw new BusinessException(ExceptionEnumCode.SYS_ERR, String.format("试剂<%s>特性不存在或者编码位数不是四位",name));
//            }
//
//            String avoid = dangerousEncode.getAvoid();
//            if (StringUtils.isBlank(avoid)||avoid.length()!=2) {
//                throw new BusinessException(ExceptionEnumCode.SYS_ERR, String.format("试剂<%s>相忌不存在或者编码位数不是两位",name));
//            }
//            String status = dangerousEncode.getStatus();
//            if (StringUtils.isBlank(status)||status.length()!=2) {
//                throw new BusinessException(ExceptionEnumCode.SYS_ERR, String.format("试剂<%s>状态不存在或者编码位数不是两位",name));
//            }
//            String fire = dangerousEncode.getFire();
//            if (StringUtils.isBlank(fire)||fire.length()!=2) {
//                throw new BusinessException(ExceptionEnumCode.SYS_ERR, String.format("试剂<%s>灭火器不存在或者编码位数不是两位",name));
//            }
//            String packing = "0";
//            StringBuilder prefixBuilder=new StringBuilder().append(containerNumber)
//                    .append(factoryfactory)
//                    .append(specifications)
//                    .append(reagentCode)
//                    .append(feature)
//                    .append(avoid)
//                    .append(status)
//                    .append(fire)
//                    .append(packing);
//            String codePrex=prefixBuilder.toString();
//            OpeReagentCode opeReagentCode=this.opeReagentCodeDao.getMaxReagentCode(codePrex);
//            Integer startCode=0;
//            Integer endCode=startCode+opeApply.getNum()-1;
//            if(opeReagentCode!=null){
//                startCode=opeReagentCode.getEndCode()+1;
//                endCode=startCode+opeApply.getNum()-1;
//            }
//            opeReagentCode=new OpeReagentCode();
//            opeReagentCode.setOrderId(orderId);
//            opeReagentCode.setApplyId(opeApply.getId());
//            opeReagentCode.setStartCode(startCode);
//            opeReagentCode.setEndCode(endCode);
//            opeReagentCode.setCodePrex(codePrex);
//            opeReagentCodeList.add(opeReagentCode);
//        }
//        if(opeReagentCodeList.size()>0){
//            this.opeReagentCodeDao.batchInsertReagentCode(opeReagentCodeList);
//        }
//    }

    public void  generateReagentCode(Long orderId,List<OpeApply> opeApplyList){
        List<OpeReagentCode> opeReagentCodeList=new ArrayList<>();
        for(OpeApply opeApply:opeApplyList) {
            String applyCode=opeApply.getApplyCode();
            applyCode=applyCode.replace("SG","");
            if (opeApply.getNum()>9999 &opeApply.getNum()<=0) {
                throw new BusinessException(ExceptionEnumCode.SYS_ERR, "试剂申请数量不能超过9999");
            }
            StringBuilder prefixBuilder=new StringBuilder().append("SJ")
                    .append(applyCode);
            String codePrex=prefixBuilder.toString();
            OpeReagentCode opeReagentCode=this.opeReagentCodeDao.getMaxReagentCode(codePrex);
            Integer startCode=0;
            Integer endCode=startCode+opeApply.getNum()-1;
            if(opeReagentCode!=null){
                startCode=opeReagentCode.getEndCode()+1;
                endCode=startCode+opeApply.getNum()-1;
            }
            opeReagentCode=new OpeReagentCode();
            opeReagentCode.setOrderId(orderId);
            opeReagentCode.setApplyId(opeApply.getId());
            opeReagentCode.setStartCode(startCode);
            opeReagentCode.setEndCode(endCode);
            opeReagentCode.setCodePrex(codePrex);
            opeReagentCodeList.add(opeReagentCode);
        }
        if(opeReagentCodeList.size()>0){
            this.opeReagentCodeDao.batchInsertReagentCode(opeReagentCodeList);
        }
    }

    @Transactional(propagation = Propagation.REQUIRED)
    public void rukuOpeOrder(OpeOrder opeOrder, List<OpeApply> opeApplyList) {
        if (opeOrder == null
                || opeApplyList == null) {
            return;
        }

        ApplyStatus flag = ApplyStatus.STORAGE;
      //  this.updateOpeOrder(opeOrder);
        for (OpeApply opeApply : opeApplyList) {
            int existArrivalNum=this.opeApplyDao.getArrivalNumById(opeApply.getId());
            Integer applyNum = opeApply.getNum();
            Integer arrivalNum = opeApply.getArrivalNum();
            if(arrivalNum<=existArrivalNum||arrivalNum>applyNum){
                throw new BusinessException(ExceptionEnumCode.ORDER_ERROR,"到货数量不正确");
            }
            if(applyNum > arrivalNum)
            {
                flag = ApplyStatus.UNCOMPLETED;
                opeApply.setStatus(ApplyStatus.UNCOMPLETED);
            }else
            {
                opeApply.setStatus(ApplyStatus.STORAGE);
            }
            this.opeApplyService.updateOpeApply(opeApply);

            OpeReagentCode opeReagentCode=this.opeReagentCodeDao.getReagentCode(opeOrder.getId(),opeApply.getId());
            if(opeReagentCode==null){
                throw new BusinessException(ExceptionEnumCode.SYS_ERR, "申购编号：" + opeApply.getApplyCode() + "的试剂条形码未自动生成");
            }
//            if(opeReagentCode.getStatus()==1){
//                continue;
//            }
            List<OpeReagentStatus> opeReagentStatusList=generateReagentStatus(opeApply,opeReagentCode,opeOrder.getConsigneeUserId(),arrivalNum);
            generateOpeUseFlow(opeReagentStatusList);
            updateWareHouse(opeApply,arrivalNum-existArrivalNum);
            this.opeReagentCodeDao.updateStatus(opeOrder.getId(),opeApply.getId(),1);
        }
        // 更新订单状态为已入库
        opeOrder.setStatus(flag);
        this.opeOrderDao.updateOpeOrderStatus(opeOrder);


    }



    /**
     * 生成试剂流向
     */
    @Override
    public List<OpeReagentStatus> generateReagentStatus(OpeApply opeApply,OpeReagentCode opeReagentCode,Long consigneeUserId,Integer num){
        int startCode=opeReagentCode.getStartCode();
        int endCode=opeReagentCode.getEndCode();
        List<OpeReagentStatus>  opeReagentStatusList=new ArrayList<>();
        int codeSum=0;
        for(int i=startCode;i<=endCode;i++){
            String lastCode=StringToolUtils.addZeroForNum(String.valueOf(i),4);
            String rcode=String.format("%s%s",opeReagentCode.getCodePrex(),lastCode);
            codeSum=codeSum+1;
            if(codeSum>num){
                break;
            }
            if (this.opeReagentStatusService.isOpeReagentStatusExist(rcode)) {
                continue;
            }
            OpeReagentStatus opeReagentStatus = new OpeReagentStatus();
            BeanUtils.copyProperties(opeApply,opeReagentStatus, "id");
            opeReagentStatus.setReagentId(opeApply.getReagent().getId());
            opeReagentStatus.setReagentCode(rcode);
            opeReagentStatus.setStatus(ArrivalStatus.WAREHOUSE.getKey());
            opeReagentStatus.setUserId(consigneeUserId);
            opeReagentStatus.setRemainder(opeApply.getReagent().getMainMetering() != null ? (opeApply.getReagent().getMainMetering()) : new BigDecimal(0));
            opeReagentStatus.setStoreType(StoreType.APPLY.getKey());
            opeReagentStatusList.add(opeReagentStatus);
        }
        if(opeReagentStatusList.size()>0) {
            this.opeReagentStatusService.batchInsertOpeReagentStatus(opeReagentStatusList);
        }
        return opeReagentStatusList;
    }
    /**

    /**
     * 生成试剂流向
     */
    public void generateOpeUseFlow(List<OpeReagentStatus>  opeReagentStatusList){
        List<OpeUseFlow> opeUseFlowList=new ArrayList<>();
        for(OpeReagentStatus opeReagentStatus :opeReagentStatusList){
            OpeUseFlow opeUseFlow = new OpeUseFlow();
            BeanUtils.copyProperties(opeReagentStatus,opeUseFlow,"id");
            opeUseFlow.setReagentCode(opeReagentStatus.getReagentCode());
            opeUseFlow.setOperateState(OperateStatus.WAREHOUSEIN.getKey());
            opeUseFlowList.add(opeUseFlow);
        }
        if(opeUseFlowList.size()>0) {
            this.opeUseFlowService.batchInsertOpeUseFlow(opeUseFlowList);
        }
    }
    /**
     * 更新库存
     */
    public void updateWareHouse(OpeApply opeApply,Integer num){
        OpeWarehouseReserve opeWarehouseReserve = this.opeWarehouseReserveService.getOpeWarehouseReserve(opeApply.getReagent().getId(), opeApply.getArticleNumber());
        if (opeWarehouseReserve == null) {
            opeWarehouseReserve = new OpeWarehouseReserve();
            opeWarehouseReserve.setReagentId(opeApply.getReagent().getId());
            opeWarehouseReserve.setArticleNumber(opeApply.getArticleNumber());
            opeWarehouseReserve.setReserve(0);
            opeWarehouseReserve.setWarehouseId(opeApply.getHouseId());
            opeWarehouseReserve.setContainerId(opeApply.getContainerId());
        }
        opeWarehouseReserve.setReserve(opeWarehouseReserve.getReserve() + num);
        if (opeWarehouseReserve.getId()==null) {
            this.opeWarehouseReserveService.insertOpeWarehouseReserve(opeWarehouseReserve);
        } else {
            this.opeWarehouseReserveService.updateOpeWarehouseReserve(opeWarehouseReserve);
        }
    }


    public List<OpeApply> getOpeApplyListByOrder(Long orderId) {
        List<OpeApply> result = this.opeApplyService.getOpeApplyByOrderId(orderId);
//        List<OpeApplyOrder> opeApplyOrderList = this.opeApplyOrderService.getOpeApplyOrderList(orderId, null);
//        if (opeApplyOrderList != null && opeApplyOrderList.size() > 0) {
//            result = new ArrayList<OpeApply>();
//            for (OpeApplyOrder opeApplyOrder : opeApplyOrderList) {
//                result.add(this.opeApplyService.getOpeApply(opeApplyOrder.getOpeApplyId()));
//            }
//        }
//
//        this.opeApplyService.getOpeApplyByOrderId(orderId);
        return result;
    }

    public boolean isOrderPendingPurchase(OpeOrder opeOrder) {
        return opeOrder != null
                && opeOrder.getStatus() != null
                && opeOrder.getStatus().getKey() == ApplyStatus.PENDING_PURCHASE.getKey();

    }

    @Transactional(propagation = Propagation.REQUIRED)
    public void cancelOrderApply(Long orderId) {
        List<OpeApply> opeApplyList = this.getOpeApplyListByOrder(orderId);
        if (opeApplyList != null && opeApplyList.size() > 0) {
            for (OpeApply opeApply : opeApplyList) {
                opeApply.setStatus(ApplyStatus.CANCEL);
                this.opeApplyService.updateOpeApply(opeApply);
            }
        }
    }

    @Transactional(propagation = Propagation.REQUIRED)
    public void emailStatusSave(OpeOrder opeOrder, List<OpeApply> opeApplyList) {

        EmailStatus emailStatus = null;

        for (OpeApply opeApply : opeApplyList) {

            emailStatus = new EmailStatus();
            emailStatus.setOrderCode(opeOrder.getOrderCode());
            emailStatus.setApplyCode(opeApply.getApplyCode());
            emailStatus.setReagentId(opeApply.getReagentId());
            emailStatus.setNum(opeApply.getArrivalNum());
            emailStatus.setApplyUserId(opeApply.getApplyUserId());
            emailStatus.setStatus(EmailSendStatus.UN_SEND);

                // 待发送邮件保存
            this.emailStatusDao.insertEmailStatus(emailStatus);
        }
    }

    @Transactional(propagation = Propagation.REQUIRED)
    public List<EmailStatus> getUnsendEmailList() {
        try {
            Map<String, Object> params = new HashMap<String, Object>();
            params.put("status", EmailSendStatus.UN_SEND);
            return  this.emailStatusDao.getEmailStatusList(params);
        } catch (DataAccessException e) {
            logger.error(e.getMessage(), e);
            throw new BusinessException(ExceptionEnumCode.DB_ERR, MessageUtil.getMessageByCode(ExceptionEnumCode.DB_ERR.getCode()), e);
        }
    }

    @Transactional(propagation = Propagation.REQUIRED)
    public int getUnsendEmailCount() {
        try {
            Map<String, Object> params = new HashMap<String, Object>();
            params.put("status", EmailSendStatus.UN_SEND);
            return this.emailStatusDao.getEmailStatusTotalCount(params);
        } catch (DataAccessException e) {
            logger.error(e.getMessage(), e);
            throw new BusinessException(ExceptionEnumCode.DB_ERR, MessageUtil.getMessageByCode(ExceptionEnumCode.DB_ERR.getCode()), e);
        }
    }

    @Transactional(propagation = Propagation.REQUIRED)
    public boolean updateEmailStatus(EmailStatus emailStatus) {
        try {
            int row = this.emailStatusDao.updateEmailStatus(emailStatus);
            return row != 0;
        } catch (DuplicateKeyException ex) {
            logger.warn(ex.getMessage(), ex);
            throw new AlarmException(AlarmCode.DATA_DUPLICATE, MessageUtil.getMessage(AlarmCode.DATA_DUPLICATE.getCode()));
        } catch (DataIntegrityViolationException ex) {
            logger.warn(ex.getMessage(), ex);
            throw new AlarmException(AlarmCode.DATA_CONFICT, MessageUtil.getMessage(AlarmCode.DATA_CONFICT.getCode()));
        } catch (DataAccessException ex) {
            logger.error(ex.getMessage(), ex);
            throw new BusinessException(ExceptionEnumCode.DB_ERR, MessageUtil.getMessageByCode(ExceptionEnumCode.DB_ERR.getCode()), ex);
        }
    }

    /**
     * 由于修改条形码重新入库
     * @param opeOrder
     * @param opeOrderApplyList
     */
    @Transactional
    @Override
    public void reRukuInfo(OpeOrder opeOrder, List<OpeApply> opeOrderApplyList) {
        if (opeOrder == null
                || opeOrderApplyList == null) {
            return;
        }


        // 将之前入库的信息删除
        BigInteger startReagentCode = null;
        BigInteger endReagentCode = null;
        String reagentCode = null;
        OpeWarehouseReserve opeWarehouseReserve = null;
        //记录需要重新入库的信息LIST
        List<OpeApply> reRukuopeOrderApplyList = new ArrayList<>();
        for (OpeApply opeApply : opeOrderApplyList) {
            OpeApply opeApply1 = this.opeApplyService.selectOpeApplyByPrimaryKey(opeApply.getId());
            if(opeApply.getArrivalNum().equals(opeApply1.getArrivalNum())
                    && opeApply.getStartReagentCode().equals(opeApply1.getStartReagentCode())
                    && opeApply.getEndReagentCode().equals(opeApply1.getEndReagentCode())
                    && opeApply.getArticleNumber().equals(opeApply1.getArticleNumber())){ //如果到货数量、批号、条形码开始、条形码结束都跟之前填入的一致，就不需要重新入库
                continue;
            }
            reRukuopeOrderApplyList.add(opeApply);

            //删除入库信息
            if(StringUtils.isNotBlank(opeApply1.getStartReagentCode()) && StringUtils.isNotBlank(opeApply1.getEndReagentCode())){
                startReagentCode = new BigInteger(opeApply1.getStartReagentCode());
                endReagentCode = new BigInteger(opeApply1.getEndReagentCode());
                for (BigInteger i = startReagentCode; i.compareTo(endReagentCode) < 1; i = i.add(BigInteger.ONE)) {
                    reagentCode = String.valueOf(i);

                    this.opeReagentStatusService.deleteByReagentCode(reagentCode);

                    this.opeUseFlowService.deleteByReagentCode(reagentCode);
                }
            }

            opeWarehouseReserve = this.opeWarehouseReserveService.getOpeWarehouseReserve(opeApply.getReagent().getId(), opeApply.getArticleNumber());
            if (opeWarehouseReserve == null) {
                opeWarehouseReserve = new OpeWarehouseReserve();
                opeWarehouseReserve.setReagentId(opeApply.getReagent().getId());
                opeWarehouseReserve.setArticleNumber(opeApply.getArticleNumber());
                opeWarehouseReserve.setReserve(0);
            }
            opeWarehouseReserve.setReserve(opeWarehouseReserve.getReserve() - opeApply1.getArrivalNum());
            if (opeWarehouseReserve.getId()==null) {
                this.opeWarehouseReserveService.insertOpeWarehouseReserve(opeWarehouseReserve);
            } else {
                this.opeWarehouseReserveService.updateOpeWarehouseReserve(opeWarehouseReserve);
            }
        }

        //进行重新入库操作
        if(!reRukuopeOrderApplyList.isEmpty()){
            rukuOpeOrder(opeOrder,reRukuopeOrderApplyList);
        }
    }

    @Override
    public List<EmailStatus> selectByReId(Long id) {
        return this.emailStatusDao.selectByReId(id);
    }

    @Override
    public void updateByReId(Long newReId, Long oldReId) {
        Map<String, Object> params=new HashMap();
        params.put("newReId",newReId);
        params.put("oldReId",oldReId);
        this.emailStatusDao.updateByReId(params);
    }

    @Override
    public OpeOrder getOrder(Long id) {
        return opeOrderDao.selectParentOrder(id);
    }

    @Override
    @Transactional
    public void updateOpeOrderStatus(OpeOrder oo) {
        opeOrderDao.updateOpeOrderStatus(oo);
    }

}