Changes

Fixiaobai

2023-10-24 5e10fd9df81dcffdebcf0c0ef892f5ac01926e20

Changes

 mes-basic/src/main/java/com/chinaztt/mes/basic/service/impl/PartServiceImpl.java

@@ -36,6 +36,7 @@
import com.chinaztt.mes.common.util.JsonUtil;
import com.chinaztt.ztt.common.core.util.R;
import com.chinaztt.ztt.common.security.util.SecurityUtils;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.google.gson.Gson;
import lombok.AllArgsConstructor;
import org.apache.http.HttpEntity;
@@ -56,10 +57,8 @@
import org.springframework.util.StringUtils;

import java.io.IOException;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.math.BigDecimal;
import java.util.*;

/**
 * é›¶ä»¶
@@ -367,8 +366,12 @@
        }
    }


    @Transactional(rollbackFor = Exception.class)
    @Override
    public void syncNewIfs(Date date) {
        Map<String, String> dicmattype = dictUtils.getDicKey("material_type");
        Map<String, String> dicunit = dictUtils.getDicKey("unit");
        String key = "syncPart_lock" + SecurityUtils.getUser().getId();
        if (redisTemplate.hasKey(key)) {
            throw new RuntimeException("有同步任务正在处理");
@@ -376,13 +379,44 @@
        redisTemplate.opsForValue().set(key, 1, 1000 * 3600);
        Map<String, Object>map=new HashMap<>();
        map.put("MODIFY_DATE", DateUtil.format(date,"yyyy-MM-dd"));
        System.out.println(map);
        String url = "http://192.168.20.47:8008/PurchService.ashx?contract=ZTKJ&contractKey=4ttDeLKNsZuhstjtROMcRE1USNFXKdFYE7lQ2p1m5Bo=&procedureName=QUERY_INVENTORY_PART_INFO_STD&userId=7632&inAttr={'MODIFY_DATE':"+JsonUtil.jsonToString(map)+"}";
        try {
            String url = "http://192.168.20.47:8008/PurchService.ashx?contract=ZTKJ&contractKey=4ttDeLKNsZuhstjtROMcRE1USNFXKdFYE7lQ2p1m5Bo=&procedureName=QUERY_INVENTORY_PART_INFO_STD&userId=7632&inAttr="+new ObjectMapper().writeValueAsString(map);
            String body = HttpRequest.get(url).execute().body();
            Map<String, Object> mapResult = JsonUtil.jsonToPojo(body, Map.class);
            System.out.println(
                    "执行========》"+mapResult);
            List<Map<String, Object>> data = JsonUtil.jsonToPojo(JsonUtil.jsonToString(mapResult.get("INVENTORY_PART_INFO")), List.class);
            List<String>no=new ArrayList<String>();
            List<Part>partList=new ArrayList<Part>();
            data.forEach(l->{
                Part part = new Part();
                part.setPartNo(String.valueOf(l.get("PART_NO")));
                no.add(part.getPartNo());
                part.setPartName(String.valueOf(l.get("PART_DESC")));
                part.setMaterialType(dicmattype.get(l.get("TYPE_CODE")));
                part.setUnit(dicunit.get(l.get("UNIT_MEAS")));
                part.setAssortment(String.valueOf(l.get("FIRST_CLASS")));
                part.setCategory(String.valueOf(l.get("SECOND_CLASS")));
                part.setThreeLevelClassification(String.valueOf(l.get("THIRD_CLASS")));
//                        part1.setMaterialAttribute(dicmatatype.get(part.get("ACCOUNTING_GROUP_DESC")));
                Object netWeight = Optional.ofNullable(l.get("NET_WEIGHT")).orElse("1");
                if(!Objects.equals(netWeight,"1")){
                    part.setWeight(BigDecimal.valueOf(Double.parseDouble(String.valueOf(l.get("NET_WEIGHT")))));
                }
                part.setEngChgLevel("1");
                part.setPlanningMethod(String.valueOf(l.get("PART_STATUS")));
                //part.setPlanningMethodIfs(l.get("PART_STATUS"));
                part.setLotTrackingIfs(!(l.get("LOT_TRACK_DB").equals("NOT LOT TRACKING")));
                part.setSunit(dicunit.get(l.get("UNIT_MEAS_FOR_WEIGHT")));
                partList.add(part);
            });
            QueryWrapper<Part>queryWrapper=new QueryWrapper<>();
            queryWrapper.lambda().select(Part::getPartNo).in(Part::getPartNo,no);
            List<Part> selectList = baseMapper.selectList(queryWrapper);
            //System.out.println(baseMapper.selectList(queryWrapper));
            partList.removeIf(mainObj -> selectList.stream().anyMatch(subObj -> subObj.getPartNo().equals(mainObj.getPartNo())));
            //System.out.println(partList);
            partList.forEach(l->{
                baseMapper.insert(l);
            });
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException(e.getMessage());
@@ -390,5 +424,4 @@
            redisTemplate.delete(key);
        }
    }

}

 mes-common/src/main/java/com/chinaztt/mes/common/util/ArrayListUtil.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,128 @@
package com.chinaztt.mes.common.util;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * @Author å¼ å®¾
 */
public class ArrayListUtil {

    /**
     * å•å€¼é›†åˆåŽ»é‡
     * @param objList
     * @param <T>
     * @return
     */
    public static <T> List<T> singleValueDistinct(List<T>objList){
        return  objList.stream().distinct().collect(Collectors.toList());
    }

    /**
     * å•å€¼é›†åˆæ¯”较 ä¸»é›†åˆä¸­ä¸Žæ¬¡é›†åˆä¸ç›¸ç­‰æ•°æ®
     * @param mainList ä¸»é›†åˆ
     * @param secondaryList æ¬¡è¦é›†åˆ
     * @param <T>
     * @return ä¸»é›†åˆä¸­è·Ÿæ¬¡è¦é›†åˆä¸ç›¸ç­‰çš„数据
     */
    public static <T> List<T> compareNotEqualListBySingleValue(List<T>mainList,List<T>secondaryList){
        return mainList.stream().filter(item -> !secondaryList.stream()
                        .map(e -> e).distinct().collect(Collectors.toList())
                        .contains(item))
                .collect(Collectors.toList());
    }

    /**
     * å•å€¼é›†åˆæ¯”较 ä¸»é›†åˆä¸­ä¸Žæ¬¡é›†åˆç›¸ç­‰æ•°æ®
     * @param mainList ä¸»é›†åˆ
     * @param secondaryList æ¬¡è¦é›†åˆ
     * @param <T>
     * @return ä¸»é›†åˆä¸­è·Ÿæ¬¡è¦é›†åˆä¸ç›¸ç­‰çš„数据
     */
    public static <T> List<T> compareEqualListBySingleValue(List<T>mainList,List<T>secondaryList){
        return mainList.stream().filter(item -> secondaryList.stream()
                        .map(e -> e).collect(Collectors.toList())
                        .contains(item))
                .collect(Collectors.toList());
    }

    /**
     * å•å€¼é›†åˆåˆå¹¶
     * @param isDistinct
     * @param values
     * @param <T>
     * @return
     */
    @SafeVarargs
    public static <T> List<T> mergeListBySingleValue(boolean isDistinct, List<T>... values){
        //去重合并
        if (isDistinct){
            return Stream.of(values).flatMap(Collection::stream).distinct().collect(Collectors.toList());
        }
        return Stream.of(values).flatMap(Collection::stream).collect(Collectors.toList());
    }

    /**
     * å•ä¸ªå¯¹è±¡é›†åˆæ ¹æ®å¯¹è±¡å±žæ€§åŽ»é‡é›†åˆ
     * @param keyExtractor
     * @param objects
     * @param <T>
     * @return
     */
    public static <T> List<T> oneObjectsDistinctByProperty(Function<? super T, ?> keyExtractor,List<T> objects){
        List<T> newList = new ArrayList<>();
        objects.stream().filter(distinctByKey(keyExtractor))  //filter保留true的值
                .forEach(newList::add);
        return newList;
    }

    /**
     * å¤šå¯¹è±¡é›†åˆåˆå¹¶æ ¹æ®å±žæ€§åŽ»é‡
     * @param objects
     * @param <T>
     * @return
     */
    @SafeVarargs
    public static <T> List<T> mergeListByObjectsDistinct(Function<? super T, ?> keyExtractor,List<T>... objects){
        List<T> tList = mergeListByObjects(objects);
        return oneObjectsDistinctByProperty(keyExtractor,tList);
    }

    /**
     * å¤šå¯¹è±¡é›†åˆåˆå¹¶æ— éœ€åŽ»é‡ é‡è½½
     * @param objects
     * @param <T>
     * @return
     */
    @SafeVarargs
    public static <T> List<T> mergeListByObjectsDistinct(List<T>... objects){
        return mergeListByObjects(objects);
    }

    private static <T> Predicate<T> distinctByKey(Function<? super T, ?> keyExtractor)  {
        Map<Object,Boolean> seen = new ConcurrentHashMap<>();
        //putIfAbsent方法添加键值对，如果map集合中没有该key对应的值，则直接添加，并返回null，如果已经存在对应的值，则依旧为原来的值。
        //如果返回null表示添加数据成功(不重复)，不重复(null==null :TRUE)
        return t -> seen.putIfAbsent(keyExtractor.apply(t), Boolean.TRUE) == null;
    }

    /**
     * å¯¹è±¡é›†åˆåˆå¹¶
     * @param objects
     * @param <T>
     * @return
     */
    @SafeVarargs
    private static <T> List<T> mergeListByObjects(List<T>... objects){
        return Stream.of(objects).flatMap(Collection::stream).collect(Collectors.toList());
    }


}