rw-aps/rw-aps-server/src/main/java/com/rongwei/rwapsserver/aps/util/ApsUtils.java

package com.rongwei.rwapsserver.aps.util;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.StrUtil;
import com.rongwei.rwapsserver.aps.domain.ApsSolution;
import com.rongwei.rwapsserver.aps.domain.ProductionProcesses;
import com.rongwei.rwapsserver.aps.taskassigning.tado.ProductionProcessesTa;
import org.optaplanner.core.api.score.ScoreExplanation;
import org.optaplanner.core.api.score.buildin.hardsoft.HardSoftScore;
import org.optaplanner.core.api.score.constraint.ConstraintMatch;

import java.util.*;

public class ApsUtils {

    /**
     * 最终得分分析
     * @param explain
     * @param processes
     */
    public void softExplain(ScoreExplanation<ApsSolution, HardSoftScore> explain, List<ProductionProcesses> processes){
        if(explain != null && explain.getConstraintMatchTotalMap() != null && explain.getConstraintMatchTotalMap().size()>0){
            explain.getConstraintMatchTotalMap().forEach((k,v)->{
                String constraintName = v.getConstraintName();
                if(constraintName != null){
                    String desc = ApsConstants.constraintDesc.get(constraintName);
                    String consLevel = ApsConstants.hardConstraint.contains(constraintName) ? "hard" : "soft";
                    if(desc != null && v.getConstraintMatchSet() != null && v.getConstraintMatchSet().size()>0){
                        for (ConstraintMatch<HardSoftScore> hardSoftScoreConstraintMatch : v.getConstraintMatchSet()) {
                            if(hardSoftScoreConstraintMatch.getIndictedObjectList() != null && hardSoftScoreConstraintMatch.getIndictedObjectList().size() > 0){
                                for (Object o : hardSoftScoreConstraintMatch.getIndictedObjectList()) {
                                    if(o instanceof ProductionProcesses){
                                        ProductionProcesses productionProcesses = (ProductionProcesses)o;
                                        constraintDescInit(productionProcesses,desc,consLevel);
                                    } else if (o instanceof ArrayList) {
                                        List<ProductionProcesses> processesList = (ArrayList)o;
                                        for (ProductionProcesses productionProcesses : processesList) {
                                            constraintDescInit(productionProcesses,desc,consLevel);
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            });
        }
    }

    /**
     * 冲突描述
     * @param productionProcesses
     * @param desc
     * @param consLevel
     */
    private void constraintDescInit(ProductionProcesses productionProcesses,String desc,String consLevel){
        if("y".equals(productionProcesses.getHasConflict())){
            if("hard".equals(consLevel)){
                if(StrUtil.isBlank(productionProcesses.getConflictDes())){
                    productionProcesses.setConflictDes(desc);
                }else{
                    if(!productionProcesses.getConflictDes().contains(desc)){
                        productionProcesses.setConflictDes(productionProcesses.getConflictDes()+";"+desc);
                    }
                }
            }else{
                if(StrUtil.isBlank(productionProcesses.getSoftconflictdes())){
                    productionProcesses.setSoftconflictdes(desc);
                }else{
                    if(!productionProcesses.getSoftconflictdes().contains(desc)){
                        productionProcesses.setSoftconflictdes(productionProcesses.getSoftconflictdes()+";"+desc);
                    }
                }
            }
        }else{
            productionProcesses.setHasConflict("y");
            if("hard".equals(consLevel)){
                productionProcesses.setConflictDes(desc);
            }else{
                productionProcesses.setSoftconflictdes(desc);
            }
        }
    }


    /**
     * 根据可选设备分组排程
     * @param processes
     * @param equPros
     */
    public void groupProsByEqu(List<ProductionProcessesTa> processes, Map<String,List<ProductionProcessesTa>> equPros){
        // 根据可选设备分组排程
        for (ProductionProcessesTa productionProcesses : processes) {
            if(productionProcesses.getOptionalEquipments().size()>1){
                int aaa = 0;
            }
            String equids = CollUtil.join(productionProcesses.getOptionalEquipments(), ",");
            if(equPros.size() == 0){
                List<ProductionProcessesTa> pps = new ArrayList<>();
                pps.add(productionProcesses);
                equPros.put(equids,pps);
            }else {
                boolean hasSameKeys = false;
                List<String> haskey = new ArrayList<>();
                Set<String> keys = equPros.keySet();
                for (String key : keys) {
                    for (String optionalEquipment : productionProcesses.getOptionalEquipments()) {
                        if(key.contains(optionalEquipment)){
                            hasSameKeys = true;
                            haskey.add(key);
                        }
                    }
                }
                if(hasSameKeys){
                    List<ProductionProcessesTa> mergePros = new ArrayList<>();
                    Set<String> keyIds = new HashSet<>();

                    for (String s : haskey) {
                        List<ProductionProcessesTa> processesList1 = equPros.get(s);
                        if(processesList1 != null && processesList1.size() > 0){
                            mergePros.addAll(processesList1);
                            equPros.remove(s);

                            String[] keysps = s.split(",");
                            for (String key : keysps) {
                                keyIds.add(key);
                            }
                        }
                    }
                    mergePros.add(productionProcesses);
                    String keyIdStrs = CollUtil.join(keyIds, ",");

                    for (String optionalEquipment : productionProcesses.getOptionalEquipments()) {
                        if(!keyIdStrs.contains(optionalEquipment)){
                            keyIdStrs = keyIdStrs + "," + optionalEquipment;
                        }
                    }
                    equPros.put(keyIdStrs,mergePros);
                }else{
                    List<ProductionProcessesTa> pps = new ArrayList<>();
                    pps.add(productionProcesses);
                    equPros.put(equids,pps);
                }
            }
        }
    }
}