EquipmentConstrainSetupAction.java

package com.mycim.webapp.actions.constrain;

import com.fa.sesa.exception.Assert;
import com.fa.sesa.exception.Errors;
import com.fa.sesa.i18n.I18nUtils;
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.time.DateUtils;
import com.mycim.valueobject.MessageIdList;
import com.mycim.valueobject.ObjectList;
import com.mycim.valueobject.ems.Entity;
import com.mycim.valueobject.ems.Equipment;
import com.mycim.valueobject.prp.EquipmentConstrainInfo;
import com.mycim.valueobject.security.UserGroup;
import com.mycim.valueobject.wip.Lot;
import com.mycim.webapp.actions.PrpSetupAction;
import com.mycim.webapp.forms.EquipmentConstrainSetupForm;
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.sql.Timestamp;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.util.*;
import java.util.regex.Pattern;

/**
 * @author shijie.deng
 * @version 6.0.0
 * @date 2019/9/11
 **/
public class    EquipmentConstrainSetupAction extends PrpSetupAction {
    public static String REJECT_STOP_KEY = "REJECT-STOP";

    public static String ACCEPT_KEY = "ACCEPT";

    @Override
    public ActionForward init(ActionMapping mapping, ActionForm form, HttpServletRequest request,
                              HttpServletResponse response) {
        request.setAttribute("userId", LocalContext.getUserId());

        String[] types = new String[]{"PRIORITY", "HOTFLAG"};

        registerOptionType(LocalContext.getFacilityRrn(), Arrays.asList(types), request);

        return mapping.getInputForward();
    }


    public Page qryEquipmentConstrain(EquipmentConstrainSetupForm theform, HttpServletRequest request) {
        String userId = LocalContext.getUserId();
        long userRrn = LocalContext.getUserRrn();
        long facilityRrn = LocalContext.getFacilityRrn();

        String equipmentId = StringUtils.trimToUpperCase(theform.getEquipmentId());
        if (StringUtils.isNotBlank(equipmentId)) {
            equipmentId = equipmentId.replace("*", "%");
        }
        Map<String, Object> conditionInfo = new HashMap<>();
        String checkFlag = request.getParameter("checkFlag");
        conditionInfo.put("checkFlag", checkFlag);
        conditionInfo.put("equipmentId", equipmentId);
        conditionInfo.put("isQeUser", isQeUser(userRrn) &&
                !emsService.checkUserAndEqptStationJurisdiction(userId, theform.getEquipmentId(), facilityRrn));
        conditionInfo.put("runFunc", theform.getRunFunc());
        conditionInfo.put("isExpired", theform.getIsExpired());

        List<String> constrainRule = Arrays.asList(EquipmentConstrainInfo.NORMAL_EQUIPMENT_RULE,
                                                 EquipmentConstrainInfo.FREE_EQUIPMENT_RULE);

        conditionInfo.put("constrainRule", constrainRule);
        Page equipmentConstrainPage = new Page(theform.getPage(), theform.getLimit());
        equipmentConstrainPage = constrainService.qryEquipmentConstrainInfos(equipmentConstrainPage, conditionInfo);
        return equipmentConstrainPage;
    }


    public String saveEquipmentConstrain(EquipmentConstrainSetupForm theform) {

        String userId = LocalContext.getUserId();
        long facilityRrn = LocalContext.getFacilityRrn();

        if (theform.getTotalWaferCount() > 0 || theform.getDailyWaferCount() > 0) {
            Assert.isFalse(StringUtils.isBlank(theform.getExpireDate()) && StringUtils.isBlank(theform.getExpireTime()),
                           Errors.create().key(MessageIdList.EQUIPMENT_CONSTRAIN_EXPIREDATE_NOT_NULL)
                                 .content("When the wafer count is selected, the expire date cannot be empty").build());
            if (StringUtils.isBlank(theform.getExpireDates())) {
                DateTimeFormatter dtf = DateTimeFormatter.ofPattern("YYYY/MM/dd");
                theform.setExpireDates(dtf.format(LocalDate.now()));
            }
        }


        if (StringUtils.isNotEmpty(theform.getExpireDates())) {
            theform.setExpireDate(theform.getExpireDates() + " " +
                                          (StringUtils.isEmpty(theform.getExpireTime()) ? "00:00:00" : theform
                                                  .getExpireTime()));
        }
        validateLotConstainInfo(theform);
        Map condtionInfo = new HashMap();
        condtionInfo.put("equipmentId", theform.getEquipmentId());
        condtionInfo.put("productId", theform.getProductId());
        condtionInfo.put("processId", theform.getProcessId());
        condtionInfo.put("lotId", theform.getLotId());
        condtionInfo.put("operationId", theform.getOperationId());
        condtionInfo.put("recipeId", theform.getRecipeId());
        condtionInfo.put("constrainSeq", theform.getConstrainSeq());
        condtionInfo.put("routeId", theform.getRouteId());
        condtionInfo.put("customerId", theform.getCustomerId());
        condtionInfo.put("stageId", theform.getStageId());
        condtionInfo.put("dailyWaferCount", theform.getDailyWaferCount());
        condtionInfo.put("totalWaferCount", theform.getTotalWaferCount());

        EquipmentConstrainInfo equipmentConstrainInfo = new EquipmentConstrainInfo();
        BeanUtils.copyProperties(theform, equipmentConstrainInfo);

        equipmentConstrainInfo.setCreateBy(userId);
        equipmentConstrainInfo.setFacilityRrn(facilityRrn);
        //如果是腔体，查询出它的父设备，统计waferCount用
        Entity entity = emsService.getEntity(
                getInstanceRrn(equipmentConstrainInfo.getEquipmentId(), LocalContext.getFacilityRrn(),
                               ObjectList.ENTITY_KEY));
        equipmentConstrainInfo
                .setParentEquipmentRrn(entity.getParentEntityRrn() == null ? 0 : entity.getParentEntityRrn());
        equipmentConstrainInfo.setParentEquipmentId(entity.getParentEntityId());

        if (theform.getConstrainRrn() <= 0) {
            Collection constrainRules = Arrays
                    .asList(new String[]{EquipmentConstrainInfo.NORMAL_EQUIPMENT_RULE,
                            EquipmentConstrainInfo.FREE_EQUIPMENT_RULE});
            condtionInfo.put("constrainRule", constrainRules);
            List<EquipmentConstrainInfo> equipmentConstrainInfos = constrainService
                    .validationEquipmentConstrainInfos(condtionInfo);
            Assert.isFalse(CollectionUtils.isNotEmpty(equipmentConstrainInfos),
                           Errors.create().key(MessageIdList.CONSTRAIN_EXIST_PLEASE_MODIFY).content(
                                   "The process " + "limitation " + "has" + " " + "existed. " + "Please check " +
                                           "the process " + "limit and " + "modify it.").build());
            constrainService.insertEquipmentConstrainInfo(equipmentConstrainInfo);
        } else {
            equipmentConstrainInfo.setModifyBy(userId);
            constrainService.modifyEquipmentConstrainInfo(equipmentConstrainInfo);
        }
        return I18nUtils.getMessage("system.operate_successfully", "operate successfully!");

    }

    public String deleteLotConstrain(EquipmentConstrainSetupForm theform) {
        String userId = LocalContext.getUserId();
        EquipmentConstrainInfo equipmentConstrainInfo = new EquipmentConstrainInfo();
        long constrainRrn = theform.getConstrainRrn();
        if (constrainRrn > 0) {
            equipmentConstrainInfo.setConstrainRrn(constrainRrn);
            equipmentConstrainInfo = constrainService.getEquipmentConstrainInfo(equipmentConstrainInfo, false);
        }

        Assert.isFalse(theform.getConstrainRrn() <= 0,
                       Errors.create().key(MessageIdList.CONSTRAIN_NOT_EXIST_PLEASE_CONFIRM)
                             .content("This process limit does not exist, please" + " " + "confirm!").build());

        equipmentConstrainInfo.setModifyBy(userId);
        constrainService.deleteEquipmentConstrainInfo(equipmentConstrainInfo);
        return I18nUtils.getMessage("system.operate_successfully", "operate successfully!");
    }


    public EquipmentConstrainInfo getEquipmentConstrain(EquipmentConstrainSetupForm theform) {

        EquipmentConstrainInfo equipmentConstrainInfo = new EquipmentConstrainInfo();
        BeanUtils.copyProperties(theform, equipmentConstrainInfo);
        String constrainRule = theform.getConstrainRule();
        Boolean approveFlag = StringUtils.equalsIgnoreCase(EquipmentConstrainInfo.CHECK_EQUIPMENT_RULE, constrainRule);
        long constrainRrn = theform.getConstrainRrn();
        if (constrainRrn > 0) {
            equipmentConstrainInfo.setConstrainRrn(constrainRrn);
            equipmentConstrainInfo = constrainService.getEquipmentConstrainInfo(equipmentConstrainInfo, approveFlag);

            Map<String, Object> conditionMap = new HashMap<String, Object>();
            conditionMap.put("type", "eqptConstrain");
            conditionMap.put("constrainInfo", equipmentConstrainInfo);
            conditionMap.put("facilityRrn", LocalContext.getFacilityRrn());
            Date date = DateUtils.parse(DateUtils.getNowTime(DateUtils.DATE_FORMAT4DAYD), DateUtils.DATE_FORMAT4DAYD);
            if (date.before(equipmentConstrainInfo.getModifyTime())) {
                conditionMap.put("startTime", DateUtils
                        .formatDate(equipmentConstrainInfo.getModifyTime(), DateUtils.DATE_FORMAT4DATE));
            } else {
                conditionMap.put("startTime", DateUtils.getNowTime(DateUtils.DATE_FORMAT4DAYD));
            }
            conditionMap.put("level", EquipmentConstrainInfo.LOT);
            equipmentConstrainInfo
                    .setCurrentDailyLotCount(lotQueryService.getLotCountFormHistoryByCondition(conditionMap));
            conditionMap.put("level", EquipmentConstrainInfo.WAFER);
            equipmentConstrainInfo
                    .setCurrentDailyWaferCount(lotQueryService.getLotCountFormHistoryByCondition(conditionMap));
            conditionMap.put("startTime",
                             DateUtils.formatDate(equipmentConstrainInfo.getModifyTime(), DateUtils.DATE_FORMAT4DATE));
            conditionMap.put("level", EquipmentConstrainInfo.LOT);
            equipmentConstrainInfo
                    .setCurrentTotalLotCount(lotQueryService.getLotCountFormHistoryByCondition(conditionMap));
            conditionMap.put("level", EquipmentConstrainInfo.WAFER);
            equipmentConstrainInfo
                    .setCurrentTotalWaferCount(lotQueryService.getLotCountFormHistoryByCondition(conditionMap));

            Date modifyTime = equipmentConstrainInfo.getModifyTime();
            long autoInterval = DateUtils.getSecondsTime(equipmentConstrainInfo.getAutoSwitchTimeInterval());
            if (autoInterval > 0 &&
                    !StringUtils.equals(equipmentConstrainInfo.getConstrainStatus(), EquipmentConstrainInfo.ENABLE)) {
                equipmentConstrainInfo.setNextEnableTime(DateUtils.addSeconds(modifyTime, (int) autoInterval));
            }

        }
        return equipmentConstrainInfo;
    }


    public Page buildQryEquipmentConstrain(EquipmentConstrainSetupForm theform) {
        long facilityRrn = LocalContext.getFacilityRrn();
        Collection equipmentConstrainInfoValueList = new ArrayList();
        Map condtionInfo = new HashMap();
        condtionInfo.put("checkFlag", theform.getCheckFlag());
        condtionInfo.put("equipmentId", theform.getEquipmentId());
        List<String> constrainRule = Arrays.asList(EquipmentConstrainInfo.NORMAL_EQUIPMENT_RULE, EquipmentConstrainInfo.FREE_EQUIPMENT_RULE);
        condtionInfo.put("constrainRule", constrainRule);
        Page equipmentConstrainPage = new Page(theform.getPage(), theform.getLimit());
        if (StringUtils.isNotEmpty(theform.getConstranin())) {
            Lot lot = new Lot();
            BeanUtils.copyProperties(theform, lot);
            String equipmentId = theform.getEquipmentId();
            Equipment equipment = new Equipment(equipmentId, getNamedSpace(ObjectList.ENTITY_KEY, facilityRrn),
                                                ObjectList.ENTITY_KEY);
            // equipment = getEquipment(equipment);
            equipmentConstrainInfoValueList = lotConstrain(equipment, lot);
        } else {
            equipmentConstrainPage = constrainService.qryEquipmentConstrainInfos(equipmentConstrainPage, condtionInfo);
            List equipmentConstrainInfoList = (List) equipmentConstrainPage.getResults();
            String equipmentId = theform.getEquipmentId();
            for (int i = 0; i < equipmentConstrainPage.getTotalItems(); i++) {
                EquipmentConstrainInfo equipmentConstrainInfo = (EquipmentConstrainInfo) equipmentConstrainInfoList
                        .get(i);
                if (equipmentConstrainInfo.matchesEquipmentId(equipmentId)) {
                    equipmentConstrainInfoValueList.add(equipmentConstrainInfo);
                }
            }
        }
        equipmentConstrainPage.setResults(equipmentConstrainInfoValueList);
        return equipmentConstrainPage;
    }


    public String checkEquipmentConstrain(EquipmentConstrainSetupForm theform) {

        long facilityRrn = LocalContext.getFacilityRrn();
        String userId = LocalContext.getUserId();
        long userRrn = LocalContext.getUserRrn();

        validateLotConstainInfo(theform);
        EquipmentConstrainInfo equipmentConstrainInfo = new EquipmentConstrainInfo();
        BeanUtils.copyProperties(theform, equipmentConstrainInfo);
        equipmentConstrainInfo.setFacilityRrn(facilityRrn);

        Assert.isFalse(StringUtils.equals(equipmentConstrainInfo.getModifyBy(), userId),
                       Errors.create().key(MessageIdList.ECS_NO_PERMISSION_DOUBLE_CHECK)
                             .content("Current login user does not have permission to double check").build());

        equipmentConstrainInfo.setModifyBy(userId);

        if (StringUtils.equalsIgnoreCase("on", equipmentConstrainInfo.getQeFlag())) {
            List<UserGroup> userGroups = securityService.getUserGroupByUserRrn(userRrn);
            boolean notQE = false;
            for (UserGroup userGroup : userGroups) {
                if (StringUtils.equals("QE", userGroup.getInstanceId())) {
                    notQE = true;
                }
            }
            Assert.isTrue(notQE, Errors.create().key(MessageIdList.ECS_NO_PERMISSION_QE)
                                       .content("You have no permission to double check ,please contact QE").build());
        }


        constrainService.checkAndModifyEquipmentConstrainInfo(equipmentConstrainInfo);

        return I18nUtils.getMessage("system.operate_successfully", "operate successfully!");

    }

    public String getMaxConstrainSeqByEqpt(ActionMapping mapping, EquipmentConstrainSetupForm theform,
                                           HttpServletRequest request, HttpServletResponse response) {
        Integer maxConstrainSeqByEqpt = constrainService
                .getMaxConstrainSeqByEqpt(StringUtils.trimToUpperCase(theform.getEquipmentId()));

        return StringUtils.toString(maxConstrainSeqByEqpt + 1);
    }


    private Collection lotConstrain(Equipment equipment, Lot lot) {
        Collection equipmentConstrainInfoValueList = new ArrayList();

        // 检查批次上的工艺限制
        List<String> constrainRule = Arrays.asList(EquipmentConstrainInfo.NORMAL_EQUIPMENT_RULE, EquipmentConstrainInfo.FREE_EQUIPMENT_RULE);

        Collection equipmentConstrainInfos = constrainService
                .qryEnableEquipmentConstrainInfos(constrainRule, equipment.getInstanceId(), "");

        for (Iterator iterator = equipmentConstrainInfos.iterator(); iterator.hasNext(); ) {
            EquipmentConstrainInfo equipmentConstrainInfo = (EquipmentConstrainInfo) iterator.next();
            Pattern pattern = Pattern.compile(equipmentConstrainInfo.getReplaceEquipmentConstrain());
            if (pattern.matcher(equipmentConstrainInfo.matchesEquipmenConstrainInfo(equipment, lot)).matches()) {
                if (StringUtils
                        .equals(equipmentConstrainInfo.getConstrainAction(), EquipmentConstrainInfo.REJECTSTOP)) {
                    equipmentConstrainInfoValueList.add(equipmentConstrainInfo);
                    break;
                }
            }
        }
        return equipmentConstrainInfoValueList;
    }


    private void validateLotConstainInfo(EquipmentConstrainSetupForm theform) {

        if (!StringUtils.equals(theform.getConstrainType(), "1")) {
            String equipmentIds = StringUtils.trimToUpperCase(theform.getEquipmentId());
            if (StringUtils.isNotBlank(equipmentIds)) {

                String equipmentIdStr = validAndbuildEquipmentIds(equipmentIds);

                theform.setEquipmentId(equipmentIdStr.toString());
            }
        }

        if (StringUtils.isNotBlank(theform.getExpireDate())) {
            long nowTime = System.currentTimeMillis();
            Timestamp dueDate = DateUtils.stringToTimestamp(theform.getExpireDate());
            Integer daliyWaferCount = theform.getDailyWaferCount();

            Assert.isTrue(dueDate != null,
                          Errors.create().key(MessageIdList.ASM_DATEFORMAT_CHECK).content("Date format is wrong!")
                                .build());
            Assert.isFalse(dueDate.getTime() < nowTime && (daliyWaferCount == null || daliyWaferCount == 0),
                           Errors.create().key(MessageIdList.ASM_EXPIRY_DATE_INVALID)
                                 .content("Expire date must after the current date").build());

        }
    }


    private String validAndbuildEquipmentIds(String equipmentIds) {

        long facilityRrn = LocalContext.getFacilityRrn();
        String userId = LocalContext.getUserId();
        Long userRrn = LocalContext.getUserRrn();
        String[] equipmentIdArray = StringUtils.split(equipmentIds, ',');

        StringBuilder equipmentIdStr = new StringBuilder();

        for (int i = 0; i < equipmentIdArray.length; i++) {
            String equipmentId = StringUtils.trimToUpperCase(equipmentIdArray[i]);
            if (StringUtils.isBlank(equipmentId)) {
                continue;
            }
            long equipmentRrn = this.getInstanceRrn(equipmentId, facilityRrn, ObjectList.ENTITY_KEY);
            Assert.isFalse(equipmentRrn <= 0,
                           Errors.create().key(MessageIdList.EQUIPMENT_ID_NOT_EXIST).content("EQP id input error")
                                 .build());

            if (!this.emsService.checkUserAndEqptStationJurisdiction(userId, equipmentIds, facilityRrn)) {
                Assert.isTrue(isQeUser(userRrn), Errors.create().key(MessageIdList.EQUIPMENT_NO_PERMISSION_MODIFY)
                                                       .content("No permission to modify the {}!").args(equipmentId)
                                                       .build());
            }

            equipmentIdStr.append(equipmentId);
            equipmentIdStr.append(",");

        }
        equipmentIdStr.deleteCharAt(equipmentIdStr.length() - 1);

        return equipmentIdStr.toString();
    }

    private boolean isQeUser(long userRrn) {
        boolean isQeUser = false;

        List<UserGroup> userGroups = securityService.getUserGroupByUserRrn(userRrn);
        for (UserGroup userGroup : userGroups) {
            if (StringUtils.equals("QE", userGroup.getInstanceId())) {
                isQeUser = true;
                break;
            }
        }

        return isQeUser;
    }

}