# RunCardQueryManagerImpl.java

    package com.mycim.server.wip.manager.impl;

    import com.fa.sesa.threadlocal.LocalContext;
    import com.mycim.framework.jdbc.Page;
    import com.mycim.framework.utils.beans.BeanUtils;
    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.lang.math.NumberUtils;
    import com.mycim.framework.utils.lang.time.DateUtils;
    import com.mycim.server.base.manager.NamedObjectManager;
    import com.mycim.server.ctx.exec.manager.ProcessOperationDescContextValueManager;
    import com.mycim.server.ctx.exec.manager.ResequenceContextValueManager;
    import com.mycim.server.prp.manager.OperationManager;
    import com.mycim.server.spec.manager.AttributeConvertManager;
    import com.mycim.server.system.manager.ReferenceFileManager;
    import com.mycim.server.wip.dao.RunCardQueryDao;
    import com.mycim.server.wip.manager.LotQueryManager;
    import com.mycim.server.wip.manager.RunCardQueryManager;
    import com.mycim.server.wip.manager.UnitQueryManager;
    import com.mycim.utils.WipUtils;
    import com.mycim.valueobject.ObjectList;
    import com.mycim.valueobject.consts.ReferenceFileConst;
    import com.mycim.valueobject.consts.SystemConstants;
    import com.mycim.valueobject.prp.Operation;
    import com.mycim.valueobject.runcard.dto.RunCardPortalQueryDTO;
    import com.mycim.valueobject.runcard.util.RunCardConstants;
    import com.mycim.valueobject.runcard.util.RunCardStoreSubStatus;
    import com.mycim.valueobject.wip.*;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    import org.springframework.transaction.annotation.Transactional;

    import java.util.*;

    /**
     * RunCardQueryManager实现
     *
     * @author pinyan.song
     * @version 6.0.0
     * @date 2019-10-9
     **/
    @Service
    @Transactional
    public class RunCardQueryManagerImpl implements RunCardQueryManager {
        @Autowired
        RunCardQueryDao runCardQueryDao;

        @Autowired
        UnitQueryManager unitQueryManager;

        @Autowired
        LotQueryManager lotQueryManager;

        @Autowired
        NamedObjectManager namedObjectManager;

        @Autowired
        OperationManager operationManager;

        @Autowired
        ProcessOperationDescContextValueManager operationDescContextValueManager;

        @Autowired
        ReferenceFileManager referenceFileManager;

        @Autowired
        ResequenceContextValueManager resequenceContextValueManager;

        @Autowired
        AttributeConvertManager attributeConvertManager;

        @Override
        public LotRunCard getLotRunCardByMainLot(Long lotRrn) {
            List<String> status = new ArrayList<String>();
            status.add("PROCESSING");
            List<LotRunCard> runcardList = runCardQueryDao.getLotRunCardByLot(lotRrn, status);
            return runcardList.size() == 1 ? runcardList.get(0) : null;
        }

        @Override
        public List<LotRunCard> getLotRunCardByLot(long lotRrn, List<String> status) {
            return runCardQueryDao.getLotRunCardByLot(lotRrn, status);
        }

        @Override
        public LotRecoveryRunCard getLotRecoveryRunCard(Long runCardRrn) {
            return runCardQueryDao.getLotRecoveryRunCard(runCardRrn);
        }

        @Override
        public LotRunCard getLotRunCard(Long runCardRrn) {
            return runCardQueryDao.getLotRunCard(runCardRrn);
        }

        @Override
        public LotRunCardStore getSplitRunCardLotStore(long lotRrn) {
            return runCardQueryDao.getSplitRunCardLotStore(lotRrn, 0L, null);
        }

        @Override
        public List<LotRunCardSplit> getLotRunCardSplit(Long runCardRrn) {
            List<LotRunCardSplit> splitList = runCardQueryDao.getLotRunCardSplitSet(runCardRrn);
            return splitList;
        }

        @Override
        public List<LotRunCardStep> getLotRunCardStepList(Long runCardRrn, Integer splitSeq) {
            List<LotRunCardSplit> splitSetList = runCardQueryDao.getLotRunCardSplitSet(runCardRrn);

            String stepSerials = "";
            for (LotRunCardSplit splitSet : splitSetList) {
                if (splitSet.getSplitSeq().intValue() == splitSeq.intValue()) {
                    stepSerials = splitSet.getStepSerials();
                }
            }

            List<String> stepSerialList = Arrays.asList(StringUtils.split(stepSerials, ","));

            List<LotRunCardStep> lotRunCardStepList = new ArrayList<>();

            List<LotRunCardStep> allStepList = runCardQueryDao.getLotRunCardStepList(runCardRrn);
            for (LotRunCardStep lotRunCardStep : allStepList) {
                if (stepSerialList.contains(lotRunCardStep.getStepSerialNo().toString())) {
                    lotRunCardStepList.add(lotRunCardStep);
                }
            }
            return lotRunCardStepList;
        }

        @Override
        public List<LotRunCardStep> getLotRunCardStepList(Long runCardRrn) {
            List<LotRunCardStep> data = runCardQueryDao.getLotRunCardStepList(runCardRrn);
            return CollectionUtils.isEmpty(data) ? Collections.emptyList() : data;
        }

        @Override
        public LotRunCardStep getLotRunCardStep(Long lotRrn) {
            SRCLotSpecialStep specialStep = getLotSplitRunCardSpecialStep(lotRrn);
            if (Objects.nonNull(specialStep)) {
                return getLotRunCardStep(specialStep.getRuncardRrn(), NumberUtils.toInt(specialStep.getStepNo()));

            }
            return null;
        }

        @Override
        public LotRunCardStep getLotRunCardStep(Long runCardRrn, int stepSerialNo) {
            return runCardQueryDao.getLotRunCardStep(runCardRrn, stepSerialNo);
        }

        @Override
        public List<LotRunCardStepParameter> getLotRunCardStepParameterList(Long runCardRrn) {
            List<LotRunCardStepParameter> data = runCardQueryDao.getLotRunCardStepParameterList(runCardRrn);
            return CollectionUtils.isEmpty(data) ? Collections.emptyList() : data;
        }

        @Override
        public List<LotRunCardStepParameter> getLotRunCardStepParameterList(Long runCardRrn, Integer stepSerialNo,
                                                                            Long parameterSetRrn) {
            List<LotRunCardStepParameter> data = runCardQueryDao
                    .getLotRunCardStepParameterList(runCardRrn, stepSerialNo, parameterSetRrn);
            return CollectionUtils.isEmpty(data) ? Collections.emptyList() : data;
        }

        @Override
        public LotRunCardStore getSplitRunCardLotStore(long lotRrn, long runcardRrn) {
            return runCardQueryDao.getSplitRunCardLotStore(lotRrn, runcardRrn, null);
        }

        @Override
        public LotRunCardStore getSplitRunCardLotStore(String showLotId, Long runcardRrn) {
            return runCardQueryDao.getSplitRunCardLotStore(0L, runcardRrn, showLotId);
        }

        @Override
        public LotRunCard getOuterInfo(long lotRrn) {
            LotRunCardStore lotStore = getSplitRunCardLotStore(lotRrn);
            String mainLotId = lotStore.getMainLotId();
            Lot lot = lotQueryManager.getLot(mainLotId, LocalContext.getFacilityRrn());

            List<String> status = new ArrayList<String>();
            status.add("PROCESSING");
            List<LotRunCard> runcardList = runCardQueryDao.getLotRunCardByLot(lot.getLotRrn(), status);
            LotRunCard lotRuncard = null;
            for (LotRunCard runcard : runcardList) {
                //chanclemovein 的rrc没有SplitOperationRrn，这里又要要兼容升版问题
                if (StringUtils.equalsIgnoreCase(runcard.getSplitStepPath(), lotStore.getWflStep()) ||
                        (runcard.getSplitOperationRrn() == lotStore.getOperationRrn().longValue())) {
                    lotRuncard = runcard;
                    break;
                }
            }
            return lotRuncard;
        }

        @Override
        public List<Map<String, Object>> getRunCardLotsByRuncardRrn(Long runcardRrn) {
            return runCardQueryDao.getRunCardLotsByRuncardRrn(runcardRrn);
        }

        @Override
        public SRCLotSpecialStep getLotSplitRunCardSpecialStep(Long lotSpecialStepRrn, Integer stepSequence) {
            return runCardQueryDao.getLotSplitRunCardSpecialStep(lotSpecialStepRrn, stepSequence);
        }

        @Override
        public SRCLotSpecialStep getLotSplitRunCardSpecialStep(Long lotRrn) {
            LotRunCardStore store = getSplitRunCardLotStore(lotRrn);
            if (Objects.nonNull(store)) {
                Long lotSpecialStepRrn = store.getLotSpecialStepRrn();
                Integer stepSeq = store.getStepSequence();
                return getLotSplitRunCardSpecialStep(lotSpecialStepRrn, stepSeq);
            }
            return null;
        }

        @Override
        public List<Map<String, Object>> getSplitedRunCardLots(long runcardRrn) {
            return runCardQueryDao.getSplitedRunCardLots(runcardRrn);
        }

        @Override
        public Map<String, Object> getLotRunCardReviewQueueHistory(Long transRrn, Integer transSequence) {
            return runCardQueryDao.getLotRunCardReviewQueueHistory(transRrn, transSequence);
        }

        @Override
        public LotRunCardReviewQueue getLotRunCardReviewQueue(Long runCardRrn, Integer queueSequence) {
            return runCardQueryDao.getLotRunCardReviewQueue(runCardRrn, queueSequence);
        }

        @Override
        public LotRunCardReviewQueue getLotRunCardReviewQueueFirst(Long runCardRrn) {
            return runCardQueryDao.getLotRunCardReviewQueueFirst(runCardRrn);
        }

        @Override
        public LotRunCardReviewQueue getLotRunCardReviewQueueLast(Long runCardRrn) {
            return runCardQueryDao.getLotRunCardReviewQueueLast(runCardRrn);
        }

        @Override
        public List<LotRunCardReviewQueue> getLotRunCardReviewQueueByReviewRole(Long runCardRrn, String reviewRole) {
            return runCardQueryDao.getLotRunCardReviewQueueByReviewRole(runCardRrn, reviewRole);
        }

        @Override
        public boolean isRunCardId(String runCardId, String idType) {
            return StringUtils.isNotEmpty(runCardId) && StringUtils.indexOf(runCardId, idType) == 0 &&
                    runCardId.length() == 15;
        }

        @Override
        public Integer getLotRunCardReviewQueueFirstSeq(Long runCardRrn) {
            LotRunCardReviewQueue lotRunCardReviewQueue = getLotRunCardReviewQueueFirst(runCardRrn);
            if (lotRunCardReviewQueue == null) {
                return 0;
            }
            return lotRunCardReviewQueue.getQueueSequence();
        }

        @Override
        public String getLotRunCardReviewQueueFirstRole(Long runCardRrn) {
            LotRunCardReviewQueue lotRunCardReviewQueue = getLotRunCardReviewQueueFirst(runCardRrn);
            if (lotRunCardReviewQueue == null) {
                return "MFG";
            }
            return lotRunCardReviewQueue.getReviewRole();
        }

        @Override
        public List<LotRunCard> getEffectiveLotRuncardByLot(long lotRrn) {
            List<String> status = new ArrayList<String>();
            status.add("ACTIVE");
            status.add("DRAFT");
            status.add("SUBMIT");
            return runCardQueryDao.getLotRunCardByLot(lotRrn, status);
        }

        @Override
        public LotRunCard getLotSplitRunCardSetByLot(String lotId) {
            LotRunCard lotRunCard = null;

            if (StringUtils.contains(lotId, RunCardConstants.MAINLOT_ID_IN_MES)) {
                String baseLotId = StringUtils.substringBefore(lotId, RunCardConstants.MAINLOT_ID_IN_MES);
                Lot baseLot = lotQueryManager.getLot(baseLotId, LocalContext.getFacilityRrn());

                Lot lot = lotQueryManager.getLot(lotId, LocalContext.getFacilityRrn());

                List<String> status = new ArrayList<String>();
                status.add("ACTIVE");
                status.add("PROCESSING");
                List<LotRunCard> runcardList = runCardQueryDao.getLotRunCardByLot(baseLot.getLotRrn(), status);

                LotRunCardStore runcardStore = runCardQueryDao.getSplitRunCardLotStore(lot.getLotRrn(), 0, null);

                if (CollectionUtils.isNotEmpty(runcardList) && runcardStore != null) {
                    for (LotRunCard runCard : runcardList) {
                        if (runcardStore.getRuncardRrn().longValue() == runCard.getRunCardRrn().longValue()) {
                            lotRunCard = runCard;
                        }
                    }
                }
            }

            return lotRunCard;
        }

        @Override
        public List<Map<String, Object>> qrySplitRunCardLotInfo(Map<String, Object> lotPortalFormMap, long facilityRrn,
                                                                String startRowStr, String pageSize) {
            buildLotPortalConditionMap(lotPortalFormMap);

            int startRow = 0;
            int currentTotalRow = 10;
            if (StringUtils.isNotBlank(startRowStr) && StringUtils.isNotBlank(pageSize)) {
                try {
                    startRow = Integer.parseInt(startRowStr);
                    currentTotalRow = startRow + Integer.parseInt(pageSize);
                } catch (Exception e) {
                    startRow = 0;
                    currentTotalRow = 10;
                }
            }

            String refNamedSpace = namedObjectManager.getNamedSpace(LocalContext.getFacilityRrn(),
                                                                    ObjectList.REFERENCE_FILE_KEY);

            lotPortalFormMap.put("referenceNamedSpace", refNamedSpace);
            lotPortalFormMap.put("facilityRrn", LocalContext.getFacilityRrn());

            Map<String, Object> countMap = runCardQueryDao.queryRunCardLotCount(lotPortalFormMap);
            List<Map<String, Object>> results = runCardQueryDao.querySplitRunCardLotInfoByPage(lotPortalFormMap, startRow,
                                                                                               currentTotalRow, countMap);
            return results;
        }

        @Override
        public Map<String, Object> getRCLotInfoMap(String lotId) {
            long facilityRrn = LocalContext.getFacilityRrn();
            Map<String, Object> lotInfoMap = new HashMap<>();

            Lot mainLot = lotQueryManager.getLot(lotId, facilityRrn);
            BeanUtils.copyBeanToMap(lotInfoMap, mainLot);

            LotRunCardStore lotStore = getSplitRunCardLotStore(mainLot.getLotRrn());

            if (lotStore == null) {
                return lotInfoMap;
            }

            Lot lot = lotQueryManager.getLot(lotStore.getMainLotId(), facilityRrn);
            // BeanUtils.copyBeanToMap(lotInfoMap, lot);
            SystemConstants.copyBeanToMapIgnoreKeys(lotInfoMap, lot, "flipType", "carrierId");
            if (mainLot.getLotRrn() == mainLot.getBasedLotRrn()) {
                BeanUtils.copyBeanToMap(lotInfoMap, lotStore);
            } else {
                SystemConstants.copyBeanToMapIgnoreKeys(lotInfoMap, lotStore, "carrierId");
            }
            lotInfoMap.put("lotStatus", mainLot.getLotStatus());
            lotInfoMap.put("duedate", DateUtils.formatDate(lot.getDueDate(), DateUtils.DATE_FORMAT4DAYD));
            lotInfoMap.put("qty1", lot.getQty1().intValue());

            String hotFlagString = "";
            if (StringUtils.isNotBlank(lot.getHotFlag()) && StringUtils.isNotBlank(lot.getPriority().toString())) {
                hotFlagString = lotQueryManager.getHotflagSplicingPriority(Integer.parseInt(lot.getHotFlag()),
                                                                           lot.getPriority(), facilityRrn);
            }
            lotInfoMap.put("hotFlagString", hotFlagString);

            LotExt lotExt = new LotExt();
            lotExt.setLotRrn(lot.getLotRrn());
            String customerId = lotQueryManager.getLotExt(lotExt).getCustomerId();
            lotInfoMap.put("customerId", customerId);
            lotInfoMap.put("lotPurpose", lot.getLotComments());

            String nextStepVersion1 = MapUtils.getString(lotInfoMap, "nextStepVersion1");
            if (StringUtils.isBlank(nextStepVersion1)) {
                nextStepVersion1 = null;
            }

            Long productRrn = MapUtils.getLong(lotInfoMap, "productRrn");
            Long processRrn = MapUtils.getLong(lotInfoMap, "processRrn");
            Integer processVersion = MapUtils.getInteger(lotInfoMap, "processVersion");
            Long routeRrn = WipUtils.getRouteRrnByProcessStep(nextStepVersion1);
            Long operationRrn = MapUtils.getLong(lotInfoMap, "nextOperationRrn1");

            SRCLotSpecialStep srcLotSpecialStep = getLotSplitRunCardSpecialStep(lotStore.getLotSpecialStepRrn(),
                                                                                lotStore.getStepSequence() + 1);
            List<LotRunCardStep> lotRunCardStepList = getLotRunCardStepList(lotStore.getRuncardRrn());

            for (LotRunCardStep runcardStep : lotRunCardStepList) {
                String stepPath = runcardStep.getStepPath();
                if (StringUtils.isNotBlank(stepPath)) {
                    processRrn = new Long(stepPath.substring(0, stepPath.indexOf(".")));
                    stepPath = stepPath.substring(stepPath.indexOf("|"));
                    routeRrn = new Long(stepPath.substring(1, stepPath.indexOf(".")));
                }
                if (srcLotSpecialStep != null) {
                    if (NumberUtils.toInt(srcLotSpecialStep.getStepNo()) == runcardStep.getStepSerialNo()) {
                        operationRrn = runcardStep.getOperationRrn();
                        lotInfoMap.put("nextOperationId1", namedObjectManager.getInstanceId(operationRrn));
                        break;
                    }
                } else {
                    //如果没有下一步，则下一步骤默认是显示空
                    lotInfoMap.put("nextOperationId1", "");
                }
            }

            String nextOperationDesc1 = operationDescContextValueManager.getOperationDesc(productRrn, processRrn,
                                                                                          processVersion, routeRrn,
                                                                                          operationRrn);
            if (StringUtils.isBlank(nextOperationDesc1)) {
                lotInfoMap.put("nextOperationDesc1", "");
            } else {
                lotInfoMap.put("nextOperationDesc1", nextOperationDesc1);
            }

            lotInfoMap.put("splitMergeFlag", StringUtils.nullToStr(lot.getSplitMergeFlag()));
            lotInfoMap.put("pollutionLevel", mainLot.getPollutionLevel());
            String pollutionLevel = mainLot.getPollutionLevel();
            String pollutionLevelColor = referenceFileManager.getReferenceDetailExchange("$$LOT_POLUTIONLEVEL",
                                                                                         pollutionLevel, "data_2_value");
            if (StringUtils.isNotBlank(pollutionLevelColor)) {
                String plBgColor = StringUtils.substringBefore(pollutionLevelColor, "$");
                String plColor = StringUtils.substringAfter(pollutionLevelColor, "$");
                lotInfoMap.put("plBgColor", plBgColor);
                lotInfoMap.put("plColor", plColor);
            }

            lotInfoMap.put("qty1", mainLot.getQty1().intValue());

            productRrn = MapUtils.getLong(lotInfoMap, "productRrn");
            processRrn = MapUtils.getLong(lotInfoMap, "processRrn");
            routeRrn = MapUtils.getLong(lotInfoMap, "routeRrn");
            operationRrn = MapUtils.getLong(lotInfoMap, "operationRrn");
            processVersion = MapUtils.getInteger(lotInfoMap, "processVersion");

            lotInfoMap.put("flowSeq",
                           resequenceContextValueManager.getFlowSeq(processRrn, processVersion, operationRrn, routeRrn));
            lotInfoMap.put("operationDesc",
                           operationDescContextValueManager.getOperationDesc(productRrn, processRrn, processVersion,
                                                                             routeRrn, operationRrn));
            lotInfoMap.put("lotComments", lotQueryManager.getLotComments(lot));

            // get lot q-time
            /*int                 qTBufferTime = this.getQTBufferTime();
            Map<String, Object> qTimeMap     = this.getQtimeRemainTime(lot.getLotRrn());
            if (StringUtils.equalsIgnoreCase("Y", MapUtils.getString(qTimeMap, "isRemainTime"))) {
                lotInfoMap.put("qTime", MapUtils.getString(qTimeMap, "remainTime"));
                lotInfoMap.put("qTBufferTime", qTBufferTime);
            }*/

            // get lot category
            String lotCategoryStr = referenceFileManager.getRefFileValue("$LOT_CREATE_CATEGORY", lot.getCreateCategory(),
                                                                         ReferenceFileConst.DATA_1_VALUE);
            lotInfoMap.put("lotCategoryStr", lotCategoryStr);

            String consumedMaterial = lotQueryManager.getConsumedMaterial(lot.getLotRrn());
            lotInfoMap.put("consumedMaterial", StringUtils.trimToEmpty(consumedMaterial));

            if (StringUtils.equalsIgnoreCase(RunCardStoreSubStatus.SPLIT.toString(), lotStore.getSubStatus())) {
                Long lotSpecialStepRrn = lotStore.getLotSpecialStepRrn();
                Integer stepSeq = lotStore.getStepSequence();
                SRCLotSpecialStep lotSpecialStep = getLotSplitRunCardSpecialStep(lotSpecialStepRrn, stepSeq);
                if (lotSpecialStep != null) {
                    // BeanUtils.copyBeanToMap(lotInfoMap, lotSpecialStep);
                    // 避免被MainLot的FlipType覆盖
                    SystemConstants.copyBeanToMapIgnoreKeys(lotInfoMap, lotSpecialStep, "flipType");

                    if (mainLot.getEqptRrn() != null && mainLot.getEqptRrn() > 0) {
                        lotInfoMap.put("recipeId", mainLot.getRecipePhysicalId());
                    }

                    String stepNo = lotSpecialStep.getStepNo();
                    long runcardRrn = lotSpecialStep.getRuncardRrn();
                    List<LotRunCardStep> stepList = getLotRunCardStepList(runcardRrn);
                    for (LotRunCardStep runcardStep : stepList) {
                        if (NumberUtils.toInt(stepNo) == runcardStep.getStepSerialNo()) {
                            lotInfoMap.put("flowSeq", runcardStep.getFlowSeq());
                            lotInfoMap.put("operationId", namedObjectManager.getInstanceId(runcardStep.getOperationRrn()));
                            lotInfoMap.put("operationDesc", runcardStep.getComments());
                        }
                    }
                }
            } else if (StringUtils.equalsIgnoreCase(RunCardStoreSubStatus.BANKIN.toString(), lotStore.getSubStatus()) &&
                    StringUtils.equals(LotStatus.WAITING, MapUtils.getString(lotInfoMap, "lotStatus"))) {
                lotInfoMap.put("recipeId", "");
                lotInfoMap.put("lotStatus", RunCardConstants.SHOW_RUNCARD_MAIN_LOT_STATUS_WAITING_SPLIT);
            } else if (StringUtils.equalsIgnoreCase(RunCardStoreSubStatus.AUTO.toString(), lotStore.getSubStatus())) {
                if (StringUtils.equals(LotStatus.WAITING, MapUtils.getString(lotInfoMap, "lotStatus"))) {
                    lotInfoMap.put("recipeId", "");
                    lotInfoMap.put("lotStatus", RunCardConstants.SHOW_RUNCARD_MAIN_LOT_STATUS_WAITING_REPOS);
                } else if (StringUtils.equals(LotStatus.RUNNING, MapUtils.getString(lotInfoMap, "lotStatus"))) {
                    LotRecoveryRunCard recoveryRunCard = getLotRecoveryRunCard(MapUtils.getLong(lotInfoMap, "runcardRrn"));
                    if (recoveryRunCard != null && !StringUtils.equalsIgnoreCase(RunCardStoreSubStatus.BANKOUT.toString(),
                                                                                 lotStore.getSubStatus())) {
                        String runcardAction = recoveryRunCard.getRunCardAction();
                        if (StringUtils.equalsIgnoreCase("CANCELTRACKIN", runcardAction)) {
                            lotInfoMap.put("lotStatus", RunCardConstants.SHOW_RUNCARD_MAIN_LOT_STATUS_WAITING_CANCEL);
                        } else if (StringUtils.equalsIgnoreCase("TRACKOUT", runcardAction)) {
                            lotInfoMap.put("lotStatus", RunCardConstants.SHOW_RUNCARD_MAIN_LOT_STATUS_WAITING_DISPATCH);
                        }
                    }
                }
            } else if (StringUtils.equals(LotStatus.RUNCARD_FINISH, MapUtils.getString(lotInfoMap, "lotStatus"))) {
                lotInfoMap.put("recipeId", "");
            }

            String workArea = "";
            if (StringUtils.isNotBlank(MapUtils.getString(lotInfoMap, "workArea"))) {
                workArea = getReferValus("$$WORK_AREA", MapUtils.getString(lotInfoMap, "workArea"));
            } else {
                Operation operation = operationManager.getOperation(MapUtils.getLongValue(lotInfoMap, "operationRrn"));
                if (operation != null && StringUtils.isNotEmpty(operation.getWorkArea())) {
                    workArea = this.getReferValus("$$WORK_AREA", operation.getWorkArea());
                }
            }
            lotInfoMap.put("workArea", workArea);

            if (StringUtils.contains(lot.getLotId(), ".S")) {
                lotInfoMap.put("mainLotId", lot.getLotId());
            }

            lotInfoMap.put("qTime", mainLot.getqTime());
            lotInfoMap.put("qTimeBgc", mainLot.getqTimeBgc());
            return lotInfoMap;
        }

        @Override
        public RunCardLotInfo getRunCardLotInfo(String lotId) {
            Long facilityRrn = LocalContext.getFacilityRrn();

            RunCardLotInfo runCardLotInfo = new RunCardLotInfo();

            Lot mainLot = lotQueryManager.getLot(lotId, facilityRrn);
            if (Objects.isNull(mainLot)) {
                return null;
            }
            BeanUtils.copyProperties(mainLot, runCardLotInfo);

            LotRunCardStore lotStore = getSplitRunCardLotStore(mainLot.getLotRrn());
            if (Objects.isNull(lotStore)) {
                return runCardLotInfo;
            }

            Lot lot = lotQueryManager.getLot(lotStore.getMainLotId(), facilityRrn);
            BeanUtils.copyProperties(lot, runCardLotInfo);
            BeanUtils.copyProperties(lotStore, runCardLotInfo);

            runCardLotInfo.setLotStatus(mainLot.getLotStatus());
            runCardLotInfo.setQty1(lot.getInt_qty1());

            String hotFlagString = "";
            if (StringUtils.isNotBlank(lot.getHotFlag()) && StringUtils.isNotBlank(lot.getPriority().toString())) {
                hotFlagString = lotQueryManager.getHotflagSplicingPriority(NumberUtils.toInt(lot.getHotFlag()),
                                                                           lot.getPriority(), facilityRrn);
            }
            runCardLotInfo.setHotFlagString(hotFlagString);

            Long lotSpecialStepRrn = lotStore.getLotSpecialStepRrn();
            Integer stepSequence = lotStore.getStepSequence();
            SRCLotSpecialStep lotSpecialStep = getLotSplitRunCardSpecialStep(lotSpecialStepRrn, stepSequence);
            if (lotSpecialStep != null) {
                BeanUtils.copyProperties(lotSpecialStep, runCardLotInfo);
            }

            return runCardLotInfo;
        }

        @Override
        public Map<String, Object> getRCLotStepInfo(String lotId, Long runCardRrn) {
            return runCardQueryDao.getRCLotStepInfo(lotId, runCardRrn);
        }

        @Override
        public int getRCChildLotCount(String lotId, String runCardIdPrefix) {
            return runCardQueryDao.getRCChildLotCount(lotId, LocalContext.getFacilityRrn(), runCardIdPrefix);
        }

        @Override
        public Page qryRuncardLotTransHistory(Page page, Long lotRrn) {
            return runCardQueryDao.qryRuncardLotTransHistory(page, lotRrn);
        }

        @Override
        public List<Map<String, Object>> qryRuncardLotTransHistory(Map<String, Object> condition, int thisPage,
                                                                   int pageSize) {
            return paddingDataRuncardLotTransHis(runCardQueryDao.qryRuncardLotTransHistory(condition, thisPage, pageSize));
        }

        @Override
        public String getRCRunCardIdByLotId(String lotId) {
            return runCardQueryDao.getRCRunCardIdByLotId(lotId);
        }

        @Override
        public List getSumbitAndActiveRunCardCreateTime(Long lotRrn) {
            return runCardQueryDao.getSumbitAndActiveRunCardCreateTime(LocalContext.getFacilityRrn(), lotRrn);
        }

        @Override
        public List<Map<String, Object>> queryFecthStepBySrc(long lotRrn) {
            Map<String, String> flipTypeMap = attributeConvertManager.getFlipTypeKeyMap();
            List<Map<String, Object>> results = runCardQueryDao.queryFecthStepBySrc(lotRrn);
            results.forEach(r -> {
                String flipType = MapUtils.getString(r, "flipType");
                r.put("flipTypeDesc", MapUtils.getString(flipTypeMap, flipType));
            });
            return results;
        }

        @Override
        public Map<String, Long> getRCLotRouteRrnAndOperationRrn(String lotId) {
            return runCardQueryDao.getRCLotRouteRrnAndOperationRrn(lotId);
        }

        @Override
        public List<Map<String, Object>> getRcLotInfoOfRcQtime(long lotRrn) {
            return runCardQueryDao.getRcLotInfoOfRcQtime(lotRrn);
        }

        @Override
        public Long getLotRrnByRunCardRrn(long runCardRrn) {
            return runCardQueryDao.getLotRrnByRunCardRrn(runCardRrn);
        }

        private List<Map<String, Object>> paddingDataRuncardLotTransHis(List<Map<String, Object>> results) {
            for (Map m : results) {
                Long tempRrn = MapUtils.getLongValue(m, "productRrn");
                m.put("product_id", namedObjectManager.getInstanceId(tempRrn));

                tempRrn = MapUtils.getLongValue(m, "eqpt_rrn");
                m.put("equipment_id", namedObjectManager.getInstanceId(tempRrn));

                tempRrn = MapUtils.getLongValue(m, "operationRrn");
                m.put("operationDesc", namedObjectManager.getNamedObjectDesc(tempRrn));
            }
            return results;
        }

        private String getReferValus(String ref, String key_value) {
            return referenceFileManager.getReferenceDetailExchange(ref, key_value, "DATA_1_VALUE");
        }

        private Map<String, Object> buildLotPortalConditionMap(Map lotPortalFormMap) {
            if (StringUtils.isNotBlank(MapUtils.getString(lotPortalFormMap, "lotId"))) {
                lotPortalFormMap.put("lotId",
                                     StringUtils.replace(MapUtils.getString(lotPortalFormMap, "lotId"), "*", "%").toString()
                                                .toUpperCase());
            }
            if (MapUtils.getObject(lotPortalFormMap, "lotStatus") != null) {
                String[] lotStatusArray = (String[]) MapUtils.getObject(lotPortalFormMap, "lotStatus");
                if (lotStatusArray != null && lotStatusArray.length > 0) {
                    if (lotStatusArray.length != 1 || StringUtils.isNotEmpty(lotStatusArray[0])) {
                        lotPortalFormMap.put("lotStatusArray", lotStatusArray);
                    }
                } else {
                    lotPortalFormMap.put("lotStatusArray", lotStatusArray);
                }
            }
            if (MapUtils.getObject(lotPortalFormMap, "lotCategory") != null) {
                String[] lotCategoryArray = (String[]) MapUtils.getObject(lotPortalFormMap, "lotCategory");
                lotPortalFormMap.put("lotCategoryArray", lotCategoryArray);
            } else {
                lotPortalFormMap.put("lotCategory", StringUtils.EMPTY);
            }
            if (StringUtils.isNotBlank(MapUtils.getString(lotPortalFormMap, "productId"))) {
                lotPortalFormMap.put("productId",
                                     MapUtils.getString(lotPortalFormMap, "productId").replace("*", "").toUpperCase()
                                             .replaceAll(",", "|"));
            }
            if (StringUtils.isNotBlank(MapUtils.getString(lotPortalFormMap, "processId"))) {
                lotPortalFormMap.put("processId",
                                     MapUtils.getString(lotPortalFormMap, "processId").replace("*", "%").toUpperCase());
            }
            if (StringUtils.isNotBlank(MapUtils.getString(lotPortalFormMap, "routeId"))) {
                lotPortalFormMap.put("routeId",
                                     MapUtils.getString(lotPortalFormMap, "routeId").replace("*", "%").toUpperCase());
            }
            if (StringUtils.isNotBlank(MapUtils.getString(lotPortalFormMap, "carrierId"))) {
                lotPortalFormMap.put("carrierId",
                                     StringUtils.replace(MapUtils.getString(lotPortalFormMap, "carrierId"), "*", "%")
                                                .toString().toUpperCase());
            }
            if (StringUtils.isNotBlank(MapUtils.getString(lotPortalFormMap, "stationId"))) {
                lotPortalFormMap.put("stationId",
                                     MapUtils.getString(lotPortalFormMap, "stationId").replace("*", "%").toUpperCase());
            }
            if (StringUtils.isNotBlank(MapUtils.getString(lotPortalFormMap, "eqptGroupId"))) {
                lotPortalFormMap.put("eqptGroupId",
                                     MapUtils.getString(lotPortalFormMap, "eqptGroupId").replace("*", "%").toUpperCase());
            }
            if (StringUtils.isNotBlank(MapUtils.getString(lotPortalFormMap, "stageId"))) {
                lotPortalFormMap.put("stageId",
                                     MapUtils.getString(lotPortalFormMap, "stageId").replace("*", "%").toUpperCase());
            }
            if (StringUtils.isNotBlank(MapUtils.getString(lotPortalFormMap, "customId"))) {
                lotPortalFormMap.put("customId", MapUtils.getString(lotPortalFormMap, "customId").replace("*", "%"));
            }
            if (StringUtils.isNotBlank(MapUtils.getString(lotPortalFormMap, "eqptId"))) {
                lotPortalFormMap.put("eqptId",
                                     MapUtils.getString(lotPortalFormMap, "eqptId").replace("*", "%").toUpperCase());
            }
            return lotPortalFormMap;
        }

        @Override
        public List<Map<String, Object>> getRunCardGridInfo(String lotId) {
            return runCardQueryDao.getRunCardGridInfo(lotId);
        }
    }