RouteVersionSaveAction.java

package com.mycim.webapp.actions.route;

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.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.SessionNames;
import com.mycim.valueobject.consts.VersionStatus;
import com.mycim.valueobject.prp.Ecn;
import com.mycim.valueobject.prp.ProcessPlanning;
import com.mycim.valueobject.prp.Route;
import com.mycim.valueobject.prp.RouteVersion;
import com.mycim.webapp.Constants;
import com.mycim.webapp.WebUtils;
import com.mycim.webapp.actions.PrpSetupAction;
import com.mycim.webapp.forms.VersionForm;
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 Johnson.Wang
 * @version 6.0.0
 * @date 2019/8/30
 **/
public class RouteVersionSaveAction extends PrpSetupAction {

    @Override
    public ActionForward init(ActionMapping mapping, ActionForm form, HttpServletRequest request,
                              HttpServletResponse response) throws Exception {
        request.setAttribute(SessionNames.FACILITY_INFO_KEY, sysService.getFacility(LocalContext.getFacilityRrn()));

        VersionForm versionForm = (VersionForm) form;
        Route route = new Route(versionForm.getInstanceId(),
                                getNamedSpace(ObjectList.ROUTE_KEY, LocalContext.getFacilityRrn()), ObjectList.WFL_KEY);
        route.setObjectType(ObjectList.ROUTE_KEY);
        route = (Route) getInstance(route);

        List<ObjectVersion> versions = baseService.getObjectVersions(route);

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

        ObjectVersion currentVersion = versions.get(0);
        currentVersion.copyNamedObject(route);

        PropertyUtils.copyProperties(versionForm, currentVersion);
        versionForm.setEcnFlag(getEcnFlag());
        versionForm.setTransId(Constants.MODIFY_KEY);
        versionForm.setVersionEditEnable(String.valueOf(checkVersionEditEnable(currentVersion)));
        versionForm.setObjectDeleteEnable(checkObjectDeleteEnable(versions));
        versionForm.setNpwType(route.getAttribute3());
        request.setAttribute(SessionNames.ROUTE_VERSION_KEY, currentVersion);
        return mapping.findForward(Constants.MODIFY_KEY);
    }

    public ActionForward versionInfo(ActionMapping mapping, VersionForm 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);

        ObjectVersion pv = baseService.getObjectVersion(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", "/routeversionsave");

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


    public ActionForward addVersionWithEcn(ActionMapping mapping, VersionForm form, HttpServletRequest request,
                                           HttpServletResponse response) throws Exception {
        Route route = new Route(form.getInstanceId(),
                                getNamedSpace(ObjectList.ROUTE_KEY, LocalContext.getFacilityRrn()), ObjectList.WFL_KEY);
        route.setObjectType(ObjectList.ROUTE_KEY);
        route = (Route) this.getInstance(route);
        RouteVersion routeVersion = new RouteVersion();
        List<ObjectVersion> versions = baseService.getObjectVersions(route);
        boolean versionEdit = checkVersionEditEnable(versions);
        Assert.isFalse(versionEdit,
                       Errors.create().key(MessageIdList.VERSION_HAS_NOT_ACTIVE_VERSION).content("版本未激活").build());
        routeVersion.copyNamedObject(route);
        routeVersion.setInstanceVersion(route.getCurrentVersion() + 1);
        routeVersion.setVersionId(route.getCurrentVersion() + 1 + "");
        routeVersion.setVersionDesc("Automatic schema generation");
        routeVersion.setVersionStatus(VersionStatus.UNFROZEN_KEY);
        routeVersion.setTransId(Constants.CREATE_KEY);
        routeVersion.setTransPerformedby(LocalContext.getUserId());
        prpService.insertRouteVersionWithEcn(routeVersion);

        PropertyUtils.copyProperties(form, routeVersion);

        form.setTransId(Constants.MODIFY_KEY);
        form.setEcnFlag(getEcnFlag());
        form.setVersionEditEnable(String.valueOf(checkVersionEditEnable(routeVersion)));
        request.setAttribute(SessionNames.ROUTE_VERSION_KEY, routeVersion);
        return init(mapping, form, request, response);
    }

    public ActionForward useInfo(ActionMapping mapping, VersionForm versionInfo, HttpServletRequest request) {
        long routeRrn = this
                .getInstanceRrn(versionInfo.getInstanceId(), LocalContext.getFacilityRrn(), ObjectList.WFL_KEY);
        List<ProcessPlanning> usedProcess = prpService.getUsedByProcess(routeRrn);
        if (CollectionUtils.isNotEmpty(usedProcess)) {
            List<Map> wflLists = new ArrayList<>();
            for (ProcessPlanning processPlanning : usedProcess) {
                Map<String, Object> wfl = new HashMap<>(4);
                wfl.put("routeId", processPlanning.getInstanceId());
                wfl.put("routeDesc", processPlanning.getInstanceDesc());
                wfl.put("routeRrn", processPlanning.getInstanceRrn());
                wfl.put("routeVersion", processPlanning.getCurrentVersion());
                wflLists.add(wfl);
            }
            request.setAttribute("wflLists", wflLists);
        }
        return mapping.findForward("routewheretouse");
    }

    public ActionForward delete(ActionMapping mapping, VersionForm form, HttpServletRequest request,
                                HttpServletResponse response) throws Exception {
        Route route = new Route(form.getInstanceId(),
                                getNamedSpace(ObjectList.ROUTE_KEY, LocalContext.getFacilityRrn()), ObjectList.WFL_KEY);
        route.setObjectType(ObjectList.ROUTE_KEY);
        route = (Route) this.getInstance(route);

        RouteVersion routeVersion = new RouteVersion();
        routeVersion.setInstanceRrn(route.getInstanceRrn());
        routeVersion.setInstanceVersion(Integer.parseInt(form.getVersionId()));
        routeVersion = prpService.getRouteVersion(routeVersion);

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

        prpService.deleteRouteVersion(routeVersion);

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

    public ActionForward activate(ActionMapping mapping, VersionForm form, HttpServletRequest request,
                                  HttpServletResponse response) throws Exception {
        Route route = new Route(form.getInstanceId(),
                                getNamedSpace(ObjectList.ROUTE_KEY, LocalContext.getFacilityRrn()), ObjectList.WFL_KEY);
        route.setObjectType(ObjectList.ROUTE_KEY);
        route = (Route) this.getInstance(route);

        RouteVersion routeVersion = new RouteVersion();
        routeVersion.setInstanceRrn(route.getInstanceRrn());
        routeVersion.setInstanceVersion(Integer.parseInt(form.getVersionId()));
        routeVersion = prpService.getRouteVersion(routeVersion);

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

        validateProcessPlan((List) ecn.getObjects());
        routeVersion.setTransPerformedby(LocalContext.getUserId());
        prpService.activeRouteVersionByEcnRrn(routeVersion);

        form.setVersionStatus(VersionStatus.ACTIVE_KEY);
        List<ObjectVersion> versions = baseService.getObjectVersions(route);

        route.setVersions(versions);

        request.setAttribute("version", versions);

        form.setTransId(Constants.MODIFY_KEY);
        form.setVersionEditEnable("false");

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


    public ActionForward detail(ActionMapping mapping, VersionForm form, HttpServletRequest request,
                                HttpServletResponse response) {
        request.setAttribute(SessionNames.FACILITY_INFO_KEY, sysService.getFacility(LocalContext.getFacilityRrn()));
        Route route = new Route(form.getInstanceId(),
                                getNamedSpace(ObjectList.ROUTE_KEY, LocalContext.getFacilityRrn()), ObjectList.WFL_KEY);
        route.setObjectType(ObjectList.ROUTE_KEY);
        route = (Route) this.getInstance(route);
        List<ObjectVersion> versions = baseService.getObjectVersions(route);
        request.setAttribute("version", versions);
        request.setAttribute("editaction", "/routeversionsave.do");
        request.setAttribute("initaction", "/routesave.do");
        request.setAttribute("versionedit", checkVersionEditEnable(versions) + "");
        request.setAttribute("objectform", "versionForm");

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

    public ActionForward version(ActionMapping mapping, HttpServletRequest request, VersionForm form,
                                 HttpServletResponse response) {
        Route route = new Route(form.getInstanceId(), getNamedSpace(ObjectList.WFL_KEY, LocalContext.getFacilityRrn()),
                                ObjectList.WFL_KEY);
        route = (Route) this.getInstance(route);

        List<ObjectVersion> versions = baseService.getObjectVersions(route);

        RouteVersion routeVersion = new RouteVersion();
        routeVersion.setInstanceRrn(route.getInstanceRrn());
        routeVersion.setInstanceVersion(form.getInstanceVersion());

        routeVersion = prpService.getRouteVersion(routeVersion);
        routeVersion.copyNamedObject(route);
        PropertyUtils.copyProperties(form, routeVersion);
        form.setEcnFlag(getEcnFlag());
        form.setNpwType(route.getAttribute3());
        form.setTransId(Constants.MODIFY_KEY);
        form.setVersionEditEnable(String.valueOf(checkVersionEditEnable(routeVersion)));
        form.setObjectDeleteEnable(checkObjectDeleteEnable(versions));
        request.setAttribute(SessionNames.ROUTE_VERSION_KEY, routeVersion);
        return mapping.findForward(Constants.MODIFY_KEY);
    }

}