wms / wms_shandonghaiwang · Files

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.common.constant.QuantityConstant;

import com.huaheng.api.general.domain.ReceiptDomain;

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.ApiLogger;

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.config.materialType.domain.MaterialType;
import com.huaheng.pc.config.materialType.service.MaterialTypeService;

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

import com.huaheng.pc.inventory.inventoryHeader.domain.InventoryHeader;
import com.huaheng.pc.inventory.inventoryHeader.service.InventoryHeaderService;

import com.huaheng.pc.monitor.apilog.domain.ApiLog;
import com.huaheng.pc.monitor.apilog.service.IApiLogService;

import com.huaheng.pc.receipt.receiptContainerDetail.service.ReceiptContainerDetailService;

import com.huaheng.pc.receipt.receiptContainerDetail.domain.ReceiptContainerDetail;
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.mapper.ReceiptHeaderMapper;

import com.huaheng.pc.receipt.receiptHeader.service.ReceiptHeaderService;

import com.huaheng.pc.shipment.shipmentContainerHeader.domain.ShipmentContainerHeader;
import com.huaheng.pc.shipment.shipmentContainerHeader.service.ShipmentContainerHeaderService;

import com.huaheng.pc.system.dict.domain.DictData;
import com.huaheng.pc.system.dict.service.IDictDataService;

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 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.text.SimpleDateFormat;
import java.util.*;

import java.util.stream.Collectors;

/**
 * @author Enzo Cotter
 * @date 2019/12/15
 */
@CrossOrigin
@RestController
@RequestMapping("/mobile/receipt/batch")

@Api(tags = {"移动端收货"}, value = "移动端收货MobileBatchReceiptController")

public class MobileBatchReceiptController {

    @Resource

    private ShipmentContainerHeaderService shipmentContainerHeaderService;
    @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 MaterialTypeService materialTypeService;
    @Resource

    private LocationService locationService;
    @Resource
    private TaskHeaderService taskHeaderService;
    @Resource
    private TaskDetailService taskDetailService;
    @Resource
    private CompanyService companyService;

    @Resource
    private IDictDataService dictDataService;

    @Resource
    private ReceiptTypeService receiptTypeService;

    @Resource
    private ReceiptHeaderMapper receiptHeaderMapper;

    @Resource
    private InventoryHeaderService inventoryHeaderService;

    @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 (!QuantityConstant.STATUS_CONTAINER_EMPTY.equals(container.getStatus())) {

            return AjaxResult.error("托盘状态不为空");
        }

        if (!"".equals(container.getLocationCode())) {

            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.getMaterialByCode(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 {

        List<ReceiptHeader> receiptHeaders = receiptHeaderService.getLatestReceipt(ShiroUtils.getWarehouseCode(), param.get("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("不存在这个托盘");
        }

        //pda入库增加托盘任务校验

        List<TaskHeader> unfinishTask = taskHeaderService.getUnCompleteTaskList().stream().filter((t) -> {

            return t.getContainerCode().equals(container.getCode());
        }).collect(Collectors.toList());

        if (unfinishTask.size() > 0) {

            TaskHeader t = unfinishTask.get(0);
            String time = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(t.getCreated());
            throw new ServiceException(container.getCode() + "托盘已经有未完成的任务，请不要重复下发\n该托盘任务创建于：" + time);
        }

        if (locationCode != null && 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, QuantityConstant.TASK_STATUS_COMPLETED)

                    .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.getContainerByCode(containerCode);

            receiptContainerHeader.setContainerType(container2.getContainerType());

            receiptContainerHeader.setTaskType(QuantityConstant.TASK_TYPE_SUPPLEMENTRECEIPT);

            receiptContainerHeader.setFromLocation(container2.getLocationCode());
            receiptContainerHeader.setToLocation(locationCode);

            receiptContainerHeader.setCreatedBy(ShiroUtils.getName());
            receiptContainerHeader.setLastUpdatedBy(ShiroUtils.getName());

            receiptContainerHeader.setStatus(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.updateById(taskHeader);

            for (ReceiptBill receiptBill : receiptBills) {

                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.getTaskQty();
                BigDecimal totalQty = receiptDetail2.getQty();

                BigDecimal qty = openQty.add(receiptBill.getQty());

                if (totalQty.subtract(qty).compareTo(BigDecimal.ZERO) < 0) {

                    throw new Exception("配盘数量大于表单数量");
                }

                receiptDetail2.setTaskQty(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.getName());
                receiptContainerDetail.setLastUpdatedBy(ShiroUtils.getName());

                receiptContainerDetailService.save(receiptContainerDetail);

                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.setAllocationId(receiptContainerDetail.getId());
                taskDetail.setStatus(taskHeader.getStatus());
                taskDetail.setBatch(receiptBill.getBatch());
                taskDetail.setCompanyCode(taskHeader.getCompanyCode());
                taskDetailService.save(taskDetail);

            }

        } else {

            ReceiptContainerView record = new ReceiptContainerView();

            record.setReceiptContainerCode(containerCode);
            record.setLocationCode(locationCode);

            record.setTaskType((short) 100);

            record.setCompanyCode(receiptBills.get(0).getCompanyCode());
            receiptContainerHeaderService.checkContainer(record);

            if (locationCode != null) {

                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("/listReceipt")
    @ApiOperation("移动端根据表单整盘入库")
    @Log(title = "移动端根据表单整盘入库", action = BusinessType.OTHER)
    @Transactional(rollbackFor = Exception.class)

    public AjaxResult listReceipt(@RequestBody @ApiParam(value = "收货单") List<ReceiptBill> receiptBills) throws Exception {
        if (receiptBills == null || receiptBills.size() <= 0) {

            throw new JSONException("没有收货信息");
        }
        String containerCode = receiptBills.get(0).receiptContainerCode;
        String companyCode = receiptBills.get(0).getCompanyCode();
        String receiptDetailId = receiptBills.get(0).getReceiptDetailId();
        String locationCode = receiptBills.get(0).locationCode;

        LambdaQueryWrapper<Container> containerQueryWrapper = Wrappers.lambdaQuery();
        containerQueryWrapper.eq(Container::getCode, containerCode);
        Container container = containerService.getOne(containerQueryWrapper);

        if (container == null) {
            if (locationCode != null) {

                LambdaQueryWrapper<Location> locationLambdaQueryWrapper = Wrappers.lambdaQuery();
                locationLambdaQueryWrapper.eq(Location::getCode, locationCode);
                Location location = locationService.getOne(locationLambdaQueryWrapper);

                if (location != null && location.getLocationType().equals("PK")) {

                    containerCode = location.getContainerCode();

                    if (StringUtils.isEmpty(containerCode)) {

                        LambdaQueryWrapper<Container> containerQueryWrapper2 = Wrappers.lambdaQuery();
                        containerQueryWrapper2.eq(Container::getEnable, true)

                                .eq(Container::getStatus, QuantityConstant.STATUS_CONTAINER_EMPTY)
                                .eq(Container::getContainerType, "DM");

                        List<Container> containerList = containerService.list(containerQueryWrapper2);
                        containerCode = containerList.get(0).getCode();
                    }
                } else {
                    return AjaxResult.error("不存在这个托盘");
                }
            } else {
                return AjaxResult.error("不存在这个托盘");
            }

        }

        if (locationCode != null) {

            LambdaQueryWrapper<Location> locationLambdaQueryWrapper = Wrappers.lambdaQuery();
            locationLambdaQueryWrapper.eq(Location::getCode, locationCode);
            Location location = locationService.getOne(locationLambdaQueryWrapper);

            if (location == null) {

                throw new JSONException("不存在这个托盘");
            }

            if (!QuantityConstant.STATUS_LOCATION_EMPTY.equals(location.getStatus())) {

                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("没有找到入库单");
        }

        List<ReceiptContainerView> receiptContainerViewList = new ArrayList<>();

        for (ReceiptBill receiptBill : receiptBills) {
            if (receiptBill.getQty().compareTo(BigDecimal.ZERO) == 0) {

                continue;
            }

            ReceiptContainerView receiptContainerView = new ReceiptContainerView();
            receiptContainerView.setLocationCode(receiptBill.getLocationCode());
            receiptContainerView.setCompanyCode(receiptBill.getCompanyCode());

            receiptContainerView.setReceiptContainerCode(containerCode);

            receiptContainerView.setReceiptDetailId(Integer.parseInt(receiptBill.getReceiptDetailId()));
            receiptContainerView.setQty(receiptBill.getQty());

            receiptContainerView.setTaskType((short) 100);

            receiptContainerViewList.add(receiptContainerView);
        }
        receiptContainerHeaderService.batchSave(receiptContainerViewList);
        AjaxResult retResult = taskHeaderService.createQuickTask(containerCode);
        return retResult;
    }

    @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("公司编码为空");
        }

        /* 查询入库单，如果数据库中不存在，则调用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("PDA呼叫料盒")
    @ApiLogger(apiName = "PDA呼叫料盒", from = "PDA")
    @Log(title = "PDA呼叫料盒", action = BusinessType.OTHER)

    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");

        if (StringUtils.isEmpty(destinationLocation) && StringUtils.isEmpty(containerCode)) {
            return AjaxResult.error("库位和容器不能都为空");
        }

        return taskHeaderService.callBox(containerCode, destinationLocation, type, companyCode);

    }

    @PostMapping("/searchReceipt")
    @ApiOperation("移动端查询入库单")
    @Log(title = "移动端查询入库单", action = BusinessType.OTHER)

    public AjaxResult searchReceipt(@RequestBody @ApiParam(value = "物料号") Map<String, String> param) {

        String companyCode = param.get("companyCode");
        SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String now = df.format(new Date());
        Calendar c = Calendar.getInstance();
        c.setTime(new Date());
        c.add(Calendar.DATE, -7);
        Date first = c.getTime();
        String start = df.format(first);//前一天
        LambdaQueryWrapper<ReceiptHeader> receiptHeaderQueryWrapper = Wrappers.lambdaQuery();
        receiptHeaderQueryWrapper.eq(ReceiptHeader::getCompanyCode, companyCode)
                .eq(ReceiptHeader::getWarehouseCode, ShiroUtils.getWarehouseCode())

                .ne(ReceiptHeader::getReceiptType, "PPI")

                .le(ReceiptHeader::getCreated, now)

                .gt(ReceiptHeader::getCreated, start)
                .orderByDesc(ReceiptHeader::getCreated);

        List<ReceiptHeader> receiptHeaderList = receiptHeaderService.list(receiptHeaderQueryWrapper);
        return AjaxResult.success(receiptHeaderList);
    }

    @PostMapping("/searchReceiptInCondition")
    @ApiOperation("移动端查询入库单")
    @Log(title = "移动端查询入库单", action = BusinessType.OTHER)

    public AjaxResult searchReceiptInCondition(@RequestBody @ApiParam(value = "物料号") Map<String, String> param) {

        String companyCode = param.get("companyCode");
        String code = param.get("code");
        String receiptType = param.get("receiptType");
        String lastStatus = param.get("lastStatus");
        String startTime = param.get("startTime");
        String endTime = param.get("endTime");
        LambdaQueryWrapper<ReceiptHeader> receiptQueryWrapper = Wrappers.lambdaQuery();
        receiptQueryWrapper.eq(ReceiptHeader::getCompanyCode, companyCode)
                .eq(ReceiptHeader::getWarehouseCode, ShiroUtils.getWarehouseCode())
                .like(StringUtils.isNotEmpty(code), ReceiptHeader::getCode, code)
                .eq(StringUtils.isNotEmpty(receiptType), ReceiptHeader::getReceiptType, receiptType)
                .eq(StringUtils.isNotEmpty(lastStatus), ReceiptHeader::getLastStatus, lastStatus)
                .gt(StringUtils.isNotEmpty(startTime), ReceiptHeader::getCreated, startTime)
                .le(StringUtils.isNotEmpty(endTime), ReceiptHeader::getCreated, endTime)
                .orderByDesc(ReceiptHeader::getCreated);

        if (lastStatus.equals("200")) {

            receiptQueryWrapper = Wrappers.lambdaQuery();
            receiptQueryWrapper.lt(ReceiptHeader::getLastStatus, 900);
            receiptQueryWrapper.eq(ReceiptHeader::getCompanyCode, companyCode)
                    .eq(ReceiptHeader::getWarehouseCode, ShiroUtils.getWarehouseCode())
                    .like(StringUtils.isNotEmpty(code), ReceiptHeader::getCode, code)
                    .eq(StringUtils.isNotEmpty(receiptType), ReceiptHeader::getReceiptType, receiptType)
                    .gt(StringUtils.isNotEmpty(startTime), ReceiptHeader::getCreated, startTime)
                    .le(StringUtils.isNotEmpty(endTime), ReceiptHeader::getCreated, endTime)
                    .orderByDesc(ReceiptHeader::getCreated);
        }

        List<ReceiptHeader> receiptDetailList = receiptHeaderService.list(receiptQueryWrapper);

        return AjaxResult.success(receiptDetailList);
    }

    @PostMapping("/getDictListData")
    @ApiOperation("移动端查询字典信息")
    @Log(title = "移动端查询字典信息", action = BusinessType.OTHER)

    public AjaxResult getDictListData(@RequestBody @ApiParam(value = "物料号") Map<String, String> param) {

        String dictType = param.get("dictType");
        List<DictData> dictDataList = dictDataService.selectDictDataByType(dictType);
        return AjaxResult.success(dictDataList);
    }

    @PostMapping("/getReceiptType")
    @ApiOperation("移动端查询入库类型")
    @Log(title = "移动端查询字典信息", action = BusinessType.OTHER)

    public AjaxResult getReceiptType(@RequestBody @ApiParam(value = "物料号") Map<String, String> param) {

        String companyCode = param.get("companyCode");

        LambdaQueryWrapper<ReceiptType> receiptTypeLambda = Wrappers.lambdaQuery();

        receiptTypeLambda.eq(ReceiptType::getCompanyCode, companyCode);
        receiptTypeLambda.eq(ReceiptType::getWarehouseCode, ShiroUtils.getWarehouseCode());

        List<ReceiptType> receiptType = receiptTypeService.list(receiptTypeLambda);
        return AjaxResult.success(receiptType);
    }

    @PostMapping("/createReceiptCode")
    @ApiOperation("移动端创建入库单号")
    @Log(title = "移动端创建入库单号", action = BusinessType.OTHER)

    public AjaxResult createReceiptCode(@RequestBody @ApiParam(value = "物料号") Map<String, String> param) {

        String companyCode = param.get("companyCode");

        String receiptType = param.get("receiptType");

        String code = null;
        Date now = new Date();
        SimpleDateFormat df = new SimpleDateFormat("yyyyMMdd");
        String maxCode = receiptHeaderMapper.createCode(receiptType);
        //如果指定类型的最后的code存在，并且日期一致。那么 code = 入库单类型 + 年月日 + (排序号 + 1)

        if (maxCode != null && maxCode.substring(maxCode.length() - 13, maxCode.length() - 5).equals(df.format(now))) {
            Integer Count = Integer.valueOf(maxCode.substring(maxCode.length() - 5, maxCode.length()));
            code = receiptType + df.format(now) + String.format("%05d", Count + 1);