OcapStepAbstractAction.java

package com.mycim.webapp.actions;

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.msg.JsonUtils;
import com.mycim.valueobject.consts.ActionIdEnum;
import com.mycim.valueobject.consts.SessionNames;
import com.mycim.valueobject.consts.SpecifiedActionEnum;
import com.mycim.valueobject.ocap.OcapCard;
import com.mycim.valueobject.ocap.dto.DoActionDTO;
import com.mycim.valueobject.ocap.dto.OcapCardDTO;
import com.mycim.valueobject.ocap.dto.OcapDoActionDTO;
import com.mycim.valueobject.ocap.dto.RADCommentDTO;
import com.mycim.webapp.WebUtils;
import com.mycim.webapp.forms.RootForm;
import org.apache.commons.lang3.EnumUtils;
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.*;

/**
 * @author songpy
 * @version 1.0.0
 * @date 2021/6/7
 **/
public abstract class OcapStepAbstractAction extends OcapAbstractAction {
    protected static final String ACTION_URL_KEY = "ocapActionUrl";

    protected SpecifiedActionEnum actionType = SpecifiedActionEnum.NORMAL;

    @Override
    public ActionForward init(ActionMapping mapping, ActionForm form, HttpServletRequest request,
                              HttpServletResponse response) throws Exception {
        initCache((RootForm) form, request);
        setActionUrl(request);
        Map<String, Object> parametersMap = (Map) request.getAttribute(SessionNames.PARAMETERSINFO_KEY);

        String ocapId = MapUtils.getString(parametersMap, "ocapId");
        String lotId = MapUtils.getString(parametersMap, "lotId");
        lotId = StringUtils.isBlankCheckNull(lotId) ? StringUtils.EMPTY : lotId;
        long ocapRrn = MapUtils.getLongValue(parametersMap, "ocapRrn");

        if (StringUtils.isNotEmpty(ocapId)) {
            OcapCardDTO ocapInformationDTO = ocapService
                    .getOcapInfo(LocalContext.getFacilityRrn(), LocalContext.getUserId(), ocapId, lotId);
            if (ocapInformationDTO != null) {
                ocapRrn = ocapInformationDTO.getOcapRrn();
                ocapId = ocapInformationDTO.getOcapId();
            }
        }

        if (StringUtils.isNotBlank(ocapId)) {
            registerOptionTypeForOcap(LocalContext.getFacilityRrn(), ocapId, request);
        }

        request.setAttribute("lotId", lotId);
        request.setAttribute("ocapRrn", ocapRrn);
        request.setAttribute("ocapId", ocapId);
        request.setAttribute("specifiedAction", actionType.toString());
        request.setAttribute("selectItems", JsonUtils.toString(getSelectItems()));
        return mapping.getInputForward();
    }

    /**
     * Action 方法
     **/
    public void doAction(DoActionDTO actionDTO) throws Exception {
        OcapDoActionDTO doActionDTO = buildBaseOcapDoActionDTO(actionDTO);
        doActionDTO.setOcapId(actionDTO.getOcapId());
        doActionDTO.setLotId(actionDTO.getLotId());

        Map<String, Object> parameters = (Map) WebUtils.getCacheString2Obj(actionDTO.getCacheParametersInfo());
        doActionDTO.setParameters(parameters);

        checkActionType(actionDTO.getActionId());

        OcapCard ocap = wipQueryService
                .getOcapCardByUniqueKey(LocalContext.getFacilityRrn(), actionDTO.getOcapId(), actionDTO.getLotId());
        validOcapMainLot(ocap);

        ocapService.doReviewAction(LocalContext.getFacilityRrn(), doActionDTO);
    }

    private void checkActionType(String actionId) {
        Assert.isTrue(EnumUtils.isValidEnum(ActionIdEnum.class, actionId),
                      Errors.create().content("This action: {} is not defined！").args(actionId).build());
    }

    private void registerOptionTypeForOcap(Long facilityRrn, String ocapId, HttpServletRequest request) {
        String lotId = WebUtils.getParameterUpperCase("lotId", request);
        lotId = StringUtils.isBlankCheckNull(lotId) ? StringUtils.EMPTY : lotId;
        List<String> types = new ArrayList<>();

        types.add("holdGroup");
        types.add("reasonGroup");

        Boolean newRadCommentExist = false;
        HashMap<String, Object> reponseData = new HashMap<>();
        OcapCard ocap = wipQueryService.getOcapCardByUniqueKey(facilityRrn, ocapId, lotId);
        String userGroupIds = getOcapSignerUserGroupIds(ocap);

        if (StringUtils.isNotBlank(userGroupIds)) {
            newRadCommentExist = buildRadCommonts(newRadCommentExist, reponseData, ocap, userGroupIds);
        }

        if (Boolean.TRUE.equals(!newRadCommentExist)) {
            types.add("radComment");
        }

        for (String type : types) {
            Collection optionValues = getOptionTypeList(facilityRrn, type);
            if (optionValues != null) {
                List comboxData = buildComboxDatas(optionValues);
                reponseData.put(type, comboxData);
            }
        }

        put("COMBOXDATAS", JsonUtils.toString(reponseData), request);
        put("newRadCommentExist", newRadCommentExist, request);
    }

    private Boolean buildRadCommonts(Boolean newRadCommentExist, HashMap<String, Object> reponseData, OcapCard ocap,
                                     String userGroupIds) {
        Map<String, List> conditions = new HashMap<>();
        List<String> userserGroups = new ArrayList<>(StringUtils.splitAsList(userGroupIds, StringUtils.COMMA_SIGN));
        List<String> conditionList = new ArrayList<>();
        conditionList.add(ocap.getOcapType());
        conditions.put("userGroupId", userserGroups);
        conditions.put("commentType", conditionList);
        List<RADCommentDTO> radComments = ocapService.queryRADComment(conditions);
        if (CollectionUtils.isNotEmpty(radComments)) {
            newRadCommentExist = true;
            List<String> addValue = new ArrayList<>();
            ArrayList<Object> comboxData = new ArrayList<>();
            for (RADCommentDTO tmp : radComments) {
                HashMap<String, Object> jsonObject = new HashMap<>();
                if (!addValue.contains(tmp.getCategory())) {
                    jsonObject.put("key", tmp.getCategory());
                    jsonObject.put("value", tmp.getCategory());
                    comboxData.add(jsonObject);
                    addValue.add(tmp.getCategory());
                }
            }
            reponseData.put("radCommentsCategory", comboxData);
        }
        return newRadCommentExist;
    }

    protected abstract void setActionUrl(HttpServletRequest request);

    protected void initCache(RootForm theform, HttpServletRequest request) throws Exception {
        Map<String, Object> parametersMap = (Map) request.getAttribute(SessionNames.PARAMETERSINFO_KEY);
        request.setAttribute("cacheParametersInfo", WebUtils.getCacheObj2String(parametersMap));
    }

    protected OcapDoActionDTO buildBaseOcapDoActionDTO(DoActionDTO actionDTO) {
        OcapDoActionDTO ocapDoActionDTO = new OcapDoActionDTO();
        ocapDoActionDTO.setFacilityRrn(LocalContext.getFacilityRrn());
        ocapDoActionDTO.setUserRrn(LocalContext.getUserRrn());
        ocapDoActionDTO.setUserId(LocalContext.getUserId());
        ocapDoActionDTO.setSpecifiedAction(actionType.toString());
        ocapDoActionDTO.setActionId(actionDTO.getActionId());
        ocapDoActionDTO.setPathId(actionDTO.getPathId());
        ocapDoActionDTO.setNextStepId(actionDTO.getNextStepId());
        ocapDoActionDTO.setRemark(actionDTO.getComment());
        Assert.isTrue(StringUtils.isNotEmptyTrim(actionDTO.getComment()),
                      Errors.create().content("Comment Can't be empty").build());
        return ocapDoActionDTO;
    }

}