package com.huaheng.mobile.receipt;

import com.alibaba.fastjson.JSONException;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.huaheng.api.general.domain.ReceiptDomain;
import com.huaheng.common.constant.QuantityConstant;
import com.huaheng.common.exception.service.ServiceException;
import com.huaheng.common.utils.StringUtils;
import com.huaheng.common.utils.security.ShiroUtils;
import com.huaheng.framework.aspectj.lang.annotation.Log;
import com.huaheng.framework.aspectj.lang.constant.BusinessType;
import com.huaheng.framework.web.domain.AjaxResult;
import com.huaheng.pc.config.company.service.CompanyService;
import com.huaheng.pc.config.container.domain.Container;
import com.huaheng.pc.config.container.service.ContainerService;
import com.huaheng.pc.config.location.domain.Location;
import com.huaheng.pc.config.location.service.LocationService;
import com.huaheng.pc.config.material.domain.Material;
import com.huaheng.pc.config.material.service.MaterialService;
import com.huaheng.pc.receipt.receiptContainerDetail.domain.ReceiptContainerDetail;
import com.huaheng.pc.receipt.receiptContainerDetail.service.ReceiptContainerDetailService;
import com.huaheng.pc.receipt.receiptContainerHeader.domain.ReceiptContainerHeader;
import com.huaheng.pc.receipt.receiptContainerHeader.domain.ReceiptContainerView;
import com.huaheng.pc.receipt.receiptContainerHeader.service.ReceiptContainerHeaderService;
import com.huaheng.pc.receipt.receiptDetail.domain.ReceiptDetail;
import com.huaheng.pc.receipt.receiptDetail.service.ReceiptDetailService;
import com.huaheng.pc.receipt.receiptHeader.domain.ReceiptHeader;
import com.huaheng.pc.receipt.receiptHeader.service.ReceiptHeaderService;
import com.huaheng.pc.task.taskDetail.domain.TaskDetail;
import com.huaheng.pc.task.taskDetail.service.TaskDetailService;
import com.huaheng.pc.task.taskHeader.domain.TaskHeader;
import com.huaheng.pc.task.taskHeader.service.TaskHeaderService;
import groovy.json.JsonException;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import java.math.BigDecimal;
import java.util.Date;
import java.util.List;
import java.util.Map;

/**
 *
 * @author Enzo Cotter
 * @date 2019/12/15
 */
@CrossOrigin
@RestController
@RequestMapping("/mobile/receipt/batch")
@Api(tags = {"MobileBatchReceiptController"}, description = "移动端收货")
public class MobileBatchReceiptController {

    @Resource
    private ReceiptContainerHeaderService receiptContainerHeaderService;
    @Resource
    private ReceiptHeaderService receiptHeaderService;
    @Resource
    private ReceiptDetailService receiptDetailService;
    @Resource
    private ReceiptContainerDetailService receiptContainerDetailService;
    @Resource
    private ContainerService containerService;
    @Resource
    private MaterialService materialService;
    @Resource
    private LocationService locationService;
    @Resource
    private TaskHeaderService taskHeaderService;
    @Resource
    private TaskDetailService taskDetailService;
    @Resource
    private CompanyService companyService;

    @PostMapping("/scanBill")
    @ApiOperation("移动端扫描入库单")
    @Log(title = "移动端扫描入库单", action = BusinessType.OTHER)
    public AjaxResult scanBill(@RequestBody @ApiParam(value = "收货单号") Map<String, String> param) throws Exception {
        if (param.get("code") == null || param.get("code").trim().length() < 1) {
            throw new JSONException("收货单号(code)不能为空");
        } else if (StringUtils.isEmpty(param.get("type"))) {
            throw new JsonException("入库单类型不能为空");
        } else if (StringUtils.isEmpty(param.get("companyCode"))) {
            throw new JsonException("库存组织不能为空");
        }
        return receiptDetailService.scanReceiptCode(param.get("code"), param.get("type"), param.get("companyCode"));
    }

    @PostMapping("/scanContainer")
    @ApiOperation("移动端入库扫描容器")
    @Log(title = "移动端入库扫描容器", action = BusinessType.OTHER)
    public AjaxResult scanContainer(@RequestBody @ApiParam(value = "容器号") Map<String, String> param) throws Exception {
        if (param.get("code") == null || param.get("code").trim().length() < 1) {
            throw new JSONException("容器号(code)不能为空");
        }

        ReceiptContainerView receiptContainerView = new ReceiptContainerView();
        receiptContainerView.setReceiptContainerCode(param.get("code"));
        receiptContainerView.setTaskType((short) 100);
        AjaxResult result = receiptContainerHeaderService.checkContainer(receiptContainerView);
        LambdaQueryWrapper<Container> containerLambdaQueryWrapper = Wrappers.lambdaQuery();
        containerLambdaQueryWrapper.eq(Container::getCode, param.get("code"));
        Container container = containerService.getOne(containerLambdaQueryWrapper);
        if (container == null) {
            return AjaxResult.error("托盘编码错误");
        }
        if (!container.getStatus().equals("empty")) {
            return AjaxResult.error("托盘状态不为空");
        }
        if (!container.getLocationCode().equals("")) {
            return AjaxResult.error("");
        }
        return result;
    }

    @PostMapping("/save")
    @ApiOperation("移动端收货保存")
    @Log(title = "移动端收货保存", action = BusinessType.OTHER)
    public AjaxResult save(@RequestBody @ApiParam(value = "收货单") List<ReceiptContainerView> record) throws Exception {
        AjaxResult result = receiptContainerHeaderService.batchSave(record);
        return result;
    }

    @PostMapping("/getMaterial")
    @ApiOperation("移动端获取物料信息")
    @Log(title = "移动端获取物料信息", action = BusinessType.OTHER)
    public AjaxResult getMaterial(@RequestBody @ApiParam(value = "物料号") Map<String, String> param) throws Exception {
        if (param.get("code") == null || param.get("code").trim().length() < 1) {
            throw new JSONException("容器号(code)不能为空");
        }
        Material material = materialService.findAllByCode(param.get("code"));
        if (material == null) {
            return AjaxResult.error("没有该物料");
        }
        MaterialInfo materialInfo = new MaterialInfo();
        materialInfo.setMaterialCode(material.getCode());
        materialInfo.setMaterialName(material.getName());
        materialInfo.setType(material.getSpec());

        return AjaxResult.success(materialInfo);
    }

    @PostMapping("/getLatestMaterial")
    @ApiOperation("移动端获取物料信息")
    @Log(title = "移动端获取物料信息", action = BusinessType.OTHER)
    public AjaxResult getLatestMaterial(@RequestBody @ApiParam(value = "物料号") Map<String, String> param) throws Exception {
        List<Material> materials = materialService.findLatest();
        if (materials == null) {
            return AjaxResult.error("没有找到物料");
        }

        return AjaxResult.success(materials);
    }

    @PostMapping("/getLatestReceipt")
    @ApiOperation("移动端获取入库单")
    @Log(title = "移动端获取入库单", action = BusinessType.OTHER)
    public AjaxResult getLatestReceipt(@RequestBody @ApiParam(value = "物料号") Map<String, String> param) throws Exception {
        String companyCode = param.get("companyCode");
        List<ReceiptHeader> receiptHeaders = receiptHeaderService.getLatestReceipt(companyCode);
        if (receiptHeaders == null) {
            return AjaxResult.error("没有找到入库单");
        }
        return AjaxResult.success(receiptHeaders);
    }



    @PostMapping("/checkLocation")
    @ApiOperation("移动端验证库位")
    @Log(title = "移动端验证库位", action = BusinessType.OTHER)
    public AjaxResult checkLocation(@RequestBody @ApiParam(value = "物料号") Map<String, String> param) throws Exception {
        if (param.get("code") == null || param.get("code").trim().length() < 1) {
            throw new JSONException("容器号(code)不能为空");
        }

        boolean result = locationService.checkLocation(param.get("code"));
        if (!result) {
            return AjaxResult.error("没有该库位");
        }
        return AjaxResult.success(result);
    }

    @PostMapping("/getFreeLocation")
    @ApiOperation("移动端获得空闲库位")
    @Log(title = "移动端获得空闲库位", action = BusinessType.OTHER)
    public AjaxResult getFreeLocation(@RequestBody @ApiParam(value = "物料号") Map<String, String> param) throws Exception {
        if (param.get("materialCode") == null || param.get("materialCode").trim().length() < 1) {
            throw new JSONException("materialCode不能为空");
        }

        if (param.get("batch") == null || param.get("batch").trim().length() < 1) {
            throw new JSONException("batch不能为空");
        }
        String materialCode = param.get("materialCode");
        String batch = param.get("batch");
        boolean result = locationService.getFreeLocation(materialCode, batch);
        if (!result) {
            return AjaxResult.error("没有空闲的分区库位");
        }
        return AjaxResult.success(result);
    }

    @PostMapping("/getContainerCode")
    @ApiOperation("移动端验证库位")
    @Log(title = "移动端验证库位", action = BusinessType.OTHER)
    public AjaxResult getContainerCode(@RequestBody @ApiParam(value = "物料号") Map<String, String> param) throws Exception {
        if (param.get("code") == null || param.get("code").trim().length() < 1) {
            throw new JSONException("容器号(code)不能为空");
        }
        LambdaQueryWrapper<Location> queryWrapper = Wrappers.lambdaQuery();
        queryWrapper.eq(Location::getCode, param.get("code"))
                .eq(Location::getWarehouseCode, ShiroUtils.getWarehouseCode())
                .eq(Location::getDeleted, false);
        Location location = locationService.getOne(queryWrapper);
        if (location == null) {
            return AjaxResult.error("没有该库位");
        }
        return AjaxResult.success("成功", location.getContainerCode());
    }

    @PostMapping("/quickReceipt")
    @ApiOperation("移动端收货保存")
    @Log(title = "移动端收货保存", action = BusinessType.OTHER)
    @Transactional(rollbackFor = Exception.class)
    public AjaxResult quickReceipt(@RequestBody @ApiParam(value="收货单") List<ReceiptBill> receiptBills) throws Exception {
        if (receiptBills == null || receiptBills.size() <=0) {
            throw new JSONException("没有收货信息");
        }
        String containerCode = receiptBills.get(0).receiptContainerCode;
        String locationCode = receiptBills.get(0).locationCode;
        String companyCode = receiptBills.get(0).getCompanyCode();
        String receiptDetailId = receiptBills.get(0).getReceiptDetailId();

        LambdaQueryWrapper<Container> containerQueryWrapper = Wrappers.lambdaQuery();
        containerQueryWrapper.eq(Container::getCode, containerCode);
        Container container = containerService.getOne(containerQueryWrapper);
        if(container == null) {
            throw new JSONException("不存在这个托盘");
        }
        if(locationCode.equals(container.getLocationCode())) {
            /* 查询未完成的入库任务*/
            LambdaQueryWrapper<TaskHeader> taskQueryWrapper = Wrappers.lambdaQuery();
            taskQueryWrapper.eq(TaskHeader::getWarehouseCode, ShiroUtils.getWarehouseCode())
                    .in(TaskHeader::getTaskType, QuantityConstant.TASK_TYPE_WHOLERECEIPT,
                            QuantityConstant.TASK_TYPE_SUPPLEMENTRECEIPT)
                    .lt(TaskHeader::getStatus, 100)
                    .eq(TaskHeader::getContainerCode, containerCode);
            TaskHeader taskHeader = taskHeaderService.getOne(taskQueryWrapper);
            if(taskHeader == null) {
                throw new JSONException("没有找到托盘对应的任务");
            }

            LambdaQueryWrapper<ReceiptDetail> receiptDetailQueryWrapper = Wrappers.lambdaQuery();
            receiptDetailQueryWrapper.eq(ReceiptDetail::getId, receiptDetailId);
            ReceiptDetail receiptDetail = receiptDetailService.getOne(receiptDetailQueryWrapper);
            if(receiptDetail == null) {
                throw new JSONException("没有找到入库单详情");
            }

            LambdaQueryWrapper<ReceiptHeader> receiptHeaderQueryWrapper = Wrappers.lambdaQuery();
            receiptHeaderQueryWrapper.eq(ReceiptHeader::getId, receiptDetail.getReceiptId());
            ReceiptHeader receiptHeader = receiptHeaderService.getOne(receiptHeaderQueryWrapper);
            if(receiptHeader == null) {
                throw new JSONException("没有找到入库单");
            }

            LambdaQueryWrapper<ReceiptContainerHeader> lambda = Wrappers.lambdaQuery();
            lambda.eq(ReceiptContainerHeader::getContainerCode, containerCode)
                    .lt(ReceiptContainerHeader::getStatus, QuantityConstant.RECEIPT_CONTAINER_FINISHED);
            List<ReceiptContainerHeader> list = receiptContainerHeaderService.list(lambda);
            if (list.size() >= 1){
                throw new ServiceException("容器已经生成任务，不能放物料了！");
            }
            ReceiptContainerHeader receiptContainerHeader = new ReceiptContainerHeader();
            //如果不存在记录则新建记录
            receiptContainerHeader.setWarehouseCode(ShiroUtils.getWarehouseCode());
            receiptContainerHeader.setCompanyCode(companyCode);
            receiptContainerHeader.setContainerCode(containerCode);
            Container container2 = containerService.findAllByCode(containerCode);
            receiptContainerHeader.setContainerType(container2.getContainerType());
            receiptContainerHeader.setTaskType(String.valueOf(QuantityConstant.TASK_TYPE_SUPPLEMENTRECEIPT));
            receiptContainerHeader.setFromLocation(container2.getLocationCode());
            receiptContainerHeader.setToLocation(locationCode);
            receiptContainerHeader.setCreatedBy(ShiroUtils.getLoginName());
            receiptContainerHeader.setLastUpdatedBy(ShiroUtils.getLoginName());
            receiptContainerHeader.setStatus((short)10);

            if (!receiptContainerHeaderService.save(receiptContainerHeader)){
                throw new ServiceException("入库组盘头表保存失败");
            }

            receiptHeader.setFirstStatus(QuantityConstant.RECEIPT_HEADER_RECEIVING);
            receiptHeader.setLastStatus(QuantityConstant.RECEIPT_HEADER_RECEIVING);
            receiptHeaderService.update(receiptHeader, receiptHeaderQueryWrapper);

            taskHeader.setAllocationHeadId(receiptContainerHeader.getId());
            taskHeaderService.update(taskHeader, taskQueryWrapper);

            for(ReceiptBill receiptBill : receiptBills) {
                TaskDetail taskDetail = new TaskDetail();
                taskDetail.setTaskId(taskHeader.getId());
                taskDetail.setContainerCode(containerCode);
                taskDetail.setTaskType(taskHeader.getTaskType());
                taskDetail.setInternalTaskType(taskHeader.getInternalTaskType());
                taskDetail.setWarehouseCode(ShiroUtils.getWarehouseCode());
                taskDetail.setCompanyCode(companyCode);
                taskDetail.setBillCode(receiptHeader.getCode());
                taskDetail.setBillDetailId(Integer.parseInt(receiptBill.getReceiptDetailId()));
                taskDetail.setMaterialCode(receiptBill.getMaterialCode());
                taskDetail.setMaterialName(receiptBill.getMaterialName());
                taskDetail.setQty(receiptBill.getQty());
                taskDetail.setFromLocation(taskHeader.getFromLocation());
                taskDetail.setToLocation(taskHeader.getToLocation());
                taskDetail.setStatus(taskHeader.getStatus());
                taskDetail.setBatch(receiptBill.getBatch());
                taskDetail.setCompanyCode(taskHeader.getCompanyCode());
                taskDetailService.save(taskDetail);


                LambdaQueryWrapper<ReceiptDetail> receiptDetail2QueryWrapper = Wrappers.lambdaQuery();
                receiptDetail2QueryWrapper.eq(ReceiptDetail::getId, receiptBill.getReceiptDetailId());
                ReceiptDetail receiptDetail2 = receiptDetailService.getOne(receiptDetail2QueryWrapper);
                if(receiptDetail2 == null) {
                    throw new JSONException("没有找到入库单详情");
                }

                BigDecimal openQty = receiptDetail2.getOpenQty();
                BigDecimal totalQty = receiptDetail2.getTotalQty();
                BigDecimal qty = openQty.add(receiptBill.getQty());
                if(totalQty.subtract(qty).compareTo(BigDecimal.ZERO) < 0) {
                    throw new Exception("配盘数量大于表单数量");
                }

                receiptDetail2.setOpenQty(qty);
                receiptDetailService.update(receiptDetail2, receiptDetail2QueryWrapper);

                ReceiptContainerDetail receiptContainerDetail = new ReceiptContainerDetail();
                receiptContainerDetail.setReceiptContainerId(receiptContainerHeader.getId());
                receiptContainerDetail.setWarehouseCode(ShiroUtils.getWarehouseCode());
                receiptContainerDetail.setReceiptId(receiptHeader.getId());
                receiptContainerDetail.setReceiptDetailId(receiptDetail2.getId());
                receiptContainerDetail.setReceiptCode(receiptHeader.getCode());
                receiptContainerDetail.setReceiptType(receiptHeader.getReceiptType());
                receiptContainerDetail.setLocationCode(locationCode);
                receiptContainerDetail.setContainerCode(containerCode);
                receiptContainerDetail.setContainerType(container.getContainerType());
                receiptContainerDetail.setCompanyCode(companyCode);

                LambdaQueryWrapper<Material> materialQueryWrapper = Wrappers.lambdaQuery();
                materialQueryWrapper.eq(Material::getCode, receiptBill.getMaterialCode())
                                    .eq(Material::getDeleted, 0);
                Material material = materialService.getOne(materialQueryWrapper);

                receiptContainerDetail.setMaterialCode(material.getCode());
                receiptContainerDetail.setMaterialName(material.getName());
                receiptContainerDetail.setMaterialSpec(material.getSpec());
                receiptContainerDetail.setMaterialUnit(material.getUnit());
                receiptContainerDetail.setQty(receiptBill.getQty());
                receiptContainerDetail.setStatus(10);
                receiptContainerDetail.setCreatedBy(ShiroUtils.getLoginName());
                receiptContainerDetail.setLastUpdatedBy(ShiroUtils.getLoginName());
                receiptContainerDetailService.save(receiptContainerDetail);
            }

        } else {
         /*   ReceiptContainerView record = new ReceiptContainerView();
            record.setReceiptContainerCode(receiptBills.get(0).getReceiptContainerCode());
            record.setLocationCode(receiptBills.get(0).getLocationCode());
            record.setTaskType((short)100);
            record.setCompanyCode(receiptBills.get(0).getCompanyCode());
            receiptContainerHeaderService.checkContainer(record);
            receiptContainerHeaderService.mobileCheckLocationCode(record);
            int receiptHeaderId = receiptHeaderService.createTodayHeader(companyCode);
            ReceiptHeader receiptHeader = receiptHeaderService.getById(receiptHeaderId);
            List<Integer> receiptDetailIds = receiptDetailService.insertTodayReceiptDetail(receiptHeaderId, receiptBills, true, companyCode);
            if(receiptDetailIds != null && receiptDetailIds.size() > 0) {
                int containerHeaderId = receiptContainerHeaderService.insertTodayReceiptContainerHeader(receiptBills.get(0), receiptHeader.getCode());
                if(containerHeaderId > 0) {
                    List<Integer> receiptContainerDetailIds = receiptContainerDetailService.insertTodayReceiptcContainerDetail(containerHeaderId, receiptHeaderId, receiptDetailIds, receiptBills);
                    if(receiptContainerDetailIds != null && receiptContainerDetailIds.size() > 0) {

                    } else {
                        return AjaxResult.error("入库组盘失败");
                    }
                } else {
                    return AjaxResult.error("插入入库容器表单头失败");
                }
            } else {
                return AjaxResult.error("插入入库明细表单失败");
            }   */
        }
        return AjaxResult.success("收货成功");
    }

    @PostMapping("/findReceipt")
    @ApiOperation("移动端查询入库单")
    @Log(title = "移动端查询入库单", action = BusinessType.OTHER)
    public AjaxResult findReceipt(@RequestBody @ApiParam(value = "物料号") Map<String, String> param){
        String receiptCode = param.get("receiptCode");
        String companyCode = param.get("companyCode");
        if (StringUtils.isNull(receiptCode)){
            return AjaxResult.error("上游系统关联单号为空");
        } else if (StringUtils.isNull(companyCode)){
            return AjaxResult.error("公司编码为空");
        }
//        else if (StringUtils.isNull(referType)) {
//            return AjaxResult.error("上游系统关联单类型为空");
//        }

        /* 查询入库单，如果数据库中不存在，则调用ERP接口拉取单据，成功后再次查询返回结果*/
         LambdaQueryWrapper<ReceiptHeader> receiptLambdaQueryWrapper = Wrappers.lambdaQuery();
        receiptLambdaQueryWrapper.eq(ReceiptHeader::getCode, receiptCode)
                .eq(ReceiptHeader::getCompanyCode, companyCode);
        ReceiptHeader receiptHeader = receiptHeaderService.getOne(receiptLambdaQueryWrapper);
        if(receiptHeader == null) {
            return AjaxResult.error("没有找到入库单");
        }
        ReceiptDomain receipt = new ReceiptDomain();
        receipt.setReceiptHeader(receiptHeader);

        LambdaQueryWrapper<ReceiptDetail> receiptDetailQueryWrapper = Wrappers.lambdaQuery();
        receiptDetailQueryWrapper.eq(ReceiptDetail::getReceiptId, receiptHeader.getId());
        List<ReceiptDetail> receiptDetailList = receiptDetailService.list(receiptDetailQueryWrapper);
        receipt.setReceiptDetails(receiptDetailList);
        return AjaxResult.success(receipt);
    }

    @PostMapping("/callBox")
    @ApiOperation("移动端呼叫料盒")
    @Log(title = "移动端呼叫料盒", action = BusinessType.OTHER)
    @Transactional(rollbackFor = Exception.class)
    public AjaxResult callBox(@RequestBody @ApiParam(value = "物料号") Map<String, String> param)  {
        String containerCode = param.get("containerCode");
        String destinationLocation = param.get("destinationLocation");
        int type = Integer.parseInt(param.get("type"));
        String companyCode = param.get("companyCode");
        Container container = new Container();
        container.setCode(containerCode);
        container.setWarehouseCode(ShiroUtils.getWarehouseCode());
        LambdaQueryWrapper lambdaQueryWrapper = Wrappers.lambdaQuery(container);
        container = containerService.getOne(lambdaQueryWrapper);
        if(container==null) {
            return AjaxResult.error("容器不存在");
        }
        if (!StringUtils.isNotEmpty(container.getLocationCode()))  {
            return AjaxResult.error("容器不在库位[" + container.getLocationCode() + "]上");
        }
        if(!container.getLocationCode().equals(destinationLocation)) {
            return AjaxResult.error("容器不在目的库位上");
        }
        Location temp = new Location();
        temp.setCode(destinationLocation);
        temp.setWarehouseCode(ShiroUtils.getWarehouseCode());
        LambdaQueryWrapper lambda = Wrappers.lambdaQuery(temp);
        Location loc = locationService.getOne(lambda);
        if(StringUtils.isNotEmpty(destinationLocation)) {
            //校验目标地址
            if (loc == null) {
                return AjaxResult.error("目标库位不存在");
            }
            if (!loc.getStatus().equals("empty")) {
                return AjaxResult.error("目标库位非空闲");
            }
        }
        //判断托盘是否已经存在任务
        LambdaQueryWrapper<TaskHeader> headerQueryWrapper = Wrappers.lambdaQuery();
        headerQueryWrapper.ne(TaskHeader::getStatus, 100)
                .eq(TaskHeader::getContainerCode, containerCode);
        Integer taskCount = taskHeaderService.count(headerQueryWrapper);
        if (taskCount != null && taskCount.intValue() > 0)  {
            return AjaxResult.error("容器已存在任务");
        }

        //创建主任务
        TaskHeader taskHeader = new TaskHeader();
        taskHeader.setWarehouseCode(loc.getWarehouseCode());
        taskHeader.setCompanyCode(companyCode);//货主
        if(type == 200) {
            taskHeader.setInternalTaskType(QuantityConstant.TASK_INTENERTYPE_SHELF);
            taskHeader.setTaskType(QuantityConstant.TASK_TYPE_SUPPLEMENTRECEIPT);
        } else {
            taskHeader.setInternalTaskType(QuantityConstant.TASK_INTENERTYPE_PICKING);
            taskHeader.setTaskType(QuantityConstant.TASK_TYPE_SORTINGSHIPMENT);
        }
        taskHeader.setContainerCode(container.getCode());
        taskHeader.setStatus(QuantityConstant.TASK_STATUS_BUILD);
        taskHeader.setFromLocation(loc.getCode());
        taskHeader.setToLocation(loc.getCode());
        taskHeader.setCreated(new Date());
        taskHeader.setCreatedBy(ShiroUtils.getLoginName());
        taskHeader.setLastUpdatedBy(ShiroUtils.getLoginName());
        taskHeader.setLastUpdated(new Date());
        if(taskHeaderService.save(taskHeader)){
            //锁定库位状态
            locationService.updateStatus(loc.getContainerCode(),"lock");
        }else{
            throw new ServiceException("补充入库主表生成失败！");
        }

        return AjaxResult.success(taskHeader.getId());
    }
}