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.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.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 LocationService locationService;
    @Resource
    private TaskHeaderService taskHeaderService;
    @Resource
    private TaskDetailService taskDetailService;
    @Resource
    private CompanyService companyService;
    @Resource
    private IDictDataService dictDataService;
    @Resource
    private ReceiptTypeService receiptTypeService;


    @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 (!"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, 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(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);


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

        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(!"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(receiptBill.getReceiptContainerCode());
            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 (!"empty".equals(loc.getStatus())) {
                return AjaxResult.error("目标库位非空闲");
            }
        }
        //判断托盘是否已经存在任务
        LambdaQueryWrapper<TaskHeader> headerQueryWrapper = Wrappers.lambdaQuery();
        headerQueryWrapper.ne(TaskHeader::getStatus, QuantityConstant.TASK_STATUS_COMPLETED.intValue())
                .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.intValue()) {
            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.getCode(),"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);
        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){
        LambdaQueryWrapper<ReceiptType> receiptTypeLambda = Wrappers.lambdaQuery();
        List<ReceiptType> receiptType = receiptTypeService.list(receiptTypeLambda);
        return AjaxResult.success(receiptType);
    }



}