EqpMonitorProcessVersionAction.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.beans.PropertyUtils;
import com.mycim.framework.utils.lang.StringUtils;
import com.mycim.framework.utils.lang.collections.CollectionUtils;
import com.mycim.valueobject.MessageIdList;
import com.mycim.valueobject.ObjectList;
import com.mycim.valueobject.bas.NamedObject;
import com.mycim.valueobject.bas.ObjectVersion;
import com.mycim.valueobject.consts.ObjectStatus;
import com.mycim.valueobject.consts.SessionNames;
import com.mycim.valueobject.consts.TransactionNames;
import com.mycim.valueobject.consts.VersionStatus;
import com.mycim.valueobject.prp.*;
import com.mycim.webapp.Constants;
import com.mycim.webapp.WebUtils;
import com.mycim.webapp.actions.NpwSetupAction;
import com.mycim.webapp.forms.TechnologyVersionInfoForm;
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.lang.Override;
import java.util.ArrayList;
import java.util.List;

/**
 * @author shijie.deng
 * @version 6.0.0
 * @date 2019/11/11
 **/
public class EqpMonitorProcessVersionAction extends NpwSetupAction {
    @Override
    public ActionForward init(ActionMapping mapping, ActionForm form, HttpServletRequest request,
                              HttpServletResponse response) throws Exception {
        request.setAttribute(SessionNames.FACILITY_INFO_KEY, sysService.getFacility(LocalContext.getFacilityRrn()));

        TechnologyVersionInfoForm infoForm = (TechnologyVersionInfoForm) form;

        ProcessPlanning processPlanning = new ProcessPlanning(infoForm.getInstanceId(),
                                                              getNamedSpace(ObjectList.WFL_KEY,
                                                                            LocalContext.getFacilityRrn()),
                                                              ObjectList.WFL_KEY);
        processPlanning = prpService.getProcessPlanning(processPlanning);
        checkPermissionForOperateProcess(processPlanning.getInstanceRrn());
        List<ProcessVersion> versions = prpService.getProcessVersions(processPlanning);

        if (CollectionUtils.isEmpty(versions)) {
            request.setAttribute("editaction", "/dmmprocessversion.do");
            request.setAttribute("initaction", "/dmmprocess.do");
            return mapping.findForward(Constants.ADDVERSION_KEY);
        }

        ObjectVersion currentVersion = versions.get(0);
        if (StringUtils.isNotEmpty(infoForm.getVersionId())) {
            currentVersion = prpService
                    .getProcessVersion(processPlanning.getInstanceRrn(), Integer.parseInt(infoForm.getVersionId()));
        }

        currentVersion.copyNamedObject(processPlanning);

        PropertyUtils.copyProperties(infoForm, currentVersion);
        infoForm.setEcnFlag(getEcnFlag());
        infoForm.setTransId(Constants.MODIFY_KEY);
        infoForm.setVersionEditEnable(String.valueOf(checkVersionEditEnable(currentVersion)));
        infoForm.setObjectDeleteEnable(checkObjectDeleteEnable(versions));
        request.setAttribute(SessionNames.PROCESS_VERSION_KEY, currentVersion);
        return mapping.findForward(Constants.MODIFY_KEY);
    }

    public ActionForward versionInfo(ActionMapping mapping, TechnologyVersionInfoForm form, HttpServletRequest request,
                                     HttpServletResponse response) throws Exception {
        String rrn = request.getParameter("versionRrn");
        String version = request.getParameter("version");

        int ver = Integer.parseInt(version);
        long versionRrn = Long.parseLong(rrn);

        NamedObject namedObject = new NamedObject();
        namedObject.setInstanceRrn(versionRrn);
        namedObject = baseService.getNamedObject(namedObject);

        ProcessVersion pv = prpService.getProcessVersion(versionRrn, ver);
        pv.copyNamedObject(namedObject);

        request.setAttribute("historys",
                             baseService.getObjectVersionHistoryList(pv.getInstanceRrn(), pv.getInstanceVersion()));
        PropertyUtils.copyProperties(form, pv);

        form.setTransId(Constants.MODIFY_KEY);
        request.setAttribute("actionedit", "/dmmprocessversion");

        return (mapping.findForward("detail"));
    }

    public ActionForward addVersionWithEcn(ActionMapping mapping, TechnologyVersionInfoForm form,
                                           HttpServletRequest request, HttpServletResponse response) throws Exception {
        ProcessPlanning processPlanning = new ProcessPlanning(form.getInstanceId(), getNamedSpace(ObjectList.WFL_KEY,
                                                                                                  LocalContext
                                                                                                          .getFacilityRrn()),
                                                              ObjectList.WFL_KEY);
        processPlanning = prpService.getProcessPlanning(processPlanning);
        ProcessVersion processVersion = new ProcessVersion();
        processVersion.copyNamedObject(processPlanning);
        processVersion.setInstanceVersion(processPlanning.getCurrentVersion().intValue() + 1);
        processVersion.setVersionId(processPlanning.getCurrentVersion().intValue() + 1 + "");
        processVersion.setVersionDesc("Automatic schema generation");
        processVersion.setVersionStatus(VersionStatus.UNFROZEN_KEY);
        processVersion.setTransId(Constants.CREATE_KEY);
        processVersion.setTransPerformedby(LocalContext.getUserId());

        prpService.createProcessVersion(processVersion, processPlanning.getCurrentVersion());

        Route route = new Route(getDMMRouteId(processPlanning.getInstanceId()),
                                getNamedSpace(ObjectList.WFL_KEY, LocalContext.getFacilityRrn()), ObjectList.WFL_KEY);
        long routeRrn = this.getInstanceRrn(route.getInstanceId(), LocalContext.getFacilityRrn(), ObjectList.WFL_KEY);
        if (routeRrn <= 0) {
            route = new Route(route.getInstanceId(), 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, "Y");
            route.setInstanceRrn(routeRrn);
            route.setCurrentVersion(0);
        } else {
            route.setInstanceRrn(routeRrn);
            route = prpService.getRoute(route);
        }

        RouteVersion routeVersion = new RouteVersion();
        routeVersion.copyNamedObject(route);
        routeVersion.setInstanceVersion(route.getCurrentVersion().intValue() + 1);
        routeVersion.setVersionId(route.getCurrentVersion().intValue() + 1 + "");
        routeVersion.setVersionDesc("Automatic schema generation");
        routeVersion.setTransId(Constants.CREATE_KEY);
        routeVersion.setVersionStatus(VersionStatus.UNFROZEN_KEY);
        routeVersion.setTransPerformedby(LocalContext.getUserId());
        prpService.insertRouteVersionWithEcn(routeVersion);
        importNewWorkflow(processVersion, route);
        return init(mapping, form, request, response);
    }

    public ActionForward delete(ActionMapping mapping, TechnologyVersionInfoForm form, HttpServletRequest request,
                                HttpServletResponse response) throws Exception {
        //1.删除process version
        ProcessPlanning processPlanning = new ProcessPlanning(form.getInstanceId(), getNamedSpace(ObjectList.WFL_KEY,
                                                                                                  LocalContext
                                                                                                          .getFacilityRrn()),
                                                              ObjectList.WFL_KEY);
        processPlanning = prpService.getProcessPlanning(processPlanning);

        ProcessVersion pv = new ProcessVersion();
        pv.setInstanceRrn(processPlanning.getInstanceRrn());
        pv.setInstanceVersion(Integer.parseInt(form.getVersionId()));
        pv = prpService.getProcessVersion(processPlanning.getInstanceRrn(), Integer.parseInt(form.getVersionId()));

        pv.setTransId(Constants.DELETE_KEY);
        pv.setTransPerformedby(LocalContext.getUserId());

        prpService.deleteProcessVersion(pv);

        //2.删除dmm route version
        Route route = new Route(getDMMRouteId(processPlanning.getInstanceId()),
                                getNamedSpace(ObjectList.WFL_KEY, LocalContext.getFacilityRrn()), ObjectList.WFL_KEY);
        long routeRrn = getInstanceRrn(route.getInstanceId(), LocalContext.getFacilityRrn(), ObjectList.WFL_KEY);
        route.setInstanceRrn(routeRrn);
        route = (Route) getInstance(route);
        List<ObjectVersion> routeVersions = baseService.getObjectVersions(route);
        if (CollectionUtils.isNotEmpty(routeVersions)) {
            ObjectVersion objectVersion = routeVersions.get(0);
            RouteVersion routeVersion = new RouteVersion();
            routeVersion.copyObjectVersion(objectVersion);
            routeVersion.copyNamedObject(route);
            routeVersion.setTransId(Constants.DELETE_KEY);
            routeVersion.setTransPerformedby(LocalContext.getUserId());

            EqpMonitorModel dmmModel = dmmService
                    .getDmmModelByWfl(routeVersion.getInstanceRrn(), routeVersion.getInstanceVersion());
            if (dmmModel != null) {
                dmmService.deleteDMMModel(dmmModel);
            }
            prpService.deleteRouteVersion(routeVersion);
        }

        WebUtils.setSuccessMsg(request);
        return detail(mapping, form, request, response);
    }

    public ActionForward activate(ActionMapping mapping, TechnologyVersionInfoForm form, HttpServletRequest request,
                                  HttpServletResponse response) throws Exception {

        //1.激活route
        Route route = new Route(getDMMRouteId(form.getInstanceId()),
                                getNamedSpace(ObjectList.WFL_KEY, LocalContext.getFacilityRrn()), ObjectList.WFL_KEY);
        long routeRrn = getInstanceRrn(route.getInstanceId(), LocalContext.getFacilityRrn(), ObjectList.WFL_KEY);
        route.setInstanceRrn(routeRrn);
        route = prpService.getRoute(route);

        List<ObjectVersion> routeVersions = baseService.getObjectVersions(route);
        if (CollectionUtils.isNotEmpty(routeVersions)) {
            ObjectVersion objectVersion = routeVersions.get(0);
            prpService.activeteEcnByRouteVersion(objectVersion, LocalContext.getUserId());
        }
        //2.激活process
        ProcessPlanning processPlanning = new ProcessPlanning(form.getInstanceId(), getNamedSpace(ObjectList.WFL_KEY,
                                                                                                  LocalContext
                                                                                                          .getFacilityRrn()),
                                                              ObjectList.WFL_KEY);
        processPlanning = prpService.getProcessPlanning(processPlanning);

        ProcessVersion processVersion = prpService
                .getProcessVersion(processPlanning.getInstanceRrn(), Integer.parseInt(form.getVersionId()));

        //        Ecn ecn = ecnService.getEcn(processVersion.getEcnRrn());

        //        ecnService.activateEcn(ecn.getInstanceRrn());
        processVersion.setVersionStatus(VersionStatus.ACTIVE_KEY);
        prpService.updateProcessVersionByEcnRrn(processVersion);

        dmmService.updateModelStatus(routeRrn, processVersion.getInstanceVersion(), ObjectStatus.ACTIVE_KEY);
        form.setVersionStatus(VersionStatus.ACTIVE_KEY);
        List<ObjectVersion> versions = baseService.getObjectVersions(processPlanning);

        processPlanning.setVersions(versions);

        request.setAttribute("version", versions);

        form.setTransId(Constants.MODIFY_KEY);
        form.setVersionEditEnable("false");
        return init(mapping, form, request, response);
    }

    public ActionForward detail(ActionMapping mapping, TechnologyVersionInfoForm form, HttpServletRequest request,
                                HttpServletResponse response) throws Exception {
        request.setAttribute(SessionNames.FACILITY_INFO_KEY, sysService.getFacility(LocalContext.getFacilityRrn()));
        ProcessPlanning processPlanning = new ProcessPlanning(form.getInstanceId(), getNamedSpace(ObjectList.WFL_KEY,
                                                                                                  LocalContext
                                                                                                          .getFacilityRrn()),
                                                              ObjectList.WFL_KEY);
        processPlanning = prpService.getProcessPlanning(processPlanning);
        List<ProcessVersion> versions = prpService.getProcessVersions(processPlanning);
        if (CollectionUtils.isEmpty(versions)) {
            versions = new ArrayList<>();
        }
        request.setAttribute("version", versions);
        request.setAttribute("editaction", "/dmmprocessversion.do");
        request.setAttribute("initaction", "/dmmprocess.do");
        request.setAttribute("objectform", "technologyInfoForm");
        request.setAttribute("versionedit", checkVersionEditEnable(versions) + "");

        return (mapping.findForward("version"));
    }

    public ActionForward frozen(ActionMapping mapping, HttpServletRequest request, TechnologyVersionInfoForm theform,
                                HttpServletResponse response) throws Exception {
        ProcessPlanning processPlanning = new ProcessPlanning(theform.getInstanceId(), getNamedSpace(ObjectList.WFL_KEY,
                                                                                                     LocalContext
                                                                                                             .getFacilityRrn()),
                                                              ObjectList.WFL_KEY);
        processPlanning = prpService.getProcessPlanning(processPlanning);

        ProcessVersion processVersion = prpService
                .getProcessVersion(processPlanning.getInstanceRrn(), Integer.parseInt(theform.getVersionId()));

        Ecn ecn = ecnService.getEcn(processVersion.getEcnRrn());


        ecn.setEcnStatus(VersionStatus.FROZEN_KEY);
        ecn.setTransId(TransactionNames.FROZEN_KEY);
        ecn.setTransPerformedby(LocalContext.getUserId());
        if (ecn.getObjectSubtype() == null) {
            ecn.setObjectSubtype(ecn.getObjectType());
        }
        long workflowRrn = ecnService.getEcnSignOffRrn(ecn.getObjectSubtype(),
                                                       getNamedSpace(ObjectList.REFERENCE_FILE_KEY,
                                                                     LocalContext.getFacilityRrn()),
                                                       getNamedSpace(ObjectList.WFL_KEY,
                                                                     LocalContext.getFacilityRrn()));

        Assert.isFalse(workflowRrn == 0, Errors.create().key(MessageIdList.WORKFLOW_MISSING_SIGNOFF)
                                               .content("Not foud SignOff ecn Workflow").build());


        List list = (List) ecn.getObjects();
        validateProcessPlan(list);

        //check multipath
        prpService.checkWflIsInProcess(processVersion.getInstanceRrn(), processVersion.getInstanceVersion());

        //todo ecn提交审核
        //        getProcessManager().invokeWorkflow(execRrn, map);

        //冻结之前校验流程是否进行了配置
        Route route = new Route(getDMMRouteId(processPlanning.getInstanceId()),
                                getNamedSpace(ObjectList.WFL_KEY, LocalContext.getFacilityRrn()), ObjectList.WFL_KEY);
        long routeRrn = getInstanceRrn(route.getInstanceId(), LocalContext.getFacilityRrn(), ObjectList.WFL_KEY);
        int instanceVersion = baseService.getNamedObject(routeRrn).getCurrentVersion();
        //如果流程升版，即使没有修改添加步骤，也可以冻结，故这个check只需要判断路径版本为1的时候就可以了
        ObjectVersion objectVersion = baseService.getObjectVersion(routeRrn, instanceVersion);
        EqpMonitorModel dmmModel = dmmService
                .getDmmModelByWfl(objectVersion.getInstanceRrn(), objectVersion.getInstanceVersion());
        Assert.notNull(dmmModel,
                       Errors.create().key(MessageIdList.DMM_FROZEN_DMMPROCESS_CHECK).content("请先在流程中添加步骤").build());

        List<EqpMonitorStep> stepList = dmmService.getDmmModelStepsInfo(dmmModel.getModelRrn());
        Assert.isFalse(stepList.size() == 0,
                       Errors.create().key(MessageIdList.DMM_FROZEN_DMMPROCESS_CHECK).content("请先在流程中添加步骤").build());

        //        ecnService.frozenEcn(ecn.getInstanceRrn());
        processVersion.setVersionStatus(VersionStatus.FROZEN_KEY);
        prpService.updateProcessVersionByEcnRrn(processVersion);

        return init(mapping, theform, request, response);
    }

    public ActionForward unfrozen(ActionMapping mapping, HttpServletRequest request, TechnologyVersionInfoForm theform,
                                  HttpServletResponse response) throws Exception {

        ProcessPlanning processPlanning = new ProcessPlanning(theform.getInstanceId(), getNamedSpace(ObjectList.WFL_KEY,
                                                                                                     LocalContext
                                                                                                             .getFacilityRrn()),
                                                              ObjectList.WFL_KEY);
        processPlanning = prpService.getProcessPlanning(processPlanning);

        ProcessVersion processVersion = prpService
                .getProcessVersion(processPlanning.getInstanceRrn(), Integer.parseInt(theform.getVersionId()));

        Ecn ecn = ecnService.getEcn(processVersion.getEcnRrn());
        ecn.setEcnStatus(VersionStatus.UNFROZEN_KEY);
        ecn.setTransId(TransactionNames.UNFROZEN_KEY);
        ecn.setTransPerformedby(LocalContext.getUserId());

        //        ecnService.unFrozenEcn(ecn.getInstanceRrn());
        processVersion.setVersionStatus(VersionStatus.UNFROZEN_KEY);
        prpService.updateProcessVersionByEcnRrn(processVersion);
        // fixme cleanECNExecutionRrn
        //        getProcessManager().cleanECNExecutionRrn(ecn.getInstanceRrn());

        processVersion = prpService
                .getProcessVersion(processPlanning.getInstanceRrn(), Integer.parseInt(theform.getVersionId()));
        processVersion.copyNamedObject(processPlanning);

        List<ProcessVersion> versions = prpService.getProcessVersions(processPlanning);
        request.setAttribute(SessionNames.PROCESSVERSION_KEY, processVersion);
        processPlanning.setVersions(versions);

        request.setAttribute("version", versions);
        request.setAttribute(SessionNames.PROCESSVERSION_KEY, processVersion);

        theform.setVersionStatus(VersionStatus.UNFROZEN_KEY);
        theform.setTransId(Constants.MODIFY_KEY);
        theform.setVersionEditEnable(String.valueOf(checkVersionEditEnable(processVersion)));
        theform.setObjectDeleteEnable(checkObjectDeleteEnable(versions));
        theform.setObjectType(ecn.getObjectType());
        return init(mapping, theform, request, response);
    }

    public ActionForward version(ActionMapping mapping, HttpServletRequest request, TechnologyVersionInfoForm theform,
                                 HttpServletResponse response) throws Exception {
        ProcessPlanning processPlanning = new ProcessPlanning(theform.getInstanceId(), getNamedSpace(ObjectList.WFL_KEY,
                                                                                                     LocalContext
                                                                                                             .getFacilityRrn()),
                                                              ObjectList.WFL_KEY);
        processPlanning = prpService.getProcessPlanning(processPlanning);

        ProcessVersion processVersion = prpService
                .getProcessVersion(processPlanning.getInstanceRrn(), theform.getInstanceVersion());

        List<ProcessVersion> versions = prpService.getProcessVersions(processPlanning);

        processVersion.copyNamedObject(processPlanning);

        PropertyUtils.copyProperties(theform, processVersion);
        theform.setEcnFlag(getEcnFlag());
        theform.setTransId(Constants.MODIFY_KEY);
        theform.setVersionEditEnable(String.valueOf(checkVersionEditEnable(processVersion)));
        theform.setObjectDeleteEnable(checkObjectDeleteEnable(versions));
        request.setAttribute(SessionNames.PROCESS_VERSION_KEY, processVersion);
        return mapping.findForward(Constants.MODIFY_KEY);
    }

    private void importNewWorkflow(ProcessVersion processVersion, Route route) {

        List<WorkflowStepModel> stepModels = dmmService
                .buildStepModel(processVersion.getInstanceRrn(), processVersion.getInstanceVersion(), route);
        List<WorkflowStepModel> oldStepModels = dmmService
                .getStepModels(processVersion.getInstanceRrn(), processVersion.getInstanceVersion());
        List<WorkflowLinkModel> linkModels = buildWorkflowLinkModel(stepModels);
        List<WorkflowLinkModel> oldLinkModels = buildWorkflowLinkModel(oldStepModels);

        WorkflowTemplateModel templateModel = buildTemplateModel(processVersion.getInstanceRrn(),
                                                                 processVersion.getInstanceVersion(), stepModels);
        WorkflowEditorModel editorModel = new WorkflowEditorModel(templateModel, "DMM", stepModels, oldStepModels,
                                                                  linkModels, oldLinkModels);
        dmmService.importWorkflow(editorModel);
    }


    private List<WorkflowLinkModel> buildWorkflowLinkModel(List<WorkflowStepModel> stepModels) {

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

        List<WorkflowLinkModel> linkModels = new ArrayList<WorkflowLinkModel>();
        if (startRrn != null && endRrn != null && routeStep != null) {

            long stepRrn = startRrn.longValue();
            WorkflowLinkModel linkModelStart = new WorkflowLinkModel();
            linkModelStart.setStepRrn(stepRrn);
            linkModelStart.setNextStepRrn(routeStep.getStepRrn());
            linkModelStart.setConditionType("And");

            linkModels.add(linkModelStart);

            WorkflowLinkModel linkModelEnd = new WorkflowLinkModel();
            linkModelEnd.setStepRrn(routeStep.getStepRrn());
            linkModelEnd.setNextStepRrn(endRrn);
            linkModelEnd.setConditionType("And");

            linkModels.add(linkModelEnd);
        }
        return linkModels;
    }

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

        WorkflowTemplateModel templateModel = new WorkflowTemplateModel(processRrn, 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;
    }

}