package com.zy.asrs.wms.apis.wcs.services.Impl; 
 | 
  
 | 
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; 
 | 
import com.mysql.cj.util.StringUtils; 
 | 
import com.zy.asrs.framework.common.R; 
 | 
import com.zy.asrs.framework.exception.CoolException; 
 | 
import com.zy.asrs.wms.apis.wcs.entity.domain.WaveTaskDetl; 
 | 
import com.zy.asrs.wms.apis.wcs.entity.response.SowSeeds; 
 | 
import com.zy.asrs.wms.apis.wcs.services.WaveManagentService; 
 | 
import com.zy.asrs.wms.apis.wcs.utils.HttpEssUtils; 
 | 
import com.zy.asrs.wms.asrs.entity.*; 
 | 
import com.zy.asrs.wms.asrs.entity.dto.LargeScreenTaskDto; 
 | 
import com.zy.asrs.wms.asrs.entity.enums.OrderPickStatus; 
 | 
import com.zy.asrs.wms.asrs.entity.enums.TaskStsType; 
 | 
import com.zy.asrs.wms.asrs.entity.param.WaveSeedReviewParam; 
 | 
import com.zy.asrs.wms.asrs.mapper.*; 
 | 
import com.zy.asrs.wms.asrs.service.TaskService; 
 | 
import com.zy.asrs.wms.asrs.service.WaveSeedService; 
 | 
import lombok.extern.slf4j.Slf4j; 
 | 
import org.springframework.beans.factory.annotation.Autowired; 
 | 
import org.springframework.stereotype.Service; 
 | 
  
 | 
import javax.servlet.http.HttpServletRequest; 
 | 
import java.util.List; 
 | 
  
 | 
import static com.zy.asrs.wms.utils.HttpUtils.getClientIpAddress; 
 | 
  
 | 
@Slf4j 
 | 
@Service 
 | 
public class WaveManagentServiceImpl implements WaveManagentService { 
 | 
    @Autowired 
 | 
    private WaveSeedService waveSeedService; 
 | 
  
 | 
    @Autowired 
 | 
    private TaskService taskService; 
 | 
    @Autowired 
 | 
    private TaskMapper taskMapper; 
 | 
  
 | 
    @Autowired 
 | 
    private TaskTypeMapper taskTypeMapper; 
 | 
    @Autowired 
 | 
    private OrderMapper orderMapper; 
 | 
    @Autowired 
 | 
    private OrderDetlMapper orderDetlMapper; 
 | 
    @Autowired 
 | 
    private CacheSiteMapper cacheSiteMapper; 
 | 
  
 | 
    @Override 
 | 
    public R getSowSeeds() { 
 | 
        List<SowSeeds> waveSeeds = waveSeedService.selectSeedsList(); 
 | 
        return R.ok(waveSeeds); 
 | 
    } 
 | 
  
 | 
    @Override 
 | 
    public R reviewSeeds(WaveSeedReviewParam reviewParam) { 
 | 
         waveSeedService.waveSeedReview(reviewParam); 
 | 
         return R.ok("播种复核成功"); 
 | 
    } 
 | 
  
 | 
    @Override 
 | 
    public int removeSowSeed(Long id) { 
 | 
        if (id == null) { 
 | 
            throw new CoolException("播种ID不能为空!!"); 
 | 
        } 
 | 
        return waveSeedService.removeSowById(id); 
 | 
  
 | 
    } 
 | 
  
 | 
    @Override 
 | 
    public R getTask(HttpServletRequest request) { 
 | 
        log.info("ip地址====>: {}",  getClientIpAddress(request)); 
 | 
        String locIp =  getClientIpAddress(request); 
 | 
        List<LargeScreenTaskDto> taskDtos; 
 | 
        if (locIp.equals(HttpEssUtils.S2_SITE_NO)) { 
 | 
            taskDtos =  taskMapper.getTaskIntegrateByTaskNo(new LambdaQueryWrapper<Task>() 
 | 
                    .eq(Task::getTaskSts, TaskStsType.WAVE_SEED.id) 
 | 
                            .eq(Task::getTargetSite, "S2") 
 | 
                    .orderByAsc(Task::getUpdateTime).last("limit 1")); 
 | 
        } else { 
 | 
            taskDtos =  taskMapper.getTaskIntegrateByTaskNo(new LambdaQueryWrapper<Task>() 
 | 
                    .eq(Task::getTaskSts, TaskStsType.WAVE_SEED.id) 
 | 
                    .eq(Task::getTargetSite, "S1") 
 | 
                    .orderByAsc(Task::getUpdateTime).last("limit 1")); 
 | 
        } 
 | 
         return R.ok(taskDtos); 
 | 
    } 
 | 
  
 | 
    @Override 
 | 
    public R getTaskDetl(String taskNo) { 
 | 
        List<WaveTaskDetl> taskDetls = taskMapper.getTaskDetlByTaskNo(taskNo); 
 | 
        return R.ok(taskDetls); 
 | 
    } 
 | 
  
 | 
    /** 
 | 
     * 获取非汇总明细数据 
 | 
     * 
 | 
     * @param taskNo 
 | 
     * @param waveNo 
 | 
     * @return 
 | 
     */ 
 | 
    @Override 
 | 
    public R getTaskDetlQutify(String taskNo, String waveNo) { 
 | 
        List<WaveTaskDetl> taskDetls = taskMapper.getTaskDetlQutify(taskNo, waveNo); 
 | 
        return R.ok(taskDetls); 
 | 
    } 
 | 
  
 | 
    /** 
 | 
     * 获取波次下所有订单 
 | 
     * @param waveNo 
 | 
     * @return 
 | 
     */ 
 | 
    @Override 
 | 
    public R getAllOrders(String waveNo) { 
 | 
        if (StringUtils.isNullOrEmpty(waveNo)) { 
 | 
            throw new CoolException("波次编码不能为空!!"); 
 | 
        } 
 | 
        List<Order> orders = orderMapper.selectList(new LambdaQueryWrapper<Order>().eq(Order::getWaveNo, waveNo)); 
 | 
        if (orders.isEmpty()) { 
 | 
            throw new CoolException("当前波次下没有订单!!"); 
 | 
        } 
 | 
  
 | 
        orders.forEach(order -> { 
 | 
            if (order.getPickStatus() == OrderPickStatus.ORDER_PICK_STATUS_DONE.val) { 
 | 
                order.setOrderStatus("已完成");//已完成 
 | 
            } else if (order.getPickStatus() == OrderPickStatus.ORDER_PICK_STATUS_SECTION.val) {//部分完成 
 | 
                order.setOrderStatus("部分完成"); 
 | 
            } else {//未完成 
 | 
                order.setOrderStatus("未完成"); 
 | 
            } 
 | 
        }); 
 | 
  
 | 
        return R.ok(orders); 
 | 
    } 
 | 
  
 | 
    /** 
 | 
     * 获了当前播种墙库位信息 
 | 
     * @return 
 | 
     */ 
 | 
    @Override 
 | 
    public R AllSeedLocs(HttpServletRequest request) { 
 | 
        log.info("ip地址====>: {}",  getClientIpAddress(request)); 
 | 
        String locIp =  getClientIpAddress(request); 
 | 
        List<CacheSite> cacheSites; 
 | 
        if (locIp.equals(HttpEssUtils.S2_SITE_NO)) { 
 | 
            cacheSites = cacheSiteMapper.selectList(new LambdaQueryWrapper<CacheSite>().eq(CacheSite::getChannel, "S2")); 
 | 
        } else { 
 | 
            cacheSites = cacheSiteMapper.selectList(new LambdaQueryWrapper<CacheSite>().eq(CacheSite::getChannel, "S1")); 
 | 
        } 
 | 
        if (cacheSites.isEmpty()) { 
 | 
            return R.error("当前播种墙信息未设置!!"); 
 | 
        } 
 | 
        return R.ok(cacheSites); 
 | 
    } 
 | 
} 
 |