wms / hhwms · 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.api.general.domain.Receipt;

import com.huaheng.common.constant.QuantityConstant;

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.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.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.inventoryDetail.domain.InventoryDetail;

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

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.mapper.ReceiptHeaderMapper;

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

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

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

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

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

    @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.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 {

        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("不存在这个托盘");
        }

        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.getLoginName());
            receiptContainerHeader.setLastUpdatedBy(ShiroUtils.getLoginName());

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

                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("移动端呼叫料盒")
    @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 (!QuantityConstant.STATUS_LOCATION_EMPTY.equals(loc.getStatus())) {

                return AjaxResult.error("目标库位非空闲");
            }
        }
        //判断托盘是否已经存在任务
        LambdaQueryWrapper<TaskHeader> headerQueryWrapper = Wrappers.lambdaQuery();

        headerQueryWrapper.ne(TaskHeader::getStatus, QuantityConstant.TASK_STATUS_COMPLETED)

                .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 == QuantityConstant.TASK_TYPE_SUPPLEMENTRECEIPT) {

            taskHeader.setInternalTaskType(QuantityConstant.TASK_INTENERTYPE_RECEIPT);

            taskHeader.setTaskType(QuantityConstant.TASK_TYPE_SUPPLEMENTRECEIPT);
        } else {

            taskHeader.setInternalTaskType(QuantityConstant.TASK_INTENERTYPE_RECEIPT);
            taskHeader.setTaskType(QuantityConstant.TASK_TYPE_SUPPLEMENTRECEIPT);

        }
        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.getCode(),QuantityConstant.STATUS_LOCATION_LOCK);

        } else {

            throw new ServiceException("补充入库主表生成失败！");
        }

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

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

        } else {

            code = receiptType + df.format(now) + "00001";

        }

        return AjaxResult.success().setData(code);

    }

    @PostMapping("/createReceipt")
    @ApiOperation("移动端创建入库单")
    @Log(title = "移动端创建入库单", action = BusinessType.OTHER)
    @Transactional(rollbackFor = Exception.class)
    public AjaxResult createReceipt(@RequestBody @ApiParam(value = "物料号")List<ReceiptBill> receiptBills){
        String companyCode = receiptBills.get(0).getCompanyCode();
        String receiptCode = receiptBills.get(0).getReceiptCode();

        String receiptType = receiptBills.get(0).getReceiptType();

        ReceiptHeader receiptHeader = new ReceiptHeader();
        receiptHeader.setId(null);
        receiptHeader.setCode(receiptCode);
        receiptHeader.setReceiptType(receiptType);
        receiptHeader.setWarehouseCode(ShiroUtils.getWarehouseCode());
        receiptHeader.setCreated(null);
        receiptHeader.setCreatedBy(ShiroUtils.getLoginName());
        receiptHeader.setLastUpdated(null);
        receiptHeader.setLastUpdatedBy(ShiroUtils.getLoginName());
        receiptHeader.setFirstStatus(200);
        receiptHeader.setLastStatus(200);
        receiptHeader.setCompanyCode(companyCode);
        receiptHeaderService.save(receiptHeader);
        List<Integer> receiptDetailIds = receiptDetailService.insertTodayReceiptDetail(receiptHeader.getId(), receiptBills, false, companyCode);
        receiptDetailService.updateReceiptHeader(receiptHeader);
        if(receiptDetailIds != null && receiptDetailIds.size() > 0) {
            return AjaxResult.success("创建入库单成功");
        }
        return AjaxResult.error("创建入库单失败");
    }

    @PostMapping("/findMaterial")
    @ApiOperation("移动端查询物料信息")
    @Log(title = "移动端查询物料信息", action = BusinessType.OTHER)
    public AjaxResult findMaterial(@RequestBody @ApiParam(value = "物料号") Map<String, String> param) throws Exception {
        LambdaQueryWrapper<Material> materialLambdaQueryWrapper = Wrappers.lambdaQuery();
        materialLambdaQueryWrapper.eq(Material::getDeleted, false)
                .orderByDesc(Material::getCreated);
        List<Material>  materialList = materialService.list(materialLambdaQueryWrapper);
        return AjaxResult.success(materialList);
    }

    @PostMapping("/addMaterial")
    @ApiOperation("移动端增加物料信息")
    @Log(title = "移动端增加物料信息", action = BusinessType.OTHER)
    public AjaxResult addMaterial(@RequestBody @ApiParam(value = "物料号") Material material) throws Exception {
        AjaxResult result = materialService.addSave(material);
        return result;
    }

    @PostMapping("/searchMaterialInCondition")
    @ApiOperation("移动端查询物料信息")
    @Log(title = "移动端查询物料信息", action = BusinessType.OTHER)
    public AjaxResult searchMaterialInCondition(@RequestBody @ApiParam(value = "物料号") Map<String, String> param) throws Exception {
        String companyCode = param.get("companyCode");
        String code = param.get("code");
        String name = param.get("name");
        String spec = param.get("spec");
        String startTime = param.get("startTime");
        String endTime = param.get("endTime");
        LambdaQueryWrapper<Material> materialLambdaQueryWrapper = Wrappers.lambdaQuery();
        materialLambdaQueryWrapper.eq(Material::getCompanyCode, companyCode)
                .eq(Material::getWarehouseCode, ShiroUtils.getWarehouseCode())

                .eq(Material::getDeleted, false)

                .like(StringUtils.isNotEmpty(code), Material::getCode, code)
                .like(StringUtils.isNotEmpty(name), Material::getName, name)
                .like(StringUtils.isNotEmpty(spec), Material::getSpec, spec)
                .gt(StringUtils.isNotEmpty(startTime), Material::getCreated, startTime)
                .le(StringUtils.isNotEmpty(endTime), Material::getCreated, endTime)
                .orderByDesc(Material::getCreated);
        List<Material>  materialList = materialService.list(materialLambdaQueryWrapper);
        return AjaxResult.success(materialList);
    }

    @PostMapping("/createMaterialCode")
    @ApiOperation("移动端创建物料编码")
    @Log(title = "移动端创建物料编码", action = BusinessType.OTHER)
    public AjaxResult createMaterialCode(@RequestBody @ApiParam(value = "物料号") Map<String, String> param){
        String code = null;
        Date now = new Date();
        SimpleDateFormat df = new SimpleDateFormat("yyyyMMdd");
        String day = df.format(now);
        LambdaQueryWrapper<Material> materialLambdaQueryWrapper = Wrappers.lambdaQuery();
        materialLambdaQueryWrapper.like(Material::getCode, day);;
        List<Material> materials = materialService.list(materialLambdaQueryWrapper);
        int length = materials.size();
        //如果指定类型的最后的code存在，并且日期一致。那么 code = 入库单类型 + 年月日 + (排序号 + 1)
        if (length > 0) {
            code = day + String.format("%03d", length + 1);
        } else {
            code = day + "001";
        }
        return AjaxResult.success().setData(code);
    }

    @PostMapping("/getMaterialType")
    @ApiOperation("移动端获取物料类型")
    @Log(title = "移动端获取物料类型", action = BusinessType.OTHER)
    public AjaxResult getMaterialType(@RequestBody @ApiParam(value = "物料号") Map<String, String> param) throws Exception {
        LambdaQueryWrapper<MaterialType> materialTypeLambdaQueryWrapper = Wrappers.lambdaQuery();
        List<MaterialType> materialTypes = materialTypeService.list(materialTypeLambdaQueryWrapper);
        return AjaxResult.success(materialTypes);
    }