Merge remote-tracking branch 'origin/master'

wu

2024-08-02 928fa3682fcd0bcb59e3ca3da8770ecbb06cf315

 hangzhoumesParent/moduleService/GlassStorageModule/src/main/java/com/mes/storagetask/service/impl/StorageTaskServiceImpl.java

@@ -3,22 +3,43 @@
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;

import com.baomidou.mybatisplus.core.toolkit.Wrappers;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;

import com.mes.loadposition.entity.LoadPosition;

import com.mes.loadposition.mapper.LoadPositionMapper;

import com.mes.rawusage.entity.RawUsage;

import com.mes.rawusage.mapper.RawUsageMapper;

import com.mes.shelfrack.entity.ShelfRack;

import com.mes.shelfrack.entity.request.RawUsageAndShelfRack;

import com.mes.shelfrack.mapper.ShelfRackMapper;

import com.mes.storagetask.entity.request.StorageTaskRequest;

import com.mes.storagetask.mapper.StorageTaskMapper;

import com.mes.storagetask.entity.StorageTask;

import com.mes.storagetask.service.StorageTaskService;

import lombok.extern.slf4j.Slf4j;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Service;



import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.Optional;



/**

 * @author system

 * @since 2024-07-09 14:51:27

 */

@Service

@Slf4j

public class StorageTaskServiceImpl extends ServiceImpl<StorageTaskMapper, StorageTask> implements StorageTaskService {



    @Autowired

    private StorageTaskMapper storageTaskMapper;

    @Autowired

    private LoadPositionMapper loadPositionMapper;

    @Autowired

    private ShelfRackMapper shelfRackMapper;

    @Autowired

    private RawUsageMapper rawUsageMapper;





    @Override

    public List<StorageTask> findList(StorageTask params){

@@ -26,24 +47,121 @@
        return storageTaskMapper.selectList(query);

    }



    @Override

    public StorageTask findById(Long id) {

        return storageTaskMapper.selectById(id);



    public Map<String, Optional<StorageTask>> findLatestTasks() {

        Map<String, Optional<StorageTask>> latestTasks = new HashMap<>();



        // 查询最新的已完成任务

        LambdaQueryWrapper<StorageTask> completedWrapper = new LambdaQueryWrapper<>();

        completedWrapper.eq(StorageTask::getTaskType, "已完成")

                .orderByDesc(StorageTask::getId)

                .last("LIMIT 1");

        Optional<StorageTask> latestCompletedTask = Optional.ofNullable(storageTaskMapper.selectOne(completedWrapper));

        latestTasks.put("已完成", latestCompletedTask);



        // 查询最新的等待中任务

        LambdaQueryWrapper<StorageTask> pendingWrapper = new LambdaQueryWrapper<>();

        pendingWrapper.eq(StorageTask::getTaskType, "等待中")

                .orderByDesc(StorageTask::getId);

        Optional<StorageTask> latestPendingTask = Optional.ofNullable(storageTaskMapper.selectOne(pendingWrapper));

        latestTasks.put("等待中", latestPendingTask);

        log.info(latestTasks+"");

        return latestTasks;

    }



    @Override

    public boolean insert(StorageTask storageTask) {

        return save(storageTask);

    }



    @Override

    public boolean update(StorageTask storageTask) {

        return updateById(storageTask);

    public   List<StorageTaskRequest>  Tasks() {

        return baseMapper.selectTasks();

    }







    @Override

    public int delete(Long id) {

        return storageTaskMapper.deleteById(id);

    public void taskUpdate(StorageTask request) {

        Integer taskId = request.getId();

        String taskType = request.getTaskType();

        String Type = request.getType();

        String taskState = request.getTaskState();

        String shelfRack = request.getShelfRack();

        String loadRack = request.getLoadRack();



        if ("重新开始".equals(Type)) {

            StorageTask storageTask = new StorageTask();

            storageTask.setTaskState("等待中");

            LambdaQueryWrapper<StorageTask> queryWrapper = Wrappers.lambdaQuery(StorageTask.class)

                    .eq(StorageTask::getId, request.getId());

            storageTaskMapper.update(request,queryWrapper);

        } else if ("完成".equals(Type)) {

            StorageTask existingTask = storageTaskMapper.selectById(taskId);

            if (existingTask != null && "正在工作".equals(existingTask.getTaskState())) {

                if ("从仓位到上片位".equals(taskType) || "从仓位到吊装位".equals(taskType)) {

                    LoadPosition loadPosition = new LoadPosition();

                    loadPosition.setState("正在使用");

                    loadPosition.setStorageTaskId(request.getId());

                    LambdaQueryWrapper<LoadPosition> queryWrapper = Wrappers.lambdaQuery(LoadPosition.class)

                            .eq(LoadPosition::getNumber, request.getLoadRack());

                    loadPositionMapper.update(loadPosition, queryWrapper);

                    StorageTask storageTask = new StorageTask();

                    storageTask.setTaskState("正在使用");

                    LambdaQueryWrapper<StorageTask> StorageTaskqueryWrapper = Wrappers.lambdaQuery(StorageTask.class)

                            .eq(StorageTask::getId, request.getId());

                    storageTaskMapper.update(request,StorageTaskqueryWrapper);

                } else if ("从上片位到仓位".equals(taskType)) {

                    LoadPosition loadPosition = new LoadPosition();

                    loadPosition.setState("使用中");

                    loadPosition.setStorageTaskId(null);

                    LambdaQueryWrapper<LoadPosition> queryWrapper = Wrappers.lambdaQuery(LoadPosition.class)

                            .eq(LoadPosition::getNumber, request.getLoadRack());

                    loadPositionMapper.update(loadPosition, queryWrapper);

                    ShelfRack loshelfRack = new ShelfRack();

                    LambdaQueryWrapper<RawUsage> RawUsagequeryWrapper = Wrappers.lambdaQuery(RawUsage.class)

                            .eq(RawUsage::getId,loshelfRack.getRawPackageId());

                    RawUsage RawUsage = rawUsageMapper.selectOne(RawUsagequeryWrapper);

                    if(RawUsage.getLeftPieces()==0){

                        loshelfRack.setState("空闲");

                    }else {

                        loshelfRack.setState("使用中");

                    }

                    LambdaQueryWrapper<ShelfRack> loshelfRackqueryWrapper = Wrappers.lambdaQuery(ShelfRack.class)

                            .eq(ShelfRack::getNumber, request.getLoadRack());

                    shelfRackMapper.update(loshelfRack, loshelfRackqueryWrapper);

                } else if ("从吊装位到仓位".equals(taskType)) {

                    LoadPosition loadPosition = new LoadPosition();

                    loadPosition.setState("空闲");

                    loadPosition.setStorageTaskId(null);

                    LambdaQueryWrapper<LoadPosition> queryWrapper = Wrappers.lambdaQuery(LoadPosition.class)

                            .eq(LoadPosition::getNumber, request.getLoadRack());

                    loadPositionMapper.update(loadPosition, queryWrapper);

                    ShelfRack loshelfRack = new ShelfRack();

                    LambdaQueryWrapper<RawUsage> RawUsagequeryWrapper = Wrappers.lambdaQuery(RawUsage.class)

                            .eq(RawUsage::getId,loshelfRack.getRawPackageId());

                    RawUsage RawUsage = rawUsageMapper.selectOne(RawUsagequeryWrapper);

                    if(RawUsage.getLeftPieces()==1){

                        loshelfRack.setEnableState("启用");

                    }else {

                        loshelfRack.setEnableState(loshelfRack.getEnableState());

                    }

                    loadPosition.setState("使用中");

                    LambdaQueryWrapper<ShelfRack> loshelfRackqueryWrapper = Wrappers.lambdaQuery(ShelfRack.class)

                            .eq(ShelfRack::getNumber, request.getLoadRack());

                    shelfRackMapper.update(loshelfRack, loshelfRackqueryWrapper);

                }

                StorageTask storageTask = new StorageTask();

                storageTask.setTaskState("已完成");

                LambdaQueryWrapper<StorageTask> StorageTaskqueryWrapper = Wrappers.lambdaQuery(StorageTask.class)

                        .eq(StorageTask::getId, request.getId());

                storageTaskMapper.update(storageTask, StorageTaskqueryWrapper);

            }

        } else if ("删除".equals(Type)) {



            LambdaQueryWrapper<StorageTask> StorageTaskqueryWrapper = Wrappers.lambdaQuery(StorageTask.class)

                    .eq(StorageTask::getId, request.getId());

            storageTaskMapper.delete(StorageTaskqueryWrapper);

        }

    }









}