BatchReleaseLotAction.java

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

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.valueobject.MessageIdList;
import com.mycim.valueobject.ObjectList;
import com.mycim.valueobject.prp.ProcessPlanning;
import com.mycim.valueobject.prp.ProcessVersion;
import com.mycim.valueobject.wip.Lot;
import com.mycim.valueobject.wip.LotStatus;
import com.mycim.valueobject.wip.TransReason;
import com.mycim.webapp.WebUtils;
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.*;

/**
 * @author liuji.li
 * @version 6.0.0
 * @date 2019/11/26
 **/
public class BatchReleaseLotAction 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();
        Map actionMap = new HashMap();
        String productId = MapUtils.getString(map, "productId");
        if (StringUtils.isNotEmptyTrim(productId)) {
            productId = productId.trim();
            long productRrn = this.getInstanceRrn(productId, facilityRrn, ObjectList.PRODUCT_KEY);
            Assert.isFalse(productRrn <= 0,
                           Errors.create().key(MessageIdList.PRODUCT_PRODUCT_MISSING).content("产品不存在!").build());
            actionMap.put("productRrn", new Long(productRrn));
        }
        String processId = MapUtils.getString(map, "processId");
        if (StringUtils.isNotEmptyTrim(processId)) {
            processId = processId.trim();
            long processRrn = this.getInstanceRrn(processId, this.getNamedSpace("WFL", facilityRrn), "WFL", "ROUTE");
            Assert.isFalse(processRrn <= 0,
                           Errors.create().key(MessageIdList.PROCESS_PROCESS_MISSING).content("流程不存在!").build());
            actionMap.put("processRrn", new Long(processRrn));
        }
        String routeId = MapUtils.getString(map, "routeId");
        if (StringUtils.isNotEmptyTrim(routeId)) {
            routeId = routeId.trim();
            long routeRrn = this.getInstanceRrn(routeId, this.getNamedSpace("WFL", facilityRrn), "WFL", "ROUTE");
            Assert.isFalse(routeRrn <= 0,
                           Errors.create().key(MessageIdList.ROUTE_ROUTE_MISSING).content("路径号不存在!").build());
            actionMap.put("routeRrn", new Long(routeRrn));
        }
        String operationId = MapUtils.getString(map, "operationId");
        if (StringUtils.isNotEmptyTrim(operationId)) {
            operationId = operationId.trim();
            long operationRrn = this
                    .getInstanceRrn(operationId, this.getNamedSpace("OPERATION", facilityRrn), "OPERATION");
            Assert.isFalse(operationRrn <= 0,
                           Errors.create().key(MessageIdList.INSTRUCTIONEDIT_OPERATION_MISSING).content("步骤号不存在!")
                                 .build());
            actionMap.put("operationRrn", new Long(operationRrn));
        }

        Assert.isFalse(actionMap.isEmpty(),
                       Errors.create().key(MessageIdList.BATCHHOLDLOT_MUST_ITEM).content("Must select one Item!")
                             .build());

        List<Map> lotsList = lotQueryService.getHoldLotsList(actionMap);
        for (Map holdLotsMap : lotsList) {
            Map holdInfo = new HashMap();
            holdInfo.put("lotRrn", MapUtils.getLong(holdLotsMap, "lotRrn"));
            holdInfo.put("lotId", MapUtils.getString(holdLotsMap, "lotId"));
            holdLotsMap.put("holdLotsInfo", WebUtils.getCacheObj2String(holdLotsMap));
        }
        // request.setAttribute(SessionNames.LOTS_LIST_KEY, lotsList);
        // theform.setProductId(productId);
        // theform.setProcessId(processId);
        // theform.setRouteId(routeId);
        // theform.setOperationId(operationId);
        // theform.setReasonGroup("");
        // theform.setReason("");
        // return mapping.findForward("viewHoldLots");
        Map<String, Object> result = new HashMap();
        result.put("lots", lotsList);
        return result;
    }

    public void batchRelease(Map map) {
        String userId = LocalContext.getUserId();
        String userName = MapUtils.getString(map, "userId");
        String reasonCode = MapUtils.getString(map, "reasonCode");
        String reasonGroup = MapUtils.getString(map, "reasonGroup");
        List<Map> holdLots = (List<Map>) map.get("dataArray");
        Assert.isFalse(CollectionUtils.isEmpty(holdLots),
                       Errors.create().key(MessageIdList.BATCHHOLDLOT_SELECT_LOT).content("Please select lot id!")
                             .build());
        String batchId = "";
        Set set = new TreeSet();
        List<Map> holdLotsList = new ArrayList<>();
        for (Map holdLotMap : holdLots) {
            // Map holdLotMap = (Map) WebUtils.getCacheString2Obj(holdLot);
            String lotId = MapUtils.getString(holdLotMap, "lotId");
            Assert.isTrue(StringUtils.equals(MapUtils.getString(holdLotMap, "lotStatus"), LotStatus.HOLD),
                          Errors.create().key(MessageIdList.LOT_STATUS_NOT_ALLOW).content("Lot status not allow!")
                                .build());
            batchId = lotQueryService.getBatchId(lotId);
            if (StringUtils.isNotEmpty(batchId)) {
                set.add(batchId);
                holdLotsList.add(holdLotMap);
            }
        }
        Assert.isFalse(set.size() != 1, Errors.create().key(MessageIdList.BATCHRELEASE_BATCH_LOTIDS).content(
                "Can not release these lots, because they were not hold " + "together!").build());
        for (Map holdLotInfo : holdLotsList) {
            long lotRrn = MapUtils.getLongValue(holdLotInfo, "lotRrn");
            Lot lot = lotQueryService.getLot(lotRrn);
            List<Map> holdReasons = wipQueryService.getHoldReasons(lotRrn);
            String reason = reasonGroup + " " + reasonCode + " " + userName + " " + MapUtils.getString(map, "reason");
            TransReason transReason = new TransReason();
            transReason.setReasonCategory("BATCHRELEASE");
            transReason.setReasonCode(reasonCode);
            transReason.setReason(reason);
            transReason.setTransQty1(lot.getQty1());
            transReason.setTransQty2(lot.getQty2());
            transReason.setResponsibility(userId);

            Map releaseInfo = new HashMap();
            releaseInfo.put("lotRrn", new Long(lot.getLotRrn()).toString());
            releaseInfo.put("lotId", lot.getLotId());
            releaseInfo.put("releaseReasons", holdReasons);
            releaseInfo.put("transPerformedBy", userId);
            releaseInfo.put("transComments", "");
            releaseInfo.put("operation", lot.getOperationId());
            releaseInfo.put("transReason", transReason);
            releaseInfo.put("superFlag", "0");
            releaseInfo.put("batchId", batchId);
            // List<Lot> lockLots = new ArrayList<>();
            // lockLots.add(lot);
            // checkAndCreateLotsTransLock(LocalContext.getUserRrn(), TransactionNames.LOCK_RELEASE_LOT, lockLots,
            //                             "Batch release lot in BatchReleaseLoAction by: " + LocalContext.getUserId());
            lotService.batchReleaseLot(releaseInfo);
        }
    }
    public List<Map<String, String>> getProcessVersionByProcess(Map map) throws Exception {
        List<Map<String, String>> result = new ArrayList<>();
        String processId = MapUtils.getString(map, "processId");
        long processRrn = getInstanceRrn(processId, LocalContext.getFacilityRrn(), ObjectList.WFL_KEY);
        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 Map<String, Object> queryProcess(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> 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("processIds", processIdList);
        result.put("productId", productId);
        result.put("productRrn", productRrn);
        return result;
    }
}