BatchFutureHoldAction.java

package com.mycim.webapp.actions.lot.batchfuturehold;

import com.fa.sesa.exception.Assert;
import com.fa.sesa.exception.Errors;
import com.fa.sesa.exception.SystemIllegalArgumentException;
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.ListUtils;
import com.mycim.framework.utils.lang.collections.MapUtils;
import com.mycim.valueobject.MessageIdList;
import com.mycim.valueobject.ObjectList;
import com.mycim.valueobject.alm.EenAction;
import com.mycim.valueobject.consts.ContextNames;
import com.mycim.valueobject.consts.EenActionType;
import com.mycim.valueobject.consts.TransactionNames;
import com.mycim.valueobject.prp.ContextValue;
import com.mycim.valueobject.prp.ProcessPlanning;
import com.mycim.valueobject.prp.ProcessVersion;
import com.mycim.webapp.actions.WipSetupAction;
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.*;
import java.util.stream.Collectors;

/**
 * @author liuji.li
 * @version 6.0.0
 * @date 2019/11/19
 **/
public class BatchFutureHoldAction extends WipSetupAction {
    @Override
    public ActionForward init(ActionMapping mapping, ActionForm form, HttpServletRequest request,
                              HttpServletResponse response) throws Exception {
        return mapping.getInputForward();
    }

    public Map<String, Object> queryLots(Map map) {
        long facilityRrn = LocalContext.getFacilityRrn();
        String productId = StringUtils.trimToUpperCase(MapUtils.getString(map, "productId"));
        Assert.isFalse(StringUtils.isBlank(productId),
                       Errors.create().key(MessageIdList.BATCHFUTUREHOLDLOT_SELECT_PRODUCTID)
                             .content("The Part Have Not Select Or KeyIn!").build());

        long productRrn = getInstanceRrn(productId, getNamedSpace(ObjectList.PRODUCT_KEY, facilityRrn),
                                         ObjectList.PRODUCT_KEY);
        Assert.isFalse(productRrn <= 0,
                       Errors.create().key(MessageIdList.PRODUCT_PRODUCT_MISSING).content("产品不存在!").build());
        /*List<Map> lotsList = lotQueryService.getLotPriorityList(productRrn);
        if (CollectionUtils.isEmpty(lotsList)) {
            throw new WebException("batchfutureholdlot.product_not_lot", "The product has no qualified lot!");
        }*/
        List<Map> processIdList = new ArrayList<>();
        List<String> processIds = prpService.getProcessIdsByProductRrn(productRrn);
        for (String processId : processIds) {
            Map processIdMap = new HashMap(processIds.size());
            processIdMap.put("processId", processId);
            processIdMap.put("processRrn", getInstanceRrn(processId, facilityRrn, ObjectList.WFL_KEY));
            processIdList.add(processIdMap);
        }
        Map<String, Object> result = new HashMap();
        //result.put("lots", lotsList); //此处不查询了 qryLots方法 查询批次信息
        result.put("processIds", processIdList);
        result.put("productId", productId);
        result.put("productRrn", productRrn);
        return result;
    }

    public List<Map> qryLots(Map map) {
        int processVersion = MapUtils.getIntValue(map, "processVersion");
        long processRrn = MapUtils.getLongValue(map, "processRrn");
        String productId = StringUtils.trimToUpperCase(MapUtils.getString(map, "productId"));
        long productRrn = 0L;
        if (StringUtils.isNotEmpty(productId)) {
            productRrn = getInstanceRrn(productId, getNamedSpace(ObjectList.PRODUCT_KEY, LocalContext.getFacilityRrn()),
                                        ObjectList.PRODUCT_KEY);
            Assert.isFalse(productRrn <= 0,
                           Errors.create().key(MessageIdList.PRODUCT_PRODUCT_MISSING).content("产品不存在!").build());
        }
        if (productRrn <= 0 || processRrn <= 0 || processVersion <= 0) {
            return ListUtils.newArrayList();
        }
        List<Map> lotsList = lotQueryService.getLotPriorityList(productRrn);
        Assert.isFalse(CollectionUtils.isEmpty(lotsList),
                       Errors.create().key(MessageIdList.BATCHFUTUREHOLDLOT_PRODUCT_NOT_LOT)
                             .content("The product has no qualified lot!").build());
        Assert.isFalse(baseService.isExisted(processRrn) == null,
                       Errors.create().key(MessageIdList.PROCESS_PROCESS_MISSING).content("流程不存在!").build());
        lotsList = lotsList.stream().filter(m -> processRrn == MapUtils.getLongValue(m, "processRrn") &&
                processVersion == MapUtils.getIntValue(m, "processVersion")).collect(Collectors.toList());
        return lotsList;
    }

    public List<Map<String, String>> getProcessVersionByProcess(Map map) throws Exception {
        List<Map<String, String>> result = new ArrayList<>();
        long processRrn = MapUtils.getLongValue(map, "processRrn");
        if (processRrn > 0) {
            ProcessPlanning processPlanning = new ProcessPlanning(processRrn);
            List<ProcessVersion> processVersions = prpService.getProcessVersions(processPlanning);
            Assert.isFalse(CollectionUtils.isEmpty(processVersions),
                           Errors.create().key(MessageIdList.PROCESS_NO_VERSION)
                                 .content("There is no version under the process!").build());
            processVersions.forEach(processVersion -> {
                String key = String.valueOf(processVersion.getInstanceVersion());
                String text = key + "(" + processVersion.getVersionStatus() + ")";
                Map<String, String> m = new LinkedHashMap<>(2);
                m.put("key", key);
                m.put("text", text);
                result.add(m);
            });
        }
        return result;
    }

    public void batchFutureHoldLot(Map map) {
        String user = LocalContext.getUserId();
        long facilityRrn = LocalContext.getFacilityRrn();
        List<Map> futureHoldLots = (List<Map>) MapUtils.getObject(map, "dataArray");
        Assert.isFalse(CollectionUtils.isEmpty(futureHoldLots),
                       Errors.create().key(MessageIdList.BATCHHOLDLOT_SELECT_LOT).content("Please select lot id!")
                             .build());

        String routeId = MapUtils.getString(map, "routeId");
        String operationId = MapUtils.getString(map, "operationId");
        String reasonCode = MapUtils.getString(map, "reasonCode");

        checkRCHoldCode(reasonCode);

        String holdReason =
                MapUtils.getString(map, "department") + " " + MapUtils.getString(map, "userName") + " Reason:" +
                        "Holdcode is " + reasonCode + ". " + MapUtils.getString(map, "reason");
        int holdReasonLen = holdReason.replaceAll("[^\\x00-\\xff]", "***").length();
        Assert.isFalse(holdReasonLen > 256, Errors.create().key(MessageIdList.LOT_HOLDREASONTOOLONG)
                                                  .content("holdReason length can not be over 256!").build());

        long processRrn = MapUtils.getLongValue(map, "processRrn");
        int processVer = MapUtils.getIntValue(map, "processVer");
        checkLotAndProcessInfo(processRrn, processVer, futureHoldLots);
        Map transInfo = new HashMap();
        for (Map futureHoldLot : futureHoldLots) {
            long lotRrn = MapUtils.getLongValue(futureHoldLot, "lotRrn");
            ContextValue actionCondition = new ContextValue();
            actionCondition.setContextId(ContextNames.EEN_CONTEXT_HOLDLOT);
            actionCondition.setContextRrn(
                    getInstanceRrn(ContextNames.EEN_CONTEXT_HOLDLOT, getNamedSpace(ObjectList.CONTEXT_KEY, facilityRrn),
                                   ObjectList.CONTEXT_KEY));

            Assert.isFalse(actionCondition.getContextRrn() <= 0, Errors.create().content("Context").build());
            long routeRrn = this.getInstanceRrn(routeId, this.getNamedSpace("WFL", facilityRrn), "WFL", "ROUTE");
            actionCondition.setContextKey1(StringUtils.toString(routeRrn));
            long operationRrn = this
                    .getInstanceRrn(operationId, this.getNamedSpace("OPERATION", facilityRrn), "OPERATION");
            actionCondition.setContextKey2(StringUtils.toString(operationRrn));
            actionCondition.setContextKey3(StringUtils.toString(lotRrn));
            long refRrn = this.getInstanceRrn(ContextNames.EEN_CONTEXT_HOLDLOT, facilityRrn, ObjectList.CONTEXT_KEY);
            int sequenceNumber = prpService.getMaxSeq(refRrn);
            actionCondition.setSequenceNumber(new Integer(sequenceNumber) + 1);
            actionCondition.setResultValue2(user);
            actionCondition.setResultValue3(" ");
            actionCondition.setResultValue4(reasonCode);
            actionCondition.setResultValue5(holdReason);
            EenAction eenAction = new EenAction();
            eenAction.setActionType(EenActionType.FUTURE_HOLD_LOT_KEY);
            transInfo.put("eenAction", eenAction);
            transInfo.put("user", user);
            transInfo.put("facilityRrn", facilityRrn);
            transInfo.put("contextValue", actionCondition);
            transInfo.put("byLotFlag","Y");
            StringBuilder transComments = new StringBuilder(TransactionNames.BY_LOT_CREATE_FUTURE_HOLD);
            transComments.append(", Flow seq:").append(MapUtils.getString(map,"flowSeq")).append(" Hold Code:").append(reasonCode)
                         .append(" Hold Comment:").append(MapUtils.getString(map,"reason"));
            transInfo.put("transComments", transComments);
            transInfo.put("lotRrn",lotRrn);
            wipService.insertEenAction(transInfo,lotRrn);
        }
    }

    /**
     * 判断选中的Lot是否与当前流程和流程版本匹配，若有不匹配，抛出提示
     **/
    private void checkLotAndProcessInfo(long processRrn, int processVer, List<Map> futureHoldLots) {
        StringBuilder notMatchLots = new StringBuilder();
        if (CollectionUtils.isNotEmpty(futureHoldLots)) {
            futureHoldLots.stream().filter(m -> !(processRrn == MapUtils.getLongValue(m, "processRrn") &&
                    processVer == MapUtils.getLongValue(m, "processVer")))
                          .forEach(m -> notMatchLots.append(MapUtils.getString(m, "lotId")).append(","));
        }
        if (notMatchLots.length() > 0) {
            notMatchLots.deleteCharAt(notMatchLots.lastIndexOf(","));
            throw new SystemIllegalArgumentException(
                    Errors.create().content("Lot Id: {} process Or processVer is incorrect!")
                          .args(notMatchLots.toString()).build());
        }
    }

}