wms / wms_xiaogangabu · Files

package com.huaheng.api.mes.controller;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.huaheng.api.mes.domain.*;
import com.huaheng.api.mes.service.SearchInventoryService;
import com.huaheng.common.constant.QuantityConstant;
import com.huaheng.common.exception.service.ServiceException;

import com.huaheng.common.utils.StringUtils;

import com.huaheng.framework.aspectj.lang.annotation.ApiLogger;
import com.huaheng.framework.aspectj.lang.annotation.Log;
import com.huaheng.framework.aspectj.lang.constant.BusinessType;

import com.huaheng.framework.web.controller.BaseController;
import com.huaheng.framework.web.domain.AjaxResult;

import com.huaheng.pc.config.material.domain.Material;
import com.huaheng.pc.config.material.service.MaterialService;

import com.huaheng.pc.config.receiptType.domain.ReceiptType;
import com.huaheng.pc.config.receiptType.service.ReceiptTypeService;

import com.huaheng.pc.config.shipmentType.domain.ShipmentType;
import com.huaheng.pc.config.shipmentType.service.ShipmentTypeService;

import com.huaheng.pc.inventory.adjustDetail.domain.AdjustDetail;
import com.huaheng.pc.inventory.adjustDetail.service.AdjustDetailService;
import com.huaheng.pc.inventory.adjustHeader.domain.AdjustHeader;
import com.huaheng.pc.inventory.adjustHeader.service.AdjustHeaderService;
import com.huaheng.pc.inventory.cycleCountDetail.domain.CycleCountDetail;
import com.huaheng.pc.inventory.cycleCountDetail.service.CycleCountDetailService;
import com.huaheng.pc.inventory.cycleCountHeader.domain.CycleCountHeader;
import com.huaheng.pc.inventory.cycleCountHeader.service.CycleCountHeaderService;
import com.huaheng.pc.inventory.inventoryDetail.domain.InventoryDetail;
import com.huaheng.pc.inventory.inventoryDetail.service.InventoryDetailService;
import com.huaheng.pc.inventory.inventoryHeader.domain.InventoryHeader;

import com.huaheng.pc.receipt.receiptDetail.domain.ReceiptDetail;
import com.huaheng.pc.receipt.receiptDetail.service.ReceiptDetailService;
import com.huaheng.pc.receipt.receiptDetailHistory.domain.ReceiptDetailHistory;
import com.huaheng.pc.receipt.receiptDetailHistory.service.ReceiptDetailHistoryService;
import com.huaheng.pc.receipt.receiptHeader.domain.ReceiptHeader;
import com.huaheng.pc.receipt.receiptHeader.mapper.ReceiptHeaderMapper;
import com.huaheng.pc.receipt.receiptHeader.service.ReceiptHeaderService;
import com.huaheng.pc.receipt.receiptHeaderHistory.domain.ReceiptHeaderHistory;
import com.huaheng.pc.receipt.receiptHeaderHistory.service.ReceiptHeaderHistoryService;
import com.huaheng.pc.shipment.shipmentDetail.domain.ShipmentDetail;
import com.huaheng.pc.shipment.shipmentDetail.service.ShipmentDetailService;
import com.huaheng.pc.shipment.shipmentDetailHistory.domain.ShipmentDetailHistory;
import com.huaheng.pc.shipment.shipmentDetailHistory.service.ShipmentDetailHistoryService;
import com.huaheng.pc.shipment.shipmentHeader.domain.ShipmentHeader;
import com.huaheng.pc.shipment.shipmentHeader.mapper.ShipmentHeaderMapper;
import com.huaheng.pc.shipment.shipmentHeader.service.ShipmentHeaderService;
import com.huaheng.pc.shipment.shipmentHeaderHistory.domain.ShipmentHeaderHistory;
import com.huaheng.pc.shipment.shipmentHeaderHistory.service.ShipmentHeaderHistoryService;

import com.huaheng.pc.task.taskDetail.domain.TaskDetail;
import com.huaheng.pc.task.taskDetail.service.TaskDetailService;
import io.swagger.annotations.ApiOperation;

import org.springframework.beans.BeanUtils;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.transaction.annotation.Transactional;

import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;

import java.math.BigDecimal;

import java.util.ArrayList;
import java.util.List;
import java.util.Objects;

@RestController
@RequestMapping("/api/mes/v2")
public class MesController extends BaseController {

    @Resource
    private SearchInventoryService searchInventoryService;
    @Resource
    private ReceiptHeaderService receiptHeaderService;
    @Resource
    private ReceiptHeaderHistoryService receiptheaderhistoryService;
    @Resource
    private ReceiptDetailHistoryService receiptDetailHistoryService;
    @Resource
    private ReceiptDetailService receiptDetailService;
    @Resource
    private ReceiptHeaderMapper receiptHeaderMapper;
    @Resource
    private ShipmentHeaderService shipmentHeaderService;
    @Resource
    private ShipmentDetailService shipmentDetailService;
    @Resource
    private ShipmentHeaderMapper shipmentHeaderMapper;
    @Resource
    private ShipmentHeaderHistoryService shipmentHeaderHistoryService;
    @Resource
    private ShipmentDetailHistoryService shipmentDetailHistoryService;

    @Resource
    private ReceiptTypeService receiptTypeService;

    @Autowired
    private MaterialService materialService;
    @Resource
    private ShipmentTypeService shipmentTypeService;

    @Resource
    private CycleCountHeaderService cycleCountHeaderService;
    @Resource
    private CycleCountDetailService cycleCountDetailService;
    @Resource
    private InventoryDetailService inventoryDetailService;
    @Resource
    private AdjustDetailService adjustDetailService;

    @Resource
    private TaskDetailService taskDetailService;

    /**
     * 查询库存
     */
    @PostMapping("/searchInventory")

    @ApiLogger(from = "mes", apiName = "查询库存")

    @ResponseBody
    public AjaxResult searchInventory(@RequestBody SearchInventoryDomain domain) {

        List<SearchInventoryVo> vo = searchInventoryService.searchInventory(domain.getMaterialCode(), domain.getMaterialName());

        return AjaxResult.success(vo);
    }

    /**
     * 入库单
     */
    @PostMapping("/receipt")

    @Transactional(rollbackFor = Exception.class)

    @ResponseBody

    @ApiLogger(from = "mes", apiName = "入库单")

    public AjaxResult receipt(@RequestBody ReceiptDomain domain) {

        ReceiptHeader receiptHeader = new ReceiptHeader();
        List<ReceiptDetail> list = new ArrayList<>();
        List<ReceiptDetails> receiptDetails = domain.getReceiptDetails();

        //入库单类型表是否有此MES单据类型

        List<ReceiptType> lst = receiptTypeService.list();

        if (lst.stream().noneMatch(w -> String.valueOf(w.getCode()).equals(domain.getReceiptType()))) {
            return AjaxResult.error("没有对应的入库单类型");

        }

        //入库单头表是否已存在此MES单据单号   唯一校验
        List<ReceiptHeader> headerList = receiptHeaderService.list();

        if (headerList.stream().anyMatch(w -> String.valueOf(w.getMesCode()).equals(domain.getReceiptHeader()))) {
            return AjaxResult.error("MES单据单号已存在");

        }
        List<ReceiptDetail> detailList = receiptDetailService.list();
        List<Material> material = materialService.list();
        BigDecimal totalQty = BigDecimal.ZERO;
        String warehouseCode = null;
        for (ReceiptDetails details : receiptDetails) {
            //出库单详情的物料批次为空

            if (details.getMaterialBatch() == null) {

                return AjaxResult.error("物料批次为空，新增失败");
            }
            //出库单详情的仓库编码为空

            if (details.getWarehouseCode() == null) {

                return AjaxResult.error("仓库编码为空，新增失败");
            }
            //出库单详情的条码数量为空

            if (details.getTotalQty() == null) {

                return AjaxResult.error("条码数量为空，新增失败");
            }
            //出库单详情的物料名称为空

            if (details.getMaterialName() == null) {

                return AjaxResult.error("物料名称为空，新增失败");
            }
            //出库单详情的物料条码为空

            if (details.getMaterialID() == null) {

                return AjaxResult.error("物料条码为空，新增失败");
            }
            //物料表是否有此MES单据明细中的物料编码

            if (material.stream().noneMatch(w -> String.valueOf(w.getCode()).equals(details.getMaterialCode())) || details.getMaterialCode() == null) {
                return AjaxResult.error("没有对应的物料");

            }
            //入库单详情表是否已存在此MES单据明细中的物料条码     唯一校验

            if (detailList.stream().anyMatch(w -> String.valueOf(w.getMaterialID()).equals(details.getMaterialID()))) {
                return AjaxResult.error("物料条码已存在");

            }
            totalQty = totalQty.add(details.getTotalQty());
            warehouseCode = details.getWarehouseCode();
        }

        String code = receiptHeaderService.createCode(domain.getReceiptType());
        if (StringUtils.isEmpty(code)) {
            throw new ServiceException("根据单据类型" + domain.getReceiptType() + "生成单号失败");
        }
        receiptHeader.setMesCode(domain.getReceiptHeader());
        receiptHeader.setCode(code);
        receiptHeader.setReceiptType(domain.getReceiptType());
        receiptHeader.setCompanyCode(QuantityConstant.COMPANYCODE);

        receiptHeader.setWarehouseCode(warehouseCode);

        receiptHeader.setFirstStatus(QuantityConstant.RECEIPT_HEADER_BUILD);
        receiptHeader.setLastStatus(QuantityConstant.RECEIPT_HEADER_BUILD);
        receiptHeader.setTotalQty(totalQty);
        receiptHeader.setTotalLines(receiptDetails.size());

        receiptHeader.setCreatedBy(QuantityConstant.PLATFORM_MES);
        receiptHeader.setLastUpdatedBy(QuantityConstant.PLATFORM_MES);

        if (receiptHeaderService.save(receiptHeader)) {

            ReceiptHeader header = receiptHeaderMapper.getByOrderHeader(domain.getReceiptHeader());
            for (ReceiptDetails details : receiptDetails) {
                ReceiptDetail receiptDetail = new ReceiptDetail();
                receiptDetail.setReceiptId(header.getId());
                receiptDetail.setReceiptCode(header.getCode());

                receiptDetail.setWarehouseCode(details.getWarehouseCode());

                receiptDetail.setCompanyCode(QuantityConstant.COMPANYCODE);
                receiptDetail.setMaterialCode(details.getMaterialCode());
                receiptDetail.setMaterialName(details.getMaterialName());
                receiptDetail.setBatch(details.getMaterialBatch());

                receiptDetail.setMesCode(header.getMesCode());
                receiptDetail.setMaterialID(details.getMaterialID());

                receiptDetail.setQty(details.getTotalQty());

                receiptDetail.setInventorySts(QuantityConstant.GOOD);
                receiptDetail.setCreatedBy(QuantityConstant.PLATFORM_MES);
                receiptDetail.setLastUpdatedBy(QuantityConstant.PLATFORM_MES);

                list.add(receiptDetail);
            }

        } else {

            return AjaxResult.error("新增入库单头表失败");
        }
        return AjaxResult.success(receiptDetailService.saveBatch(list));

    }

    /**
     * 出库单
     */
    @PostMapping("/shipment")
    @ResponseBody

    @Transactional(rollbackFor = Exception.class)

    @ApiLogger(from = "mes", apiName = "出库单")

    public AjaxResult shipment(@RequestBody ShipmentDomain domain) {

        ShipmentHeader shipmentHeader = new ShipmentHeader();
        List<ShipmentDetail> list = new ArrayList<>();
        List<ShipmentDetails> shipmentDetails = domain.getShipmentDetails();
        //出库单类型表是否有此MES单据类型
        List<ShipmentType> lst = shipmentTypeService.list();

        if (lst.stream().noneMatch(w -> String.valueOf(w.getCode()).equals(domain.getShipmentType()))) {
            return AjaxResult.error("没有对应的出库单类型");

        }
        //出库单头表是否已存在此MES单据单号   唯一校验
        List<ShipmentHeader> headerList = shipmentHeaderService.list();

        if (headerList.stream().anyMatch(w -> String.valueOf(w.getMesCode()).equals(domain.getShipmentHeader()))) {
            return AjaxResult.error("MES单据单号已存在");

        }
        String warehouseCode = null;
        BigDecimal qty = BigDecimal.ZERO;
        List<Material> material = materialService.list();
        for (ShipmentDetails details : shipmentDetails) {

            //物料表是否有此MES单据明细中的物料编码
            if (details.getMaterialCode() == null || material.stream().noneMatch(w -> String.valueOf(w.getCode()).equals(details.getMaterialCode()))) {
                return AjaxResult.error("没有对应的物料");
            }
            //出库单详情的仓库编码为空
            if (details.getWarehouseCode() == null) {
                return AjaxResult.error("仓库编码为空，新增失败");
            }
            //出库单详情的条码数量为空
            if (details.getTotalQty() == null) {
                return AjaxResult.error("条码数量为空，新增失败");
            }
            //出库单详情的物料名称为空
            if (details.getMaterialName() == null) {
                return AjaxResult.error("物料名称为空，新增失败");
            }

            qty = qty.add(details.getTotalQty());
            warehouseCode = details.getWarehouseCode();
        }
        String code = shipmentHeaderService.createCode(domain.getShipmentType());
        shipmentHeader.setFirstStatus(QuantityConstant.RECEIPT_HEADER_BUILD);
        shipmentHeader.setLastStatus(QuantityConstant.RECEIPT_HEADER_BUILD);
        shipmentHeader.setLastUpdatedBy(QuantityConstant.PLATFORM_MES);
        shipmentHeader.setCreatedBy(QuantityConstant.PLATFORM_MES);

        shipmentHeader.setCompanyCode(QuantityConstant.COMPANYCODE);
        shipmentHeader.setShipmentType(domain.getShipmentType());
        shipmentHeader.setMesCode(domain.getShipmentHeader());

        shipmentHeader.setWarehouseCode(warehouseCode);

        shipmentHeader.setTotalQty(qty);
        shipmentHeader.setTotalLines(shipmentDetails.size());

        shipmentHeader.setCode(code);

        if (shipmentHeaderService.save(shipmentHeader)) {

            ShipmentHeader header = shipmentHeaderMapper.getByOrderHeader(domain.getShipmentHeader());
            for (ShipmentDetails details : shipmentDetails) {
                ShipmentDetail detail = new ShipmentDetail();
                detail.setShipmentId(header.getId());
                detail.setShipmentCode(header.getCode());
                detail.setCreatedBy(QuantityConstant.PLATFORM_MES);
                detail.setLastUpdatedBy(QuantityConstant.PLATFORM_MES);
                detail.setWarehouseCode(details.getWarehouseCode());
                detail.setMesCode(domain.getShipmentHeader());
                detail.setInventorySts(QuantityConstant.GOOD);
                detail.setCompanyCode(QuantityConstant.COMPANYCODE);
                detail.setMaterialName(details.getMaterialName());
                detail.setMaterialCode(details.getMaterialCode());

                detail.setQty(details.getTotalQty());

                list.add(detail);
            }

        } else {

            return AjaxResult.error("新增入库单头表失败");
        }
        return AjaxResult.success(shipmentDetailService.saveBatch(list));

    }

    /**

     *  入库回传
     */
    @PostMapping("/backReceipt")
    @ResponseBody
    @ApiLogger(from = "mes", apiName = "入库回传")
    public AjaxResult backReceipt(String id) {
        if (StringUtils.isEmpty(id)){
            return AjaxResult.error("id不能为空");
        }
        ReceiptHeader receiptHeader = receiptHeaderService.getById(id);
        if(receiptHeader == null) {
            return AjaxResult.error("没有找到入库单");
        }
        LambdaQueryWrapper<TaskDetail> query = Wrappers.lambdaQuery();
        query.eq(TaskDetail::getBillCode, receiptHeader.getCode());
        List<TaskDetail> list = taskDetailService.list(query);
        ReceiptDomain domain = new ReceiptDomain();
        List<ReceiptDetails> lst = new ArrayList<>();
        for (TaskDetail taskDetail : list) {
            ReceiptDetails details = new ReceiptDetails();
            details.setMaterialID(taskDetail.getMaterialID());
            details.setMaterialCode(taskDetail.getMaterialCode());
            details.setMaterialName(taskDetail.getMaterialName());
            details.setTotalQty(taskDetail.getQty());
            lst.add(details);
        }
        domain.setReceiptHeader(receiptHeader.getMesCode());
        domain.setReceiptType(receiptHeader.getReceiptType());
        domain.setReceiptDetails(lst);
        receiptHeader.setFirstStatus(QuantityConstant.RECEIPT_HEADER_RETURN);
        receiptHeader.setLastStatus(QuantityConstant.RECEIPT_HEADER_RETURN);
        receiptHeaderService.updateById(receiptHeader);

        return AjaxResult.success(domain);
    }


    /**
     *	出库回传
     */
    @PostMapping( "/backShipment")
    @ResponseBody
    @ApiLogger(from = "mes", apiName = "出库回传")
    public AjaxResult backShipment(String id){
        if (StringUtils.isEmpty(id)) {
            return AjaxResult.error("id不能为空");
        }
        ShipmentHeader shipmentHeader = shipmentHeaderService.getById(id);
        if (shipmentHeader == null) {
            return AjaxResult.error("没有找到出库单");
        }
        LambdaQueryWrapper<TaskDetail> query = Wrappers.lambdaQuery();
        query.eq(TaskDetail::getBillCode, shipmentHeader.getCode());
        List<TaskDetail> list = taskDetailService.list(query);
        ShipmentDomain domain = new ShipmentDomain();
        List<ShipmentDetails> lst = new ArrayList<>();
        for (TaskDetail detail : list) {
            ShipmentDetails details = new ShipmentDetails();
            details.setTotalQty(detail.getQty());
            details.setMaterialCode(detail.getMaterialCode());
            details.setMaterialName(detail.getMaterialName());
            details.setMaterialId(detail.getMaterialID());
            lst.add(details);
        }
        domain.setShipmentHeader(shipmentHeader.getMesCode());
        domain.setShipmentType(shipmentHeader.getShipmentType());
        domain.setShipmentDetails(lst);
        shipmentHeader.setFirstStatus(QuantityConstant.SHIPMENT_HEADER_RETURN);
        shipmentHeader.setLastStatus(QuantityConstant.SHIPMENT_HEADER_RETURN);
        shipmentHeaderService.updateById(shipmentHeader);
        return AjaxResult.success(domain);
    }

    /**

     * 盘点结果
     */
    @PostMapping("/checkInventory")
    @ResponseBody

    @ApiLogger(from = "mes", apiName = "盘点结果")

    public AjaxResult checkInventory(String code) {
        CheckInventoryVo vo = new CheckInventoryVo();
        LambdaQueryWrapper<CycleCountHeader> query = Wrappers.lambdaQuery();
        query.eq(CycleCountHeader::getCode, code);
        CycleCountHeader cycleCountHeader = cycleCountHeaderService.getOne(query);
        if (cycleCountHeader == null){
            return AjaxResult.error("未找到盘点单");
        }
        CycleCountDetail cycleCountDetail = cycleCountDetailService.getById(cycleCountHeader.getId());
        List<OrderDetails> list = new ArrayList<>();
        if (cycleCountHeader.getStatusCyc() == 100){
            LambdaQueryWrapper<InventoryDetail> inventory = Wrappers.lambdaQuery();
            inventory.eq(InventoryDetail::getContainerCode, cycleCountDetail.getContainerCode());
            List<InventoryDetail> lst = inventoryDetailService.list(inventory);
            for (InventoryDetail detail : lst) {
                OrderDetails details = new OrderDetails();
                details.setMaterialCode(detail.getMaterialCode());
                details.setMaterialName(detail.getMaterialName());
                details.setMaterialBatch(detail.getBatch());
                details.setTotalQty(detail.getQty());
                details.setMaterialID(null);
                list.add(details);
            }
            vo.setOrderHeader(code);
            vo.setOrderDetails(list);
        }else if(cycleCountHeader.getStatusCyc() == 110){
            LambdaQueryWrapper<AdjustDetail> queryWrapper = Wrappers.lambdaQuery();
            queryWrapper.eq(AdjustDetail::getCycleCountHeaderCode, code);
            List<AdjustDetail> details = adjustDetailService.list(queryWrapper);
            for (AdjustDetail detail : details) {
                if (detail.getStatus() != 3){
                   return AjaxResult.error("盘点单编码" + code + "有未调整的单据");
                }
                OrderDetails details1 = new OrderDetails();
                details1.setMaterialID(null);
                details1.setMaterialName(detail.getMaterialName());
                details1.setMaterialCode(detail.getMaterialCode());
                details1.setMaterialBatch(detail.getBatch());
                details1.setTotalQty(detail.getToQty());
                list.add(details1);
            }
            vo.setOrderHeader(code);
            vo.setOrderDetails(list);
        }
        if (vo.getOrderDetails().size() > 0){
            LambdaQueryWrapper<CycleCountHeader> queryWrapper = Wrappers.lambdaQuery();
            queryWrapper.eq(CycleCountHeader::getCode, code);
            cycleCountHeader.setCheckStatus(1);
            cycleCountHeaderService.update(cycleCountHeader,queryWrapper);
        }
        return AjaxResult.success(vo);
    }

    /**

     * 单据取消
     */
    @PostMapping("/cancelOrder")
    @ResponseBody

    @ApiLogger(from = "mes", apiName = "单据取消")

    public AjaxResult cancelOrder(@RequestBody CancelOrderDomain domain) {

        if ("receipt".equals(domain.getOrderType())) {

            ReceiptHeader receiptHeader = receiptHeaderMapper.getByOrderHeader(domain.getOrderHeader());
            if (receiptHeader == null) {
                return AjaxResult.error("没有找到单据" + domain.getOrderHeader());
            }

            if (!Objects.equals(receiptHeader.getFirstStatus(), QuantityConstant.RECEIPT_HEADER_BUILD)) {

                return AjaxResult.error("非新建单据不能取消");
            }
            LambdaQueryWrapper<ReceiptDetail> lambdaQueryWrapper = Wrappers.lambdaQuery();
            lambdaQueryWrapper.eq(ReceiptDetail::getReceiptId, receiptHeader.getId());
            List<ReceiptDetail> list = receiptDetailService.list(lambdaQueryWrapper);
            List<ReceiptDetailHistory> receiptDetailHistoryList = new ArrayList<>();
            if (!receiptHeaderService.removeById(receiptHeader)) {
                throw new ServiceException("删除头表失败");
            }
            List<Integer> receiptDetailIds = new ArrayList<>();
            ReceiptHeaderHistory receiptHeaderHistory = new ReceiptHeaderHistory();
            BeanUtils.copyProperties(receiptHeader, receiptHeaderHistory);
            if (!receiptheaderhistoryService.save(receiptHeaderHistory)) {
                throw new ServiceException("新增历史头表失败");
            }

            for (ReceiptDetail receiptDetail : list) {

                receiptDetailIds.add(receiptDetail.getId());
                ReceiptDetailHistory receiptDetailHistory = new ReceiptDetailHistory();
                BeanUtils.copyProperties(receiptDetail, receiptDetailHistory);
                receiptDetailHistory.setReceiptId(receiptHeaderHistory.getId());
                receiptDetailHistoryList.add(receiptDetailHistory);
            }

            if (receiptDetailIds.size() > 0) {

                if (!receiptDetailService.removeByIds(receiptDetailIds)) {
                    throw new ServiceException("删除明细表失败");
                }
            }

            if (receiptDetailHistoryList.size() > 0) {

                if (!receiptDetailHistoryService.saveBatch(receiptDetailHistoryList)) {
                    throw new ServiceException("新增历史入库明细失败");
                }
            }

        } else if ("shipment".equals(domain.getOrderType())) {

            ShipmentHeader shipmentHeader = shipmentHeaderMapper.getByOrderHeader(domain.getOrderHeader());

            if (shipmentHeader == null) {

                return AjaxResult.error("没有找到单据" + domain.getOrderHeader());
            }

            if (!Objects.equals(shipmentHeader.getFirstStatus(), QuantityConstant.RECEIPT_HEADER_BUILD)) {

                return AjaxResult.error("非新建单据不能取消");
            }
            LambdaQueryWrapper<ShipmentDetail> lambdaQueryWrapper = Wrappers.lambdaQuery();
            lambdaQueryWrapper.eq(ShipmentDetail::getShipmentId, shipmentHeader.getId());
            List<ShipmentDetail> list = shipmentDetailService.list(lambdaQueryWrapper);
            List<ShipmentDetailHistory> shipmentDetailHistories = new ArrayList<>();
            List<Integer> shipmentDetailIds = new ArrayList<>();

            if (!shipmentHeaderService.removeById(shipmentHeader)) {
                throw new ServiceException("删除头表失败");
            }

            ShipmentHeaderHistory shipmentHeaderHistory = new ShipmentHeaderHistory();
            BeanUtils.copyProperties(shipmentHeader, shipmentHeaderHistory);

            if (!shipmentHeaderHistoryService.save(shipmentHeaderHistory)) {
                throw new ServiceException("新增历史头表失败");
            }
            for (ShipmentDetail shipmentDetail : list) {
                shipmentDetailIds.add(shipmentDetail.getId());
                ShipmentDetailHistory shipmentDetailHistory = new ShipmentDetailHistory();
                BeanUtils.copyProperties(shipmentDetail, shipmentDetailHistory);
                shipmentDetailHistory.setShipmentId(shipmentHeaderHistory.getId());
                shipmentDetailHistories.add(shipmentDetailHistory);
            }

            if (shipmentDetailIds.size() > 0) {

                if (!shipmentDetailService.removeByIds(shipmentDetailIds)) {
                    throw new ServiceException("删除明细表失败");
                }
            }

            if (shipmentDetailHistories.size() > 0) {

                if (!shipmentDetailHistoryService.saveBatch(shipmentDetailHistories)) {
                    throw new ServiceException("新增历史出库明细失败");
                }
            }

        } else {

            return AjaxResult.error("没有找到此类型的单据" + domain.getOrderType());
        }
        return AjaxResult.success("取消成功");
    }
}