package com.vincent.rsf.server.manager.service.impl; 
 | 
  
 | 
import cn.afterturn.easypoi.excel.ExcelImportUtil; 
 | 
import cn.afterturn.easypoi.excel.entity.result.ExcelImportResult; 
 | 
import com.alibaba.fastjson.JSONObject; 
 | 
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; 
 | 
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper; 
 | 
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper; 
 | 
import com.baomidou.mybatisplus.core.metadata.IPage; 
 | 
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl; 
 | 
import com.vincent.rsf.framework.common.R; 
 | 
import com.vincent.rsf.framework.exception.CoolException; 
 | 
import com.vincent.rsf.server.manager.entity.WkOrder; 
 | 
import com.vincent.rsf.server.manager.entity.WkOrderItem; 
 | 
import com.vincent.rsf.server.manager.entity.excel.OutStockTemplate; 
 | 
import com.vincent.rsf.server.manager.enums.AsnExceStatus; 
 | 
import com.vincent.rsf.server.manager.enums.OrderType; 
 | 
import com.vincent.rsf.server.manager.enums.OrderWorkType; 
 | 
import com.vincent.rsf.server.common.domain.BaseParam; 
 | 
import com.vincent.rsf.server.common.domain.PageParam; 
 | 
import com.vincent.rsf.server.common.utils.CommonUtil; 
 | 
import com.vincent.rsf.server.common.utils.ExcelUtil; 
 | 
import com.vincent.rsf.server.common.utils.FieldsUtils; 
 | 
import com.vincent.rsf.server.manager.entity.Matnr; 
 | 
import com.vincent.rsf.server.manager.mapper.AsnOrderItemMapper; 
 | 
import com.vincent.rsf.server.manager.service.MatnrService; 
 | 
import com.vincent.rsf.server.manager.service.OutStockItemService; 
 | 
import com.vincent.rsf.server.manager.service.OutStockService; 
 | 
import com.vincent.rsf.server.system.constant.SerialRuleCode; 
 | 
import com.vincent.rsf.server.system.utils.SerialRuleUtils; 
 | 
import org.apache.commons.lang3.StringUtils; 
 | 
import org.springframework.beans.factory.annotation.Autowired; 
 | 
import org.springframework.stereotype.Service; 
 | 
import org.springframework.transaction.annotation.Transactional; 
 | 
import org.springframework.web.multipart.MultipartFile; 
 | 
  
 | 
import java.util.*; 
 | 
import java.util.stream.Collectors; 
 | 
  
 | 
/** 
 | 
 * @author Ryan 
 | 
 * @version 1.0 
 | 
 * @title OutStockItemServiceImpl 
 | 
 * @description 
 | 
 * @create 2025/4/22 11:35 
 | 
 */ 
 | 
@Service("outStockItemServiceImpl") 
 | 
public class OutStockItemServiceImpl extends ServiceImpl<AsnOrderItemMapper, WkOrderItem> implements OutStockItemService { 
 | 
  
 | 
    @Autowired 
 | 
    private OutStockService outStockService; 
 | 
    @Autowired 
 | 
    private MatnrService matnrService; 
 | 
    @Autowired 
 | 
    private OutStockItemService outStockItemService; 
 | 
  
 | 
    /** 
 | 
     * @param 
 | 
     * @return 
 | 
     * @author Ryan 
 | 
     * @description ASN明细单据保存,及扩展字段保存 
 | 
     * @time 2025/4/7 09:59 
 | 
     */ 
 | 
    @Override 
 | 
    @Transactional(rollbackFor = Exception.class) 
 | 
    public boolean fieldsSave(Map<String, Object> params) { 
 | 
        WkOrderItem wkOrderItem = JSONObject.parseObject(JSONObject.toJSONString(params), WkOrderItem.class); 
 | 
        if (StringUtils.isBlank(wkOrderItem.getTrackCode())) { 
 | 
            String ruleCode = SerialRuleUtils.generateRuleCode(SerialRuleCode.SYS_LABEL_CODE, wkOrderItem); 
 | 
            wkOrderItem.setTrackCode(ruleCode).setBarcode(ruleCode); 
 | 
            ; 
 | 
        } 
 | 
        if (Objects.isNull(wkOrderItem.getAnfme()) || Double.compare(wkOrderItem.getAnfme(), 0.0) <= 0) { 
 | 
            throw new CoolException("计划收货数不能为空!!"); 
 | 
        } 
 | 
        //保存扩展字段 
 | 
        try { 
 | 
            String uuid16 = CommonUtil.randomUUID16(); 
 | 
            Boolean fields = FieldsUtils.saveFields(params, uuid16); 
 | 
            if (fields) { 
 | 
                wkOrderItem.setFieldsIndex(uuid16); 
 | 
            } 
 | 
        } catch (Exception e) { 
 | 
            throw new RuntimeException(e); 
 | 
        } 
 | 
        if (!this.saveOrUpdate(wkOrderItem)) { 
 | 
            throw new CoolException("收货通知单明细保存失败!!"); 
 | 
        } 
 | 
        return true; 
 | 
    } 
 | 
  
 | 
    /** 
 | 
     * @author Ryan 
 | 
     * @description 出库单模板导入 
 | 
     * @param 
 | 
     * @return 
 | 
     * @time 2025/4/22 12:40 
 | 
     */ 
 | 
    @Override 
 | 
    @Transactional(rollbackFor = Exception.class) 
 | 
    public R excelImport(MultipartFile file, HashMap<String, Object> hashMap, Long loginUserId) throws Exception { 
 | 
        ExcelImportResult result = ExcelImportUtil.importExcelMore(file.getInputStream(), OutStockTemplate.class, ExcelUtil.getDefaultImportParams()); 
 | 
        if (result.getList().isEmpty()) { 
 | 
            throw new CoolException("表格内容不能为空!!"); 
 | 
        } 
 | 
        List<OutStockTemplate> resultList = result.getList(); 
 | 
        Map<String, List<OutStockTemplate>> listMap = resultList.stream().collect(Collectors.groupingBy(OutStockTemplate::getCode)); 
 | 
        for (String key : listMap.keySet()) { 
 | 
            OutStockTemplate template = listMap.get(key).stream().findFirst().get(); 
 | 
            WkOrder wkOrder = outStockService.getOne(new LambdaQueryWrapper<WkOrder>().eq(WkOrder::getCode, template.getCode())); 
 | 
            if (!Objects.isNull(wkOrder)) { 
 | 
                continue; 
 | 
            } 
 | 
            WkOrder order = new WkOrder(); 
 | 
            order.setCode(template.getCode()) 
 | 
                    .setPoCode(template.getPoCode()) 
 | 
                    .setMemo(template.getMemo()) 
 | 
                    .setUpdateBy(loginUserId) 
 | 
                    .setCreateBy(loginUserId) 
 | 
                    .setType(OrderType.getTypeVal(template.getType())) 
 | 
                    .setWkType(OrderWorkType.getWorkType(template.getWkType())); 
 | 
            if (!outStockService.save(order)) { 
 | 
                throw new CoolException("单据保存失败!!"); 
 | 
            } 
 | 
            List<WkOrderItem> items = new ArrayList<>(); 
 | 
            for (OutStockTemplate orderTemplate : listMap.get(key)) { 
 | 
                WkOrderItem orderItem = new WkOrderItem(); 
 | 
                Matnr matnr = null; 
 | 
                if (StringUtils.isNotBlank(orderTemplate.getMatnrCode())) { 
 | 
                    matnr = matnrService.getOne(new LambdaQueryWrapper<Matnr>() 
 | 
                            .eq(Matnr::getCode, orderTemplate.getMatnrCode())); 
 | 
                } 
 | 
                orderItem.setOrderId(order.getId()) 
 | 
                        .setOrderCode(order.getCode()) 
 | 
                        .setSplrBatch(orderTemplate.getSplrBatch()) 
 | 
                        .setAnfme(Double.parseDouble(orderTemplate.getAnfme())) 
 | 
                        .setSplrName(orderTemplate.getSplrName()) 
 | 
                        .setSplrCode(orderTemplate.getSplrCode()) 
 | 
                        .setPoCode(orderTemplate.getPoCode()) 
 | 
                        .setMaktx(orderTemplate.getMaktx()) 
 | 
                        .setMatnrCode(orderTemplate.getMatnrCode()); 
 | 
                if (!Objects.isNull(matnr)) { 
 | 
                    orderItem.setMaktx(matnr.getName()).setMatnrCode(matnr.getCode()).setMatnrId(matnr.getId()); 
 | 
                } 
 | 
                items.add(orderItem); 
 | 
                if (!outStockItemService.saveBatch(items)) { 
 | 
                    throw new CoolException("单据明细保存失败!!"); 
 | 
                } 
 | 
            } 
 | 
            if (!items.isEmpty()) { 
 | 
                double purQty = items.stream().mapToDouble(WkOrderItem::getAnfme).sum(); 
 | 
                if (!outStockService.update(new LambdaUpdateWrapper<WkOrder>() 
 | 
                                .set(WkOrder::getExceStatus, AsnExceStatus.OUT_STOCK_STATUS_TASK_INIT.val) 
 | 
                        .set(WkOrder::getAnfme, purQty).eq(WkOrder::getId, order.getId()))) { 
 | 
                    throw new CoolException("单据数量修改失败!!"); 
 | 
                } 
 | 
            } 
 | 
        } 
 | 
  
 | 
        return R.ok("操作成功!!"); 
 | 
    } 
 | 
  
 | 
    /** 
 | 
     * @author Ryan 
 | 
     * @description 获取Page页 
 | 
     * @param 
 | 
     * @return 
 | 
     * @time 2025/4/22 12:39 
 | 
     */ 
 | 
    @Override 
 | 
    public IPage<Map<String, Object>> listByAsnId(PageParam<WkOrderItem, BaseParam> pageParam, QueryWrapper<WkOrderItem> buildWrapper) { 
 | 
        IPage<Map<String, Object>> hsahMap = this.baseMapper.resultForMap(pageParam, buildWrapper); 
 | 
        if (hsahMap.getRecords().isEmpty()) { 
 | 
            return hsahMap.setRecords(new ArrayList<>()); 
 | 
        } 
 | 
        hsahMap.setRecords(FieldsUtils.getExtendFields(hsahMap.getRecords())); 
 | 
        return hsahMap; 
 | 
  
 | 
    } 
 | 
  
 | 
} 
 |