EqpMonitorWorkFlowAction.java

package com.mycim.webapp.actions.dmmprocess;

import com.fa.sesa.exception.Assert;
import com.fa.sesa.exception.Errors;
import com.fa.sesa.threadlocal.LocalContext;
import com.mycim.framework.utils.lang.StringUtils;
import com.mycim.framework.utils.lang.collections.CollectionUtils;
import com.mycim.framework.utils.lang.collections.MapUtils;
import com.mycim.framework.utils.lang.math.NumberUtils;
import com.mycim.valueobject.MessageIdList;
import com.mycim.valueobject.ObjectList;
import com.mycim.valueobject.consts.VersionStatus;
import com.mycim.valueobject.npw.NpwConstants;
import com.mycim.valueobject.prp.EqpMonitorModel;
import com.mycim.valueobject.prp.EqpMonitorStep;
import com.mycim.valueobject.prp.Operation;
import com.mycim.valueobject.prp.Route;
import com.mycim.webapp.Constants;
import com.mycim.webapp.WebUtils;
import com.mycim.webapp.actions.NpwSetupAction;
import com.mycim.webapp.forms.EqpMonitorWorkflowForm;
import com.mycim.workflow.valueobject.WorkflowEditorModel;
import com.mycim.workflow.valueobject.WorkflowLinkModel;
import com.mycim.workflow.valueobject.WorkflowStepModel;
import com.mycim.workflow.valueobject.WorkflowTemplateModel;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionMapping;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @author shijie.deng
 * @version 6.0.0
 * @date 2019/11/11
 **/
public class EqpMonitorWorkFlowAction extends NpwSetupAction {

    @Override
    public ActionForward init(ActionMapping mapping, ActionForm form, HttpServletRequest request,
                              HttpServletResponse response) throws Exception {
        EqpMonitorWorkflowForm theform = (EqpMonitorWorkflowForm) form;

        String processId = request.getParameter("instanceId");
        long processRrn = getInstanceRrn(processId, LocalContext.getFacilityRrn(), ObjectList.WFL_KEY);
        Integer version = NumberUtils.toInt(request.getParameter("versionId"));

        String routeId = getDMMRouteId(processId);
        long routeRrn = getInstanceRrn(routeId, LocalContext.getFacilityRrn(), ObjectList.WFL_KEY);

        if (routeRrn <= 0) {
            Route route = new Route(routeId, getNamedSpace(ObjectList.WFL_KEY, LocalContext.getFacilityRrn()),
                                    ObjectList.WFL_KEY);
            route.setObjectType(ObjectList.ROUTE_KEY);
            route.setObjectSubtype(ObjectList.PROCEDURE_KEY);
            route.setTransId(Constants.CREATE_KEY);
            route.setTransPerformedby(LocalContext.getUserId());
            routeRrn = prpService.insertRoute(route);
            baseService.updateNamedObjectSystemUesd(routeRrn, "1");
        }

        EqpMonitorModel model = dmmService.getDmmModelByWfl(routeRrn, version);

        if (model == null) {
            model = new EqpMonitorModel();
            model.setWorkflowRrn(routeRrn);
            model.setWorkflowVersion(version);
            model.setStatus(VersionStatus.UNFROZEN_KEY);
            model.setCreatedUserId(LocalContext.getUserId());
            model.setModelRrn(dmmService.insertDMMModel(model));
            if (version != null && version > 1) {
                EqpMonitorModel lastModel = dmmService.getDmmModelByWfl(routeRrn, version - 1);
                model.setModelType(lastModel.getModelType());
                model.setWaferNum(lastModel.getWaferNum());
            }
            theform.setIsNewVersion("1");
        }

        theform.setDmmProcessRrn(processRrn);
        theform.setDmmRouteRrn(routeRrn);
        theform.setModelRrn(model.getModelRrn());
        theform.setModelType(model.getModelType());
        theform.setVersion(version);
        theform.setWaferNum(model.getWaferNum() != null ? model.getWaferNum() : "");

        if (StringUtils.isNotBlank(request.getParameter("viewOnly"))) {
            request.setAttribute("viewOnly", 1);
        }
        return mapping.findForward(Constants.INIT_KEY);
    }

    @Override
    public ActionForward cancel(ActionMapping mapping, ActionForm form, HttpServletRequest request,
                                HttpServletResponse response) throws Exception {
        return (mapping.findForward("version"));
    }

    public Map getStepsInfo(Map requestMap) {

        List<EqpMonitorStep> list = (List<EqpMonitorStep>) WebUtils
                .getCacheString2Obj(MapUtils.getString(requestMap, "cacheDMMStepList"));
        String version = MapUtils.getString(requestMap, "version");
        if (list == null) {
            Long modelRrn = MapUtils.getLong(requestMap, "modelRrn");
            if (StringUtils.isNotBlank(version)) {
                list = dmmService.getDmmModelStepsInfo(modelRrn, version);
            } else {
                list = dmmService.getDmmModelStepsInfo(modelRrn);
            }
        }

        List<Map> array = new ArrayList<Map>();
        for (EqpMonitorStep step : list) {
            Map<String, Object> map = new HashMap<String, Object>();
            map.put("seq", step.getModelSeq() + "");
            map.put("eqptId", StringUtils.isBlank(step.getEqptId()) ? "" : step.getEqptId());
            map.put("slot", StringUtils.isBlank(step.getEqptId()) ? "" : step.getSlot());
            map.put("recipe", StringUtils.isBlank(step.getRecipeId()) ? "" : step.getRecipeId());
            map.put("parameterId", StringUtils.isBlank(step.getParameterId()) ? "" : step.getParameterId());
            map.put("formula", StringUtils.isBlank(step.getCalculateFormula()) ? "" : step.getCalculateFormula());
            map.put("spec", getLimitString(step.getLowerLimit(), step.getUpperLimit()));
            map.put("measurationFlag", step.getMeasurationFlag() == null ? "" : "Y");
            map.put("entityGroupId", StringUtils.isBlank(step.getEntityGroupId()) ? "" : step.getEntityGroupId());
            map.put("parameterSetId", StringUtils.isBlank(step.getParameterSetId()) ? "" : step.getParameterSetId());
            map.put("operationId", StringUtils.isBlank(step.getOperationId()) ? "" : step.getOperationId());
            map.put("operationDesc", StringUtils.isBlank(step.getOperationDesc()) ? "" : step.getOperationDesc());
            map.put("contaimnation", StringUtils.isBlank(step.getContaimnation()) ? "" : step.getContaimnation());
            map.put("processLocation", StringUtils.isBlank(step.getProcessLocation()) ? "" : step.getProcessLocation());
            map.put("stageId", StringUtils.isBlank(step.getStageId()) ? "" : step.getStageId());
            map.put("stepSeq", StringUtils.isBlank(step.getStepSeq()) ? "" : step.getStepSeq());
            map.put("type", StringUtils.isBlank(step.getDmmType()) ? "" : step.getDmmType());
            map.put("waferNum", StringUtils.isBlank(step.getWaferNum()) ? "" : step.getWaferNum());
            array.add(map);
        }
        Map resultMap = new HashMap();
        resultMap.put("stepList", array);
        resultMap.put("cacheDMMStepList", WebUtils.getCacheObj2String(list));
        return resultMap;
    }

    public String deleteStep(Map requestMap) {

        List<EqpMonitorStep> list = (List<EqpMonitorStep>) WebUtils
                .getCacheString2Obj(MapUtils.getString(requestMap, "cacheDMMStepList"));

        int seq = MapUtils.getInteger(requestMap, "seq");

        ArrayList<EqpMonitorStep> steps = new ArrayList<EqpMonitorStep>();
        steps.addAll(list);
        for (int i = 0; i < steps.size(); i++) {
            if (steps.get(i).getModelSeq().intValue() == seq) {
                steps.remove(i);
                break;
            }
        }
        for (EqpMonitorStep step : steps) {
            if (step.getModelSeq().intValue() > seq) {
                step.setModelSeq(step.getModelSeq() - 1);
            }
        }
        list = sortBySeq(steps);

        return WebUtils.getCacheObj2String(list);
    }

    public String addStep(Map requestMap) throws Exception {

        List<EqpMonitorStep> list = (List<EqpMonitorStep>) WebUtils
                .getCacheString2Obj(MapUtils.getString(requestMap, "cacheDMMStepList"));
        if (list == null) {
            list = new ArrayList<EqpMonitorStep>();
        }

        Long modelRrn = MapUtils.getLong(requestMap, "modelRrn");

        List<Operation> dmmOperations = getDMMStep(list.size() + 1);

        EqpMonitorStep dmmStep = new EqpMonitorStep();
        dmmStep.setStepRrn(dmmOperations.get(list.size()).getInstanceRrn());
        dmmStep.setModelRrn(modelRrn);
        dmmStep.setModelSeq(list.size() + 1);
        dmmStep.setRecipeId(MapUtils.getString(requestMap, "recipeId").toUpperCase());
        dmmStep.setEntityGroupId(MapUtils.getString(requestMap, "entityGroupId").toUpperCase());
        dmmStep.setEqptId(MapUtils.getString(requestMap, "eqptId").toUpperCase());
        dmmStep.setParameterSetId(MapUtils.getString(requestMap, "parameterSetId").toUpperCase());
        dmmStep.setOperationId(MapUtils.getString(requestMap, "operationId").toUpperCase());
        dmmStep.setOperationDesc(MapUtils.getString(requestMap, "operationDesc").toUpperCase());
        dmmStep.setContaimnation(MapUtils.getString(requestMap, "contaimnation").toUpperCase());
        dmmStep.setProcessLocation(MapUtils.getString(requestMap, "processLocation").toUpperCase());
        dmmStep.setStageId(MapUtils.getString(requestMap, "stageId").toUpperCase());
        dmmStep.setStepSeq(MapUtils.getString(requestMap, "stepSeq").toUpperCase());
        /*dmmStep.setEqptId(MapUtils.getString(requestMap, "eqptId").toUpperCase());
        dmmStep.setSlot(MapUtils.getString(requestMap, "slot"));
        dmmStep.setParameterId(MapUtils.getString(requestMap, "parameterId") == null ? "" :
                               MapUtils.getString(requestMap, "parameterId").toUpperCase());
        dmmStep.setCalculateFormula(MapUtils.getString(requestMap, "formula") == null ? "" :
                                    MapUtils.getString(requestMap, "formula").toUpperCase());
        dmmStep.setLowerLimit(MapUtils.getLong(requestMap, "lowerLimit"));
        dmmStep.setUpperLimit(MapUtils.getLong(requestMap, "upperLimit"));*/
        if (StringUtils.isNotBlank(MapUtils.getString(requestMap, "measurationFlag"))) {
            dmmStep.setMeasurationFlag(1);
        } else {
            dmmStep.setMeasurationFlag(null);
        }

        list.add(dmmStep);

        return WebUtils.getCacheObj2String(list);
    }

    public String moveStep(Map requestMap) {

        List<EqpMonitorStep> list = (List<EqpMonitorStep>) WebUtils
                .getCacheString2Obj(MapUtils.getString(requestMap, "cacheDMMStepList"));
        int seq = MapUtils.getIntValue(requestMap, "seq");
        String type = MapUtils.getString(requestMap, "move");

        if (StringUtils.equalsIgnoreCase("up", type)) {
            if (seq > 1) {
                EqpMonitorStep downStep = null;
                EqpMonitorStep upStep = null;
                for (EqpMonitorStep step : list) {
                    if (step.getModelSeq().intValue() == seq - 1) {
                        downStep = step;
                    }
                    if (step.getModelSeq().intValue() == seq) {
                        upStep = step;
                    }
                }
                downStep.setModelSeq(seq);
                upStep.setModelSeq(seq - 1);
            }
        } else if (StringUtils.equalsIgnoreCase("down", type)) {
            if (seq < list.size()) {
                EqpMonitorStep downStep = null;
                EqpMonitorStep upStep = null;
                for (EqpMonitorStep step : list) {
                    if (step.getModelSeq().intValue() == seq) {
                        downStep = step;
                    }
                    if (step.getModelSeq().intValue() == seq + 1) {
                        upStep = step;
                    }
                }
                downStep.setModelSeq(seq + 1);
                upStep.setModelSeq(seq);
            }
        }

        list = sortBySeq(list);

        return WebUtils.getCacheObj2String(list);
    }

    public Map<String, Object> getStep(Map requestMap) {
        List<EqpMonitorStep> list = (List<EqpMonitorStep>) WebUtils
                .getCacheString2Obj(MapUtils.getString(requestMap, "cacheDMMStepList"));
        int seq = MapUtils.getIntValue(requestMap, "seq");

        EqpMonitorStep dmmStep = null;
        for (EqpMonitorStep step : list) {
            if (step.getModelSeq().intValue() == seq) {
                dmmStep = step;
                break;
            }
        }

        Map<String, Object> map = new HashMap<String, Object>();
        map.put("seq", seq);
        map.put("eqptId", dmmStep.getEqptId());
        map.put("slot", dmmStep.getSlot());
        map.put("recipe", dmmStep.getRecipeId());
        map.put("parameterId", dmmStep.getParameterId());
        map.put("formula", dmmStep.getCalculateFormula());
        map.put("lowerLimit", dmmStep.getLowerLimit());
        map.put("upperLimit", dmmStep.getUpperLimit());
        map.put("measurationFlag", dmmStep.getMeasurationFlag());
        map.put("entityGroupId", dmmStep.getEntityGroupId());
        map.put("parameterSetId", dmmStep.getParameterSetId());
        map.put("operationId", dmmStep.getOperationId());
        map.put("operationDesc", dmmStep.getOperationDesc());
        map.put("contaimnation", dmmStep.getContaimnation());
        map.put("processLocation", dmmStep.getProcessLocation());
        map.put("stageId", dmmStep.getStageId());
        map.put("stepSeq", dmmStep.getStepSeq());

        return map;
    }

    public String updateStep(Map requestMap) {
        List<EqpMonitorStep> list = (List<EqpMonitorStep>) WebUtils
                .getCacheString2Obj(MapUtils.getString(requestMap, "cacheDMMStepList"));
        int seq = MapUtils.getIntValue(requestMap, "seq");

        EqpMonitorStep dmmStep = null;
        for (EqpMonitorStep step : list) {
            if (step.getModelSeq().intValue() == seq) {
                dmmStep = step;
                break;
            }
        }
        /*DMMStep validate = new DMMStep();
        validate.setEqptId(MapUtils.getString(requestMap, "eqptId").toUpperCase());
        validate.setRecipeId(MapUtils.getString(requestMap, "recipeId").toUpperCase());
        validate.setParameterId(MapUtils.getString(requestMap, "parameterId").toUpperCase());*/
        /*String boo = validateInput(validate);
        if (StringUtils.isNotBlank(boo)) {
            throw new WebException(boo);
        }*/
        dmmStep.setRecipeId(MapUtils.getString(requestMap, "recipeId").toUpperCase());
        dmmStep.setEntityGroupId(MapUtils.getString(requestMap, "entityGroupId"));
        dmmStep.setEqptId(MapUtils.getString(requestMap, "eqptId"));
        dmmStep.setParameterSetId(MapUtils.getString(requestMap, "parameterSetId"));
        dmmStep.setOperationId(MapUtils.getString(requestMap, "operationId"));
        dmmStep.setOperationDesc(MapUtils.getString(requestMap, "operationDesc"));
        dmmStep.setContaimnation(MapUtils.getString(requestMap, "contaimnation"));
        dmmStep.setProcessLocation(MapUtils.getString(requestMap, "processLocation"));
        dmmStep.setStageId(MapUtils.getString(requestMap, "stageId"));
        dmmStep.setStepSeq(MapUtils.getString(requestMap, "stepSeq"));
        if (StringUtils.isNotBlank(MapUtils.getString(requestMap, "measurationFlag"))) {
            dmmStep.setMeasurationFlag(1);
        } else {
            dmmStep.setMeasurationFlag(null);
        }
        return WebUtils.getCacheObj2String(list);
    }

    public Map lastVersion(Map requestMap) throws Exception {

        Long routeRrn = MapUtils.getLong(requestMap, "routeRrn");
        Integer version = MapUtils.getInteger(requestMap, "version");
        Long modelRrn = MapUtils.getLong(requestMap, "modelRrn");

        if (version.intValue() > 1) {
            EqpMonitorModel lastModel = dmmService.getDmmModelByWfl(routeRrn, version.intValue() - 1);

            List<EqpMonitorStep> list = dmmService.getDmmModelStepsInfo(lastModel.getModelRrn());

            String modelType = lastModel.getModelType();
            String waferNum = lastModel.getWaferNum();

            for (EqpMonitorStep step : list) {
                step.setModelRrn(modelRrn);
            }

            List<Operation> dmmOperations = getDMMStep(list.size());

            for (int i = 0; i < list.size(); i++) {
                if (list instanceof List) {
                    ((List<EqpMonitorStep>) list).get(i).setStepRrn(dmmOperations.get(i).getInstanceRrn());
                }
            }

            List<EqpMonitorStep> oldList = dmmService.getDmmModelStepsInfo(modelRrn);

            List<WorkflowStepModel> stepModels = buildStepModel(list, routeRrn, version);
            List<WorkflowStepModel> oldStepModels = dmmService.getStepModels(routeRrn, version);

            List<WorkflowLinkModel> linkModels = buildWorkflowLinkModel(list, stepModels);
            List<WorkflowLinkModel> oldLinkModels = buildWorkflowLinkModel(oldList, oldStepModels);

            WorkflowTemplateModel templateModel = buildTemplateModel(routeRrn, version, stepModels);

            WorkflowEditorModel editorModel = new WorkflowEditorModel(templateModel, "DMM", stepModels, oldStepModels,
                                                                      linkModels, oldLinkModels);
            dmmService.importWorkflow(editorModel);

            dmmService.modifySteps(modelRrn, list);

            EqpMonitorModel dmmModel = new EqpMonitorModel();
            dmmModel.setModelRrn(modelRrn);
            dmmModel.setModelType(modelType);
            dmmModel.setWaferNum(waferNum);
            dmmService.updateDMMModel(dmmModel);

            List<Map> array = new ArrayList<Map>();
            for (EqpMonitorStep step : list) {
                Map map = new HashMap();
                map.put("seq", step.getModelSeq());
                map.put("eqptId", StringUtils.isBlank(step.getEqptId()) ? "" : step.getEqptId());
                map.put("slot", StringUtils.isBlank(step.getSlot()) ? "" : step.getSlot());
                map.put("recipe", StringUtils.isBlank(step.getRecipeId()) ? "" : step.getRecipeId());
                map.put("parameterId", StringUtils.isBlank(step.getParameterId()) ? "" : step.getParameterId());
                map.put("formula", StringUtils.isBlank(step.getCalculateFormula()) ? "" : step.getCalculateFormula());
                map.put("spec", getLimitString(step.getLowerLimit(), step.getUpperLimit()));
                map.put("measurationFlag", step.getMeasurationFlag() == null ? "" : "Y");
                map.put("entityGroupId", StringUtils.isBlank(step.getEntityGroupId()) ? "" : step.getEntityGroupId());
                map.put("parameterSetId",
                        StringUtils.isBlank(step.getParameterSetId()) ? "" : step.getParameterSetId());
                map.put("operationId", StringUtils.isBlank(step.getOperationId()) ? "" : step.getOperationId());
                map.put("operationDesc", StringUtils.isBlank(step.getOperationDesc()) ? "" : step.getOperationDesc());
                map.put("contaimnation", StringUtils.isBlank(step.getContaimnation()) ? "" : step.getContaimnation());
                map.put("processLocation",
                        StringUtils.isBlank(step.getProcessLocation()) ? "" : step.getProcessLocation());
                map.put("stageId", StringUtils.isBlank(step.getStageId()) ? "" : step.getStageId());
                map.put("stepSeq", StringUtils.isBlank(step.getStepSeq()) ? "" : step.getStepSeq());
                array.add(map);
            }

            Map resultMap = new HashMap();
            resultMap.put("stepList", array);
            resultMap.put("cacheDMMStepList", WebUtils.getCacheObj2String(list));
            return resultMap;
        } else {
            Map resultMap = new HashMap();
            resultMap.put("stepList", new ArrayList<Map>());
            resultMap.put("cacheDMMStepList", "");
            return resultMap;
        }
    }

    public ActionForward addWorkFlow(ActionMapping mapping, EqpMonitorWorkflowForm theform, HttpServletRequest request,
                                     HttpServletResponse response) throws Exception {

        Long modelRrn = NumberUtils.toLong(request.getParameter("modelRrn"));
        Long routeRrn = NumberUtils.toLong(request.getParameter("dmmRouteRrn"));
        Integer version = NumberUtils.toInt(request.getParameter("version"));
        String modelType = request.getParameter("modelType");
        String waferNum = request.getParameter("waferNum");
        List<EqpMonitorStep> list = (List<EqpMonitorStep>) WebUtils.getCacheString2Obj(theform.getCacheDMMStepList());

        Assert.isFalse(StringUtils.isBlank(modelType),
                       Errors.create().key(MessageIdList.DMM_TYPE_EMPTY).content("测机类型为空").build());


        if (CollectionUtils.isNotEmpty(list)) {

            List<Operation> dmmOperations = getDMMStep(list.size());
            for (int i = 0; i < list.size(); i++) {
                list.get(i).setStepRrn(dmmOperations.get(i).getInstanceRrn());
            }

            List<EqpMonitorStep> oldList = dmmService.getDmmModelStepsInfo(modelRrn);

            List<WorkflowStepModel> stepModels = buildStepModel(list, routeRrn, version);
            List<WorkflowStepModel> oldStepModels = dmmService.getStepModels(routeRrn, version);

            List<WorkflowLinkModel> linkModels = buildWorkflowLinkModel(list, stepModels);
            List<WorkflowLinkModel> oldLinkModels = buildWorkflowLinkModel(oldList, oldStepModels);

            WorkflowTemplateModel templateModel = buildTemplateModel(routeRrn, version, stepModels);

            WorkflowEditorModel editorModel = new WorkflowEditorModel(templateModel, "DMM", stepModels, oldStepModels,
                                                                      linkModels, oldLinkModels);
            dmmService.importWorkflow(editorModel);

            dmmService.modifySteps(modelRrn, list);
        } else {
            dmmService.deleteModelSteps(modelRrn);
        }

        EqpMonitorModel dmmModel = new EqpMonitorModel();
        dmmModel.setModelRrn(modelRrn);
        dmmModel.setModelType(modelType);
        dmmModel.setWaferNum(waferNum);
        dmmService.updateDMMModel(dmmModel);

        return mapping.findForward("version");
    }

    public List<Operation> getDMMStep(Integer needSteps) throws Exception {
        List<Operation> operations = dmmService.getDmmOperation(NpwConstants.DMM_STANDARD_STEP);

        int nowOperationsSize = operations.size();

        if (needSteps.intValue() > nowOperationsSize) {

            for (int i = 0; i < needSteps.intValue() - nowOperationsSize; i++) {
                int seq = nowOperationsSize + i + 1;
                Operation operation = new Operation(NpwConstants.DMM_STANDARD_STEP + "-" + seq,
                                                    getNamedSpace(ObjectList.OPERATION_KEY,
                                                                  LocalContext.getFacilityRrn()),
                                                    ObjectList.OPERATION_KEY);
                operation.setObjectType("DUMMY");

                operation.setTransPerformedby(LocalContext.getUserId());
                operation.setTransId(Constants.CREATE_KEY);
                operation.setUnitOfMeasure1("WAFER");

                operation.setMvinWflId(NpwConstants.MOVEIN_STD);
                operation.setMvinWflRrn(this.getInstanceRrn(NpwConstants.MOVEIN_STD, LocalContext.getFacilityRrn(),
                                                            ObjectList.WFL_KEY));
                operation.setMvouWflId(NpwConstants.MOVEOUT_STD);
                operation.setMvouWflRrn(this.getInstanceRrn(NpwConstants.MOVEOUT_STD, LocalContext.getFacilityRrn(),
                                                            ObjectList.WFL_KEY));
                operation.setWsMvinWflId(NpwConstants.MOVEIN_NPW_STD);
                operation.setWsMvinWflRrn(
                        this.getInstanceRrn(NpwConstants.MOVEIN_NPW_STD, LocalContext.getFacilityRrn(),
                                            ObjectList.WFL_KEY));
                operation.setWsMvouWflId(NpwConstants.MOVEOUT_NPW_STD);
                operation.setWsMvouWflRrn(
                        this.getInstanceRrn(NpwConstants.MOVEOUT_NPW_STD, LocalContext.getFacilityRrn(),
                                            ObjectList.WFL_KEY));

                operation.setTrackUnitFlag("on");
                operation.setKeepUnitHistoryFlag("on");
                //                operation.setMoveInRequired("on");

                long operationRrn = prpService.insertOperation(operation);
                baseService.updateNamedObjectSystemUesd(operationRrn, "1");

                operation.setInstanceRrn(operationRrn);
                operations.add(operation);
            }

        }

        return operations;
    }

    private List<WorkflowStepModel> buildStepModel(List<EqpMonitorStep> stepList, Long workflowRrn, Integer version) {
        List<WorkflowStepModel> workflowStepModels = dmmService.buildStepModel(stepList, workflowRrn, version);
        for (int i = 0; i < stepList.size(); i++) {
            //preStepSize 为 start 和end的数量为2
            int preStepSize = 2;
            stepList.get(i).setWorkflowStepRrn(workflowStepModels.get(i + preStepSize).getStepRrn());
        }
        return workflowStepModels;
    }

    private WorkflowTemplateModel buildTemplateModel(Long routeRrn, Integer version,
                                                     List<WorkflowStepModel> stepModels) {

        WorkflowTemplateModel templateModel = new WorkflowTemplateModel(routeRrn, version);

        Long startRrn = null;
        Long endRrn = null;
        for (WorkflowStepModel stepModel : stepModels) {
            if (StringUtils.equalsIgnoreCase("Start", stepModel.getStepId())) {
                startRrn = stepModel.getStepRrn();
            }
            if (StringUtils.equalsIgnoreCase("End", stepModel.getStepId())) {
                endRrn = stepModel.getStepRrn();
            }
        }

        templateModel.setRootFlag("Y");
        templateModel.setFirstStepRrn(startRrn);
        templateModel.setLastStepRrn(endRrn);
        return templateModel;
    }

    private List<WorkflowLinkModel> buildWorkflowLinkModel(List<EqpMonitorStep> stepList,
                                                           List<WorkflowStepModel> stepModels) {

        Long startRrn = null;
        Long endRrn = null;
        for (WorkflowStepModel stepModel : stepModels) {
            if (StringUtils.equalsIgnoreCase("Start", stepModel.getStepId())) {
                startRrn = stepModel.getStepRrn();
            }
            if (StringUtils.equalsIgnoreCase("End", stepModel.getStepId())) {
                endRrn = stepModel.getStepRrn();
            }
        }
        if (startRrn == null || endRrn == null) {
            return new ArrayList<WorkflowLinkModel>();
        }

        List<EqpMonitorStep> list = new ArrayList<EqpMonitorStep>();
        list.addAll(stepList);
        list = (List<EqpMonitorStep>) sortBySeq(list);

        List<WorkflowLinkModel> linkModels = new ArrayList<WorkflowLinkModel>();
        long stepRrn = startRrn.longValue();
        for (int i = 0; i < list.size(); i++) {
            WorkflowLinkModel linkModel = new WorkflowLinkModel();
            linkModel.setStepRrn(stepRrn);
            linkModel.setNextStepRrn(list.get(i).getWorkflowStepRrn());
            linkModel.setConditionType("And");
            linkModels.add(linkModel);
            stepRrn = list.get(i).getWorkflowStepRrn();
            if (i == list.size() - 1) {
                WorkflowLinkModel linkModelEnd = new WorkflowLinkModel();
                linkModelEnd.setStepRrn(stepRrn);
                linkModelEnd.setNextStepRrn(endRrn);
                linkModelEnd.setConditionType("And");
                linkModels.add(linkModelEnd);
            }
        }

        return linkModels;
    }

    private List<EqpMonitorStep> sortBySeq(List<EqpMonitorStep> collection) {
        ArrayList<EqpMonitorStep> steps = new ArrayList<EqpMonitorStep>();
        steps.addAll(collection);

        collection = new ArrayList<EqpMonitorStep>();
        while (steps.size() > 0) {
            int count = -1;
            for (int i = 0; i < steps.size(); i++) {
                EqpMonitorStep _dmmStep = steps.get(i);
                if (count == -1) {
                    count = i;
                }
                if (steps.get(count).getModelSeq().intValue() > _dmmStep.getModelSeq().intValue()) {
                    count = i;
                }
            }
            collection.add(steps.get(count));
            steps.remove(count);
        }
        return collection;
    }

    private String validateRecipeIdStr(String recipeIds) {
        String msg = "";
        if (StringUtils.isBlank(recipeIds)) {
            msg += "recipe is empty\n";
        }
        String[] recipeId = StringUtils.split(recipeIds, ",");
        for (int i = 0; i < recipeId.length; i++) {
            long recipeRrn = getInstanceRrn(recipeId[i].trim(), LocalContext.getFacilityRrn(), ObjectList.RECIPE_KEY);
            if (recipeRrn <= 0) {
                msg += "recipe:" + recipeId[i] + "not exist!\n";
            }
        }
        return msg;
    }

}