wms / hhwms · Files

package com.huaheng.pc.task.taskDetail.service;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.huaheng.common.constant.QuantityConstant;
import com.huaheng.common.exception.service.ServiceException;

import com.huaheng.common.support.Convert;
import com.huaheng.common.utils.StringUtils;

import com.huaheng.common.utils.Wrappers;

import com.huaheng.common.utils.security.ShiroUtils;
import com.huaheng.framework.web.domain.AjaxResult;

import com.huaheng.pc.config.FilterConfigDetail.domain.FilterConfigDetail;
import com.huaheng.pc.config.FilterConfigDetail.service.FilterConfigDetailService;

import com.huaheng.pc.config.cycleCountPreference.domain.CycleCountPreference;
import com.huaheng.pc.config.cycleCountPreference.service.CycleCountPreferenceService;

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

import com.huaheng.pc.config.receiptPreference.domain.ReceiptPreference;
import com.huaheng.pc.config.receiptPreference.service.ReceiptPreferenceService;
import com.huaheng.pc.config.shipmentPreference.domain.ShipmentPreference;
import com.huaheng.pc.config.shipmentPreference.service.ShipmentPreferenceService;

import com.huaheng.pc.inventory.cycleCountDetail.domain.CycleCountDetail;
import com.huaheng.pc.inventory.cycleCountDetail.service.CycleCountDetailService;

import com.huaheng.pc.inventory.inventoryDetail.domain.InventoryDetail;
import com.huaheng.pc.inventory.inventoryDetail.service.InventoryDetailService;

import com.huaheng.pc.receipt.receiptContainerDetail.domain.ReceiptContainerDetail;

import com.huaheng.pc.receipt.receiptContainerDetail.service.ReceiptContainerDetailService;
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.shipment.shipmentContainerDetail.domain.ShipmentContainerDetail;
import com.huaheng.pc.shipment.shipmentContainerDetail.service.ShipmentContainerDetailService;
import com.huaheng.pc.shipment.shipmentDetail.domain.ShipmentDetail;
import com.huaheng.pc.shipment.shipmentDetail.service.ShipmentDetailService;
import com.huaheng.pc.shipment.shipmentHeader.domain.ShipmentHeader;
import com.huaheng.pc.shipment.shipmentHeader.service.ShipmentHeaderService;
import com.huaheng.pc.system.user.service.IUserService;

import com.huaheng.pc.task.taskDetail.domain.TaskDetail;
import com.huaheng.pc.task.taskDetail.mapper.TaskDetailMapper;

import com.huaheng.pc.task.taskHeader.domain.TaskHeader;
import com.huaheng.pc.task.taskHeader.service.TaskHeaderService;

import org.springframework.stereotype.Service;

import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;

import java.math.BigDecimal;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.List;

@Service

public class TaskDetailServiceImpl extends ServiceImpl<TaskDetailMapper, TaskDetail> implements TaskDetailService {

    @Resource
    private CycleCountDetailService cycleCountDetailService;
    @Resource
    private CycleCountPreferenceService cycleCountPreferenceService;

    @Resource
    private TaskHeaderService taskHeaderService;
    @Resource
    private ReceiptPreferenceService receiptPreferenceService;
    @Resource
    private ShipmentPreferenceService shipmentPreferenceService;
    @Resource
    private FilterConfigDetailService filterConfigDetailService;

    @Resource
    private InventoryDetailService inventoryDetailService;
    @Resource
    private IUserService userService;
    @Resource
    private ReceiptContainerDetailService receiptContainerDetailService;
    @Resource
    private ReceiptHeaderService receiptHeaderService;
    @Resource
    private ReceiptDetailService receiptDetailService;
    @Resource
    private ShipmentHeaderService shipmentHeaderService;
    @Resource
    private ShipmentContainerDetailService shipmentContainerDetailService;
    @Resource
    private ShipmentDetailService shipmentDetailService;

    @Resource
    private MaterialService materialService;

    /**
     * 盘点任务首选项

     *

     * @param taskDetailList
     * @return
     */
    @Transactional
    @Override
    public List<TaskDetail> preferenceRealize(List<TaskDetail> taskDetailList) {
        /*查出盘点明细，找出盘点首选项，根据首选项显示字段*/
        List<TaskDetail> taskDetails = new ArrayList<>();

        for (TaskDetail item : taskDetailList) {

            //盘点明细
            CycleCountDetail cycleCountDetailtemp = new CycleCountDetail();
            cycleCountDetailtemp.setCycleCountHeadCode(item.getBillCode());
            cycleCountDetailtemp.setId(item.getBillDetailId());
            LambdaQueryWrapper<CycleCountDetail> detailLambdaQueryWrapper = Wrappers.lambdaQuery(cycleCountDetailtemp);
            CycleCountDetail cycleCountDetail = cycleCountDetailService.getOne(detailLambdaQueryWrapper);

            if (cycleCountDetail == null) {

                throw new SecurityException("没有找到子任务对应的盘点明细！");
            }
            //找盘点首选项
            CycleCountPreference cycleCountPreferenceTemp = new CycleCountPreference();
            cycleCountPreferenceTemp.setCode(cycleCountDetail.getPreferenceCode());
            cycleCountPreferenceTemp.setWarehouseCode(cycleCountDetail.getWarehouseCode());
            LambdaQueryWrapper<CycleCountPreference> preferenceLambdaQueryWrapper = Wrappers.lambdaQuery(cycleCountPreferenceTemp);
            CycleCountPreference cycleCountPreference = cycleCountPreferenceService.getOne(preferenceLambdaQueryWrapper);

            if (cycleCountPreference == null) {

                throw new SecurityException("没有找到盘点首选项！");
            }
            //根据首选项判断数据

            if (cycleCountPreference.getPromptLocation() == false) {

                //库位
                item.setFromLocation("");
                item.setToLocation("");
            }

            if (cycleCountPreference.getPromptLpn() == false) {

                //容器
                item.setContainerCode("");
            }

            if (cycleCountPreference.getPromptItem() == false) {

                //物料
                item.setMaterialCode("");
                item.setMaterialName("");
                item.setMaterialUnit("");

                item.setMaterialSpec("");

            }

            if (cycleCountPreference.getPromptQuantity() == false) {

                //系统数量
                item.setQty(null);
            }
            taskDetails.add(item);
        }
        return taskDetails;
    }

    /**

     * 任务位置拣货单打印
     * 根据任务头表id查询任务明细,根据上架或拣货货规则排序

     *

     * @param ids 头表id数组
     * @return
     */
    @Override
    public List<TaskDetail> findByTaskId(Integer[] ids) {
        Integer taskType = taskHeaderService.getById(ids[0]).getTaskType();
        String filterConfigCode = "";
        if (taskType.equals(QuantityConstant.TASK_TYPE_WHOLERECEIPT) || taskType.equals(QuantityConstant.TASK_TYPE_SUPPLEMENTRECEIPT)) {
            ReceiptPreference receiptPreference = receiptPreferenceService.list().get(0);
            filterConfigCode = receiptPreference.getListingRules();
        }
        if (taskType.equals(QuantityConstant.TASK_TYPE_WHOLESHIPMENT) || taskType.equals(QuantityConstant.TASK_TYPE_SORTINGSHIPMENT)) {
            ShipmentPreference shipmentPreference = shipmentPreferenceService.list().get(0);
            filterConfigCode = shipmentPreference.getShipmentPickingRule();
        }
        FilterConfigDetail filterConfigDetail = new FilterConfigDetail();
        if (StringUtils.isNotEmpty(filterConfigCode)) {
            LambdaQueryWrapper<FilterConfigDetail> detailQueryWrapper = Wrappers.lambdaQuery();
            detailQueryWrapper.eq(FilterConfigDetail::getCode, filterConfigCode);
            filterConfigDetail = filterConfigDetailService.getOne(detailQueryWrapper);
        }

        //Integer数组转object数组
        Object[] objects = new Object[ids.length];

        try {
            for (int i = 0; i < ids.length; i++) {
                Object a = (ids[i]);

                objects[i] = a;
            }

        } catch (Exception e) {

            throw new ServiceException(e.toString());
        }

        LambdaQueryWrapper<TaskDetail> queryWrapper = Wrappers.lambdaQuery();

        queryWrapper

                .in(TaskDetail::getTaskId, objects)

                .last(StringUtils.isNotEmpty(filterConfigDetail.getStatement()), filterConfigDetail.getStatement());
        return this.list(queryWrapper);
    }

    /**

     * 根据任务头表id查询任务明细

     *

     * @param id
     * @return
     */
    @Override
    public List<TaskDetail> findByTaskId(Integer id) {
        LambdaQueryWrapper<TaskDetail> queryWrapper = Wrappers.lambdaQuery();
        queryWrapper.eq(TaskDetail::getTaskId, id);
        return this.list(queryWrapper);
    }

    @Override

    public void createTaskDetailByReceipt(TaskHeader task, ReceiptContainerDetail item) {

        TaskDetail taskDetail = new TaskDetail();
        taskDetail.setTaskId(task.getId());
        taskDetail.setTaskType(task.getTaskType());
        taskDetail.setInternalTaskType(QuantityConstant.TASK_INTENERTYPE_RECEIPT);
        taskDetail.setWarehouseCode(task.getWarehouseCode());
        taskDetail.setAllocationId(item.getId());
        taskDetail.setCompanyCode(task.getCompanyCode());
        taskDetail.setMaterialCode(item.getMaterialCode());
        taskDetail.setMaterialName(item.getMaterialName());
        taskDetail.setMaterialSpec(item.getMaterialSpec());
        taskDetail.setMaterialUnit(item.getMaterialUnit());
        taskDetail.setInventorySts(item.getInventorySts());
        taskDetail.setBillCode(item.getReceiptCode());
        taskDetail.setBillDetailId(item.getReceiptDetailId());
        taskDetail.setQty(item.getQty());
        taskDetail.setContainerCode(task.getContainerCode());
        taskDetail.setFromLocation(task.getFromLocation());

        taskDetail.setGoodsShelfNo(task.getGoodsShelfNo());

        if (task.getToLocation() != null) {

            taskDetail.setToLocation(task.getToLocation());
        }

        String receiptCode = item.getReceiptCode();

        ReceiptHeader receiptHeader = receiptHeaderService.getOne(new LambdaQueryWrapper<ReceiptHeader>()
                .eq(ReceiptHeader::getCode, receiptCode)

                .eq(ReceiptHeader::getWarehouseCode, item.getWarehouseCode())

        );

        taskDetail.setReferenceCode(receiptHeader.getReferCode());

        taskDetail.setBatch(item.getBatch());
        taskDetail.setProjectNo(item.getProjectNo());

        taskDetail.setColor(item.getColor());

        if (!this.save(taskDetail)) {
            throw new ServiceException("生成任务明细失败");
        }
    }

    @Override
    public List<TaskDetail> selectListEntityUndone(TaskDetail taskDetail) {
        LambdaQueryWrapper<TaskDetail> queryWrapper = Wrappers.lambdaQuery();

        queryWrapper.eq(StringUtils.isNotEmpty(taskDetail.getContainerCode()), TaskDetail::getContainerCode, taskDetail.getContainerCode());
        queryWrapper.le(StringUtils.isNotNull(taskDetail.getStatus()), TaskDetail::getStatus, taskDetail.getStatus());
        queryWrapper.eq(StringUtils.isNotNull(taskDetail.getNumber()), TaskDetail::getNumber, taskDetail.getNumber());
        queryWrapper.eq(StringUtils.isNotEmpty(taskDetail.getWarehouseCode()), TaskDetail::getWarehouseCode, taskDetail.getWarehouseCode());
        queryWrapper.ne(TaskDetail::getTaskType, QuantityConstant.TASK_TYPE_EMPTYSHIPMENT);

        return this.list(queryWrapper);
    }

    @Override
    public List<TaskDetail> selectListByGoodshelf(TaskDetail taskDetail) {
        LambdaQueryWrapper<TaskDetail> queryWrapper = Wrappers.lambdaQuery();

        queryWrapper.eq(StringUtils.isNotEmpty(taskDetail.getContainerCode()), TaskDetail::getContainerCode, taskDetail.getContainerCode());
        queryWrapper.eq(StringUtils.isNotNull(taskDetail.getStatus()), TaskDetail::getStatus, taskDetail.getStatus());
        queryWrapper.eq(StringUtils.isNotNull(taskDetail.getNumber()), TaskDetail::getNumber, taskDetail.getNumber());
        queryWrapper.eq(StringUtils.isNotEmpty(taskDetail.getWarehouseCode()), TaskDetail::getWarehouseCode, taskDetail.getWarehouseCode());
        queryWrapper.lt(TaskDetail::getStatus, 100);

        return this.list(queryWrapper);
    }

    @Override
    public void updateByInventory(TaskDetail taskDetail) {
        InventoryDetail inventory = new InventoryDetail();
        inventory.setContainerCode(taskDetail.getContainerCode());
        try {
            inventory.setCompanyCode(taskDetail.getCompanyCode());
        } catch (Exception e) {
            e.printStackTrace();
        }
        inventory.setWarehouseCode(taskDetail.getWarehouseCode());
        inventory.setMaterialCode(taskDetail.getMaterialCode());
        List<InventoryDetail> inventories = inventoryDetailService.selectListEntityByEqual(inventory);
        BigDecimal number = inventoryDetailService.addQty(inventories);

        taskDetail.setWarehouseQty(number);

        if (QuantityConstant.TASK_TYPE_WHOLESHIPMENT == taskDetail.getTaskType() || QuantityConstant.TASK_TYPE_SORTINGSHIPMENT == taskDetail.getTaskType()) {

            if (number.compareTo(taskDetail.getQty()) > 0) {
                taskDetail.setRemainder((number.subtract(taskDetail.getQty())));
            } else {
                taskDetail.setRemainder(new BigDecimal(0));
            }

        } else if (QuantityConstant.TASK_TYPE_WHOLERECEIPT == taskDetail.getTaskType() || QuantityConstant.TASK_TYPE_SUPPLEMENTRECEIPT == taskDetail.getTaskType()) {

            taskDetail.setRemainder((number.add(taskDetail.getQty())));

        } else {

            taskDetail.setRemainder((number.add(taskDetail.getQty())));

        }

        Material material = materialService.getMaterialByCode(taskDetail.getMaterialCode());
        if (material != null) {

            taskDetail.setMaterialOldCode(material.getUserDef1());

            taskDetail.setMaterialSpec(material.getSpec());
            taskDetail.setMaterialName(material.getName());

        }

        taskDetail.setLastUpdatedBy(ShiroUtils.getUserName());

        inventoryDetailService.selectUwarehouse(taskDetail);
    }

    @Override
    public void updateTask(TaskDetail taskDetail, BigDecimal number) {

        if (taskDetail.getTaskType().equals("s")) {

            //修改出库子单据，修改出库组盘明细

            ShipmentDetail shipmentDetail = shipmentDetailService.getById(taskDetail.getBillDetailId());
            if (shipmentDetail == null) {

                throw new ServiceException("找不到子单");
            }
            shipmentDetail.setStatus(200);
            shipmentDetail.setQtyCompleted(shipmentDetail.getQtyCompleted().subtract(taskDetail.getQty()).add(number));

            if (!shipmentDetailService.updateById(shipmentDetail)) {

                throw new ServiceException("修改子单据失败");

            }
            ;

            ShipmentHeader shipmentHeader = shipmentHeaderService.getById(taskDetail.getBillId());
            if (shipmentHeader == null) {

                throw new ServiceException("找不到主单");
            }

            if (shipmentHeader.getLastStatus() > 200) {

                shipmentHeader.setLastStatus(200);

                if (!shipmentHeaderService.updateById(shipmentHeader)) {

                    throw new ServiceException("修改主单据失败");
                }
            }
            //修改出库组盘明细

            ShipmentContainerDetail shipmentContainerDetail = shipmentContainerDetailService.getById(taskDetail.getAllocationId());
            if (shipmentContainerDetail == null) {

                throw new ServiceException("找不到组盘明细");
            }
            shipmentContainerDetail.setQty(number);

            if (!shipmentContainerDetailService.updateById(shipmentContainerDetail)) {

                throw new ServiceException("修改组盘明细失败");

            }
            ;
        } else {

            //修改入库子单据，修改入库组盘明细

            ReceiptDetail receiptDetail = receiptDetailService.getById(taskDetail.getBillDetailId());
            if (receiptDetail == null) {

                throw new ServiceException("找不到子单");
            }

            receiptDetail.setStatus((short) 200);

            receiptDetail.setTaskQty(receiptDetail.getTaskQty().subtract(taskDetail.getQty()).add(number));

            if (!receiptDetailService.updateById(receiptDetail)) {

                throw new ServiceException("修改子单据失败");

            }
            ;

            ReceiptHeader receiptHeader = receiptHeaderService.getById(taskDetail.getBillId());
            if (receiptHeader == null) {

                throw new ServiceException("找不到主单");
            }

            if (receiptHeader.getLastStatus() > 200) {

                receiptHeader.setLastStatus(200);

                if (!receiptHeaderService.updateById(receiptHeader)) {

                    throw new ServiceException("修改主单据失败");
                }
            }
            //修改出库组盘明细

            ReceiptContainerDetail receiptContainerDetail = receiptContainerDetailService.getById(taskDetail.getAllocationId());
            if (receiptContainerDetail == null) {

                throw new ServiceException("找不到组盘明细");
            }
            receiptContainerDetail.setQty(number);

            if (!receiptContainerDetailService.updateById(receiptContainerDetail)) {

                throw new ServiceException("修改组盘明细失败");

            }
            ;

        }
        //修改子任务
        taskDetail.setQty(number);

        if (!this.updateById(taskDetail)) {

            throw new ServiceException("修改子任务失败");
        }
    }

    public List<TaskDetail> selectByIdList(List<Integer> ids) {

        if (ids == null) {

            return null;
        }
        String[] idArray = ids.toArray(new String[ids.size()]);
        LambdaQueryWrapper<TaskDetail> queryWrapper = Wrappers.lambdaQuery();
        queryWrapper.in(TaskDetail::getId, idArray);
        return this.list(queryWrapper);
    }

    @Override
    public AjaxResult updateTaskDetail(String ids, String code) {

        if (StringUtils.isEmpty(ids) || StringUtils.isEmpty(code)) {

            return AjaxResult.error("容器编码不能为空！");
        }
        List<Integer> idList = Arrays.asList(Convert.toIntArray(ids));

        if (idList.isEmpty()) {

            return AjaxResult.error("任务详情id不能为空值！");
        }

        List<TaskDetail> taskDetails = this.selectByIdList(idList);
        if (taskDetails.isEmpty()) {

            return AjaxResult.error("未查询到任务详情！");
        }

        taskDetails.forEach(item -> {

            item.setContainerCode(code);
            item.setLastUpdatedBy(ShiroUtils.getLoginName());
        });
        this.updateContainerCode(taskDetails);
        return AjaxResult.success("容器修改成功！");
    }

    public int updateContainerCode(List<TaskDetail> list) {

        if (list.isEmpty()) {

            return 0;
        }

        for (int a = 0; a < list.size(); a++) {

            LambdaQueryWrapper<TaskDetail> queryWrapper = Wrappers.lambdaQuery();
            queryWrapper.in(TaskDetail::getId, list.get(a).getId());

            TaskDetail taskDetail = new TaskDetail();

            taskDetail.setLastUpdatedBy(list.get(a).getLastUpdatedBy());

            this.update(taskDetail, queryWrapper);

        }
        return 1;
    }

}