EquipmentTriggerMaintainAction.java

package com.mycim.webapp.actions.equipmentpm;

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.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.mycim.framework.jdbc.Page;
import com.mycim.framework.utils.lang.ObjectUtils;
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.valueobject.MessageIdList;
import com.mycim.valueobject.ObjectList;
import com.mycim.valueobject.SystemConstant;
import com.mycim.valueobject.ems.*;
import com.mycim.webapp.TemplateLocation;
import com.mycim.webapp.WebUtils;
import com.mycim.webapp.actions.EmsSetupAction;
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: yibing.liu
 * @Date: 2021/12/14 16:51
 */
public class EquipmentTriggerMaintainAction extends EmsSetupAction {

    public static final String fileName = "pms_trigger_imp_template-version.xls";

    public void createMaintain(Map paramMap) {
        EquipmentTriggerMaintainQuery maintainQuery = buildParam(paramMap);
        //check valid
        checkValid(maintainQuery);
        Assert.isFalse(pmsService.getTriggerMaintain(maintainQuery) != null, Errors.create().key(MessageIdList.HAS_EXIST).content("{}已存在!").args("PM").build());
        pmsService.addTriggerMaintain(maintainQuery);
    }

    public void modifyMaintain(Map paramMap) {
        EquipmentTriggerMaintainQuery maintainQuery = buildParam(paramMap);

        checkValid(maintainQuery);
        PmsSchedule schedule = new PmsSchedule();
        schedule.setObjectId(maintainQuery.getEquipmentId());
        schedule.setTriggerCode(maintainQuery.getTriggerCode());
        schedule.setControlType(PmControlTypeEnum.PM_TRIGGER_READING.name());
        schedule.setItemStatus(SystemConstant.Str.ON);
        List<PmsSchedule> list = pmsService.qryEqptPMInfo(schedule);
        pmsService.modifyTriggerMaintain(maintainQuery, list);
    }


    /**
     * Ajax Request
     * @param paramMap
     * @return
     */
    public void deleteMaintain(Map paramMap) {
        String comment = MapUtils.getString(paramMap, "comment");
        String deleteList = MapUtils.getString(paramMap, "delList");
        EquipmentTriggerMaintainQuery maintainQuery = buildParam(paramMap);
        Assert.isFalse(StringUtils.isBlank(comment), Errors.create().key(MessageIdList.CAN_NOT_EMPTY).content("{} cannot be empty!").args("Comment").build());
        Assert.isFalse(StringUtils.isBlank(deleteList), Errors.create().key(MessageIdList.PLEASE_SELECT_DATA).content("please choose data!").build());
        String[] arr = StringUtils.split(deleteList, ";");
        List<EquipmentTriggerMaintain> list = new ArrayList<>();
        for (String str : arr){
            EquipmentTriggerMaintainQuery etmq = new EquipmentTriggerMaintainQuery();
            String[] temp = StringUtils.split(str, ",");
            etmq.setEquipmentId(temp[0]);
            etmq.setTriggerCode(temp[1]);
            EquipmentTriggerMaintain etm = pmsService.getTriggerMaintain(etmq);
            Assert.isFalse(Objects.isNull(etm), Errors.create().key(MessageIdList.TRIGGER_MAINTAIN_NOT_EXIST).content("{}的{}的TriggerMaintain不存在!").args(temp[0],temp[1]).build());
            //具体提示
            Assert.isFalse(etm.getCiteCount() > 0, Errors.create().key(MessageIdList.CAN_NOT_DELETE).content("{},can't delete!").args("Already cited by PM").build());
            list.add(etm);
        }
        maintainQuery.setComment(comment);
        maintainQuery.setDeleteList(list);
        pmsService.deleteTriggerMaintain(maintainQuery);
    }

    /**
     * Ajax Request
     * @param paramMap
     * @return
     */
    public List<Map<String, Object>> queryTriggerCodeByEquipment(Map paramMap) {
        List<Map<String,Object>> list = new ArrayList<>();
        EquipmentTriggerMaintainQuery mainForm = buildParam(paramMap);
        if (StringUtils.isBlank(mainForm.getEquipmentId())) {
            return list;
        }
        mainForm.setEquipmentId("*" + mainForm.getEquipmentId());
        List<EquipmentTriggerMaintain> maintainList = pmsService.queryTriggerCodeByEquipment(mainForm);
        for (EquipmentTriggerMaintain etm:maintainList){
            Map<String,Object> temp = new HashMap<>();
            temp.put("key", etm.getTriggerCode());
            temp.put("data1", etm.getTriggerCodeSpec());
            list.add(temp);
        }
        return list;
    }


    public Map getAffectedPM(Map paramMap) {
        EquipmentTriggerMaintainQuery form = buildParam(paramMap);
        Map result = new HashMap();
        PmsSchedule schedule = new PmsSchedule();
        schedule.setObjectId(form.getEquipmentId());
        schedule.setTriggerCode(form.getTriggerCode());
        schedule.setControlType(PmControlTypeEnum.PM_TRIGGER_READING.name());
        schedule.setItemStatus(SystemConstant.Str.ON);
        List<PmsSchedule> list = pmsService.qryEqptPMInfo(schedule);          //获取所有引用TriggerCode和EqptId的 PMS
        StringBuilder affectedPmIds = new StringBuilder();
        if (CollectionUtils.isNotEmpty(list)){
            for (PmsSchedule ps:list){
                affectedPmIds.append(",").append(ps.getPmId());
            }
        }
        result.put("data", affectedPmIds.length()>1?affectedPmIds.substring(1):StringUtils.EMPTY);
        return result;
    }


    public Map<String, Object> queryMaintain(Map paramMap) {
        int pageNo = MapUtils.getIntValue(paramMap, "page");
        int pageSize = MapUtils.getIntValue(paramMap, "limit");
        String startDate = MapUtils.getString(paramMap, "startDate");
        String endDate = MapUtils.getString(paramMap, "endDate");
        Page page = new Page(pageNo, pageSize);
        EquipmentTriggerMaintainQuery maintainQuery = buildParam(paramMap);
        maintainQuery.setStartDate(startDate);
        maintainQuery.setEndDate(endDate);
        page = pmsService.queryMaintainByPage(page, maintainQuery);
        Map<String, Object>       resultMap = new HashMap<>();
        resultMap.put("results", page.getResults());
        resultMap.put("totalCount", page.getTotalItems());
        return resultMap;
    }

    public Map<String, Object> queryMaintainH(Map paramMap) {
        int pageNo = MapUtils.getIntValue(paramMap, "page");
        int pageSize = MapUtils.getIntValue(paramMap, "limit");
        String startDate = MapUtils.getString(paramMap, "startDate");
        String endDate = MapUtils.getString(paramMap, "endDate");
        Page page = new Page(pageNo, pageSize);
        EquipmentTriggerMaintainQuery maintainQuery = buildParam(paramMap);
        maintainQuery.setStartDate(startDate);
        maintainQuery.setEndDate(endDate);
        page = pmsService.queryMaintainHistoryByPage(page, maintainQuery);
        Map<String, Object>       resultMap = new HashMap<>();
        resultMap.put("results", page.getResults());
        resultMap.put("totalCount", page.getTotalItems());
        return resultMap;
    }

    @Override
    public ActionForward init(ActionMapping mapping, ActionForm form, HttpServletRequest request,
                              HttpServletResponse response) {
        return mapping.findForward("index");
    }

    private EquipmentTriggerMaintainQuery buildParam(Map paramMap) {
        EquipmentTriggerMaintainQuery etmq = new EquipmentTriggerMaintainQuery();
        etmq.setEquipmentId(MapUtils.getString(paramMap, "equipmentId", StringUtils.EMPTY));
        etmq.setChamberId(MapUtils.getString(paramMap, "chamberId", StringUtils.EMPTY));
        etmq.setTriggerCode(MapUtils.getString(paramMap, "triggerCode", StringUtils.EMPTY));
        etmq.setTriggerCodeSpec(MapUtils.getString(paramMap, "triggerCodeSpec", StringUtils.EMPTY));
        etmq.setTriggerReading(MapUtils.getString(paramMap, "triggerReading", StringUtils.EMPTY));
        etmq.setTriggerLevel(MapUtils.getString(paramMap, "triggerLevel", StringUtils.EMPTY));
        etmq.setComment(MapUtils.getString(paramMap, "comment", StringUtils.EMPTY));

        etmq.setTargetEquipmentId(MapUtils.getString(paramMap, "targetEquipmentId", StringUtils.EMPTY));
        etmq.setTargetTriggerCode(MapUtils.getString(paramMap, "targetTriggerCode", StringUtils.EMPTY));
        etmq.setTargetTriggerLevel(MapUtils.getString(paramMap, "targetTriggerLevel", StringUtils.EMPTY));

        etmq.setFacilityRrn(LocalContext.getFacilityRrn());
        etmq.setUserId(LocalContext.getUserId());
        etmq.setUserRrn(LocalContext.getUserRrn());
        return etmq;
    }

    private void checkValid(EquipmentTriggerMaintainQuery maintain) {
        Assert.isFalse(StringUtils.isBlank(maintain.getEquipmentId()), Errors.create().key(MessageIdList.CAN_NOT_EMPTY).content("The {} cannot be empty!").args("Equipment ID").build());

        Entity entity = emsService.getEntity(
                new Entity(maintain.getEquipmentId(), getNamedSpace(ObjectList.ENTITY_KEY, maintain.getFacilityRrn()), ObjectList.ENTITY_KEY));

        Assert.isFalse(entity.getInstanceRrn() <= 0, Errors.create().key(MessageIdList.EQUIPMENT_IS_NOT_EXIST).content("The EQP is not exist!").build());


        maintain.setEquipmentRrn(entity.getInstanceRrn());
        maintain.setChamberId(getChamberType(entity));

        Assert.isFalse(StringUtils.length(maintain.getChamberId()) > 1, Errors.create().key(MessageIdList.CHAMBER_ID_TOO_LONG).content("The chamber ID length cannot exceed 1!").build());
        Assert.isFalse(StringUtils.isBlank(maintain.getTriggerCode()), Errors.create().key(MessageIdList.TRIGGER_CODE_CAN_NOT_EMPTY).content("The trigger code cannot be empty!").build());
        Assert.isFalse(StringUtils.length(maintain.getTriggerCode()) > 128, Errors.create().key(MessageIdList.TRIGGER_CODE_TOO_LONG).content("The trigger code length cannot exceed 128!").build());
        Assert.isFalse(StringUtils.isBlank(maintain.getTriggerCodeSpec()), Errors.create().key(MessageIdList.CAN_NOT_EMPTY).content("The {} cannot be empty!").args("trigger code spec").build());
        Assert.isFalse(!NumberUtils.isNumber(maintain.getTriggerCodeSpec()), Errors.create().key(MessageIdList.NOT_NUMBER).content("The {} is not number!").args("trigger code spec").build());
        if (StringUtils.isNotBlank(maintain.getTriggerReading())) {
            Assert.isFalse(!NumberUtils.isNumber(maintain.getTriggerReading()), Errors.create().key(MessageIdList.NOT_NUMBER).content("The {} is not number!").args("trigger reading").build());
        }

    }

    private String getChamberType(Entity entity) {
        String chamberType = StringUtils.EMPTY;
        if (entity.getParentEntityRrn() != null && entity.getParentEntityRrn() > 0){
            chamberType = StringUtils.substringAfterLast(entity.getInstanceId(), CHAMBER_FLAG);
        }
        return chamberType;
    }

    public void downloadTemplate(HttpServletResponse response) throws Exception {
        WebUtils.exportExcel(fileName, new HashMap<>(), new ArrayList<>(), TemplateLocation.PMS_IMP_TEMPLATE, 1, 1,
                             response);
    }

    public List<Map<String, Object>> checkPMSParameterAvailable(Map<String, Object> dataObjListMap) {
        Map<String, Object> dataObjList = (Map<String, Object>) MapUtils.getObject(dataObjListMap, "dataObjList");
        String dataList = (String) dataObjList.get("dataList");
        List<Map<String, Object>> list;
        try {
            list = new ObjectMapper().readValue(dataList, new TypeReference<List<Map<String, Object>>>() {});
        } catch (Exception e) {
            throw new SystemIllegalArgumentException(Errors.create().content(e.getMessage()).build());
        }
        for (Map<String, Object> map : list) {
            map.put("type", "area");
            map.put("areaFlag", checkField(map, list));
            map.put("type", "eqpId");
            map.put("eqpIdFlag", checkField(map, list));
            map.put("type", "chamberId");
            map.put("chamberIdFlag", checkField(map, list));
            map.put("type", "triggerCode");
            map.put("triggerCodeFlag", checkField(map, list));
            map.put("type", "triggerCodeSpec");
            map.put("triggerCodeSpecFlag", checkField(map, list));
            map.put("type", "triggerCodeDesc");
            map.put("triggerCodeDescFlag", checkField(map, list));
            map.put("type", "UOM");
            map.put("UOMFlag", checkField(map, list));
            // 校验EQP和Area是否匹配
            map.put("type", "areaMatching");
            checkField(map,list );
            // 校验是否有相同的EQP ID和Trigger Code
            map.put("type", "isExisted");
            checkField(map,list);
            // 校验腔体设备是否和设备匹配
            map.put("type", "chamberMatching");
            checkField(map,list);
            // 校验模板的数据是否重复
            map.put("type", "isRepeated");
            checkField(map, list);
        }
        return list;
    }

    private String checkField(Map<String, Object> map, List<Map<String, Object>> list) {
        String type = MapUtils.getString(map, "type");
        long facilityRrn = LocalContext.getFacilityRrn();
        String area = StringUtils.trimToUpperCase(MapUtils.getString(map, "data_0")) ;
        String eqpId = StringUtils.trimToUpperCase(MapUtils.getString(map, "data_1"));
        String chamberId = StringUtils.trimToUpperCase(MapUtils.getString(map, "data_2"));
        String triggerCode = MapUtils.getString(map, "data_3");
        String triggerCodeSpec = StringUtils.trimToUpperCase(MapUtils.getString(map, "data_4"));
        String triggerCodeDesc = StringUtils.trimToUpperCase(MapUtils.getString(map, "data_5"));
        String UOM = MapUtils.getString(map, "data_6");
        if (StringUtils.equals("area", type)) {
            if (StringUtils.isBlank(area)) {
                map.put("areaExistFlag", "blank");
                return StringUtils.BOOLEAN_FALSE;
            }
            // 判断EQP ID
        } else if (StringUtils.equals("eqpId", type)) {
            if (StringUtils.isBlank(eqpId)) {
                map.put("eqpIdExistFlag", "blank");
                return StringUtils.BOOLEAN_FALSE;
            } else if (eqpId.contains(StringUtils.UNDERLINE)) {
                if (getInstanceRrn(eqpId, facilityRrn, ObjectList.ENTITY_KEY) == 0) {
                    map.put("eqpIdExistFlag", "inexistence");
                    return StringUtils.BOOLEAN_FALSE;
                }
            } else if (getInstanceRrn(eqpId, facilityRrn, ObjectList.ENTITY_KEY) == 0) {
                map.put("eqpIdExistFlag", "inexistence");
                return StringUtils.BOOLEAN_FALSE;
            }
            // 判断chamberId
        } else if (StringUtils.equals("chamberId", type)) {
            if (StringUtils.length(chamberId) > 1) {
                map.put("eqpIdExistFlag", "exceed");
                return StringUtils.BOOLEAN_FALSE;
            }
            // 判断triggerCode
        } else if (StringUtils.equals("triggerCode", type)) {
            if (StringUtils.isBlank(triggerCode)) {
                map.put("triggerCodeExistFlag", "blank");
                return StringUtils.BOOLEAN_FALSE;
            } else {
                if (StringUtils.length(triggerCode) > 64) {
                    map.put("triggerCodeExistFlag", StringUtils.BOOLEAN_FALSE);
                    return StringUtils.BOOLEAN_FALSE;
                }
            }
            // 判断triggerCodeSpec
        } else if (StringUtils.equals("triggerCodeSpec", type)) {
            if (StringUtils.isBlank(triggerCodeSpec)) {
                map.put("triggerCodeSpecExistFlag", "blank");
                return StringUtils.BOOLEAN_FALSE;
            } else {
                String reg = "\\d+(\\.\\d+)?";
                boolean matches = triggerCodeSpec.matches(reg);
                if (!matches) {
                    map.put("triggerCodeSpecExistFlag", StringUtils.BOOLEAN_FALSE);
                    return StringUtils.BOOLEAN_FALSE;
                }
            }
            // 判断triggerCodeDesc
        } else if (StringUtils.equals("triggerCodeDesc", type)) {
            if (StringUtils.length(triggerCodeDesc) > 128) {
                map.put("triggerCodeDescExistFlag", StringUtils.BOOLEAN_FALSE);
                return StringUtils.BOOLEAN_FALSE;
            }
            // 判断UOM
        } else if (StringUtils.equals("UOM", type)) {
            if (StringUtils.length(UOM) > 32) {
                map.put("uomExistFlag", StringUtils.BOOLEAN_FALSE);
                return StringUtils.BOOLEAN_FALSE;
            }
            map.put("uomExistFlag", StringUtils.BOOLEAN_TRUE);
            return StringUtils.BOOLEAN_TRUE;
        // 判断设备和机组是否匹配
        } else if (StringUtils.equals("areaMatching", type)) {
            if (StringUtils.equals(MapUtils.getString(map, "eqpIdFlag"), StringUtils.BOOLEAN_TRUE) && StringUtils.equals(MapUtils.getString(map, "areaFlag"), StringUtils.BOOLEAN_TRUE)) {
                Entity entity = new Entity(eqpId, getNamedSpace(ObjectList.ENTITY_KEY, LocalContext.getFacilityRrn()), ObjectList.ENTITY_KEY);
                Entity result = (Entity) getInstance(entity);
                if (!StringUtils.equalsIgnoreCase(result.getEquipmentLocation(), area) ) {
                    map.put("areaFlag", StringUtils.BOOLEAN_FALSE);
                    map.put("areaMatching", StringUtils.BOOLEAN_FALSE);
                    return StringUtils.BOOLEAN_FALSE;
                }
            }
        } else if (StringUtils.equals("isExisted", type)) {
            if (StringUtils.equals(MapUtils.getString(map, "eqpIdFlag"), StringUtils.BOOLEAN_TRUE) &&
                    StringUtils.equals(MapUtils.getString(map, "triggerCodeFlag"), StringUtils.BOOLEAN_TRUE)) {
                if (!eqpId.contains(StringUtils.UNDERLINE) && StringUtils.isNotBlank(MapUtils.getString(map, "data_2"))) {
                    eqpId = eqpId + StringUtils.UNDERLINE + chamberId;
                }
                EquipmentTriggerMaintainQuery etmq = new EquipmentTriggerMaintainQuery();
                etmq.setEquipmentId(eqpId);
                etmq.setTriggerCode(triggerCode);
                EquipmentTriggerMaintain triggerMaintain = pmsService.getTriggerMaintain(etmq);
                if (ObjectUtils.isNotEmpty(triggerMaintain)) {
                    map.put("isExistedFlag", StringUtils.BOOLEAN_FALSE);
                    map.put("eqpIdFlag", StringUtils.BOOLEAN_FALSE);
                    map.put("triggerCodeFlag", StringUtils.BOOLEAN_FALSE);
                    return StringUtils.BOOLEAN_FALSE;
                }
            }
        } else if (StringUtils.equals("chamberMatching", type)) {
            if (StringUtils.equals(MapUtils.getString(map, "eqpIdFlag"), StringUtils.BOOLEAN_TRUE) &&
                    StringUtils.equals(MapUtils.getString(map, "chamberIdFlag"), StringUtils.BOOLEAN_TRUE)) {
                if (StringUtils.isNotBlank(chamberId)) {
                    Entity entity = new Entity(eqpId, getNamedSpace(ObjectList.ENTITY_KEY, facilityRrn), ObjectList.ENTITY_KEY);
                    Entity result = (Entity) getInstance(entity);
                    List<Entity> chambers = emsService.getChildChamberEquip(result.getInstanceRrn());
                    if (CollectionUtils.isEmpty(chambers)) {
                        map.put("chamberIdFlag", StringUtils.BOOLEAN_FALSE);
                        map.put("chamberExistFlag", "inexistence");
                        return StringUtils.BOOLEAN_FALSE;
                    } else {
                        for (Entity chamber: chambers) {
                            String[] tempArr = chamber.getInstanceId().split(StringUtils.UNDERLINE);
                            String lastChar = tempArr[tempArr.length - 1];
                            if (StringUtils.equalsIgnoreCase(lastChar, chamberId)) {
                                map.put("chamberExistFlag", StringUtils.BOOLEAN_TRUE);
                                return StringUtils.BOOLEAN_TRUE;
                            }
                        }
                        map.put("chamberIdFlag", StringUtils.BOOLEAN_FALSE);
                        map.put("chamberExistFlag", StringUtils.BOOLEAN_FALSE);
                        return StringUtils.BOOLEAN_FALSE;
                    }
                }
            }
            // 验证模板的数据是否重复
        } else if (StringUtils.equals("isRepeated", type)) {
            int sum = 0;
            if (StringUtils.equals(MapUtils.getString(map, "eqpIdFlag"), StringUtils.BOOLEAN_TRUE) &&
                    StringUtils.equals(MapUtils.getString(map, "triggerCodeFlag"), StringUtils.BOOLEAN_TRUE)) {
                for(Map<String, Object> param: list) {
                    if (StringUtils.equals(MapUtils.getString(param, "data_1"), eqpId) &&
                            StringUtils.equals(MapUtils.getString(param, "data_3"), triggerCode)) {
                        sum++;
                    }
                }
                if (sum > 1) {
                    map.put("triggerCodeFlag", StringUtils.BOOLEAN_FALSE);
                    map.put("eqpIdFlag", StringUtils.BOOLEAN_FALSE);
                    map.put("isExistedFlag", StringUtils.BOOLEAN_FALSE);
                    return StringUtils.BOOLEAN_FALSE;
                }
            }
        }
        return StringUtils.BOOLEAN_TRUE;
    }

    public void savePMSImportParams(Map<String, Object> dataObjListMap) {
        List<EquipmentTriggerMaintainQuery> triggerMaintainQueryList = new ArrayList<>();
        List<Map<String, Object>> maps = checkPMSParameterAvailable(dataObjListMap);
        for (Map<String, Object> map : maps) {

            Assert.state(!StringUtils.isEqual("blank", MapUtils.getString(map, "areaExistFlag")),
                         Errors.create().key(MessageIdList.AREA_ID_CAN_NOT_EMPTY)
                               .content("The Area can not be empty!")
                               .args().build());

            Assert.state(!StringUtils.isEqual(StringUtils.BOOLEAN_FALSE, MapUtils.getString(map, "areaMatching")),
                         Errors.create().key(MessageIdList.AREA_ID_AND_EQP_ID_NOT_MATCH)
                               .content("The Area {} does not match EQP ID {}!")
                               .args(MapUtils.getString(map, "data_0"), MapUtils.getString(map, "data_1")).build());


            if (StringUtils.isEqual(StringUtils.BOOLEAN_FALSE, MapUtils.getString(map, "eqpIdFlag"))) {
                Assert.state(!StringUtils.isEqual("inexistence", MapUtils.getString(map, "eqpIdExistFlag")),
                             Errors.create()
                                   .key(MessageIdList.EQUIPMENT_IS_NOT_EXIST)
                                   .content("The EQP is not exist!")
                                   .args().build());

                Assert.state(!StringUtils.isEqual("blank", MapUtils.getString(map, "eqpIdExistFlag")),
                             Errors.create().key(MessageIdList.CAN_NOT_EMPTY)
                                   .content("The {} cannot be empty!")
                                   .args("EQP ID").build());

            }

            if (StringUtils.isEqual(StringUtils.BOOLEAN_FALSE, MapUtils.getString(map, "chamberIdFlag"))) {
                Assert.state(!StringUtils.isEqual("exceed", MapUtils.getString(map, "chamberExistFlag")),
                             Errors.create().key(MessageIdList.CHAMBER_ID_TOO_LONG)
                                   .content("The chamber ID length cannot exceed 1!").args().build());

                Assert.state(!StringUtils.isEqual(StringUtils.BOOLEAN_FALSE, MapUtils.getString(map, "chamberExistFlag")),
                             Errors.create().key(MessageIdList.CHAMBER_ID_AND_EQP_ID_NOT_MATCH)
                                   .content("The Chamber ID {} does not match EQP ID {}!")
                                   .args(MapUtils.getString(map, "data_2"), MapUtils.getString(map, "data_1")).build());

                Assert.state(!StringUtils.isEqual("inexistence", MapUtils.getString(map, "chamberExistFlag")),
                             Errors.create().key(MessageIdList.CHAMBER_IS_NOT_EXIST)
                                   .content("There is no Chamber ID {} under the EQP ID {}")
                                   .args(MapUtils.getString(map, "data_2"), MapUtils.getString(map, "data_1")).build());

            }
            String str =  MapUtils.getString(map, "data_1") + StringUtils.UNDERLINE + MapUtils.getString(map, "data_2");
            if(str.endsWith(StringUtils.UNDERLINE)) {
                str = str.substring(0, str.length() - 1);
            }
            Assert.state(!StringUtils.isEqual(StringUtils.BOOLEAN_FALSE, MapUtils.getString(map, "isExistedFlag")),
                         Errors.create().key(MessageIdList.EQP_ID_IS_REPEAT)
                               .content("The EQP Id {} and Trigger Code {} is repeat!")
                               .args(str, MapUtils.getString(map, "data_3")).build());

            Assert.state(!StringUtils.isEqual(StringUtils.BOOLEAN_FALSE, MapUtils.getString(map, "repeatedExistFlag")),
                         Errors.create().key(MessageIdList.TRIGGER_CODE_TOO_LONG)
                               .content("The trigger code length cannot exceed 128!")
                               .args().build());

            if (StringUtils.isEqual(StringUtils.BOOLEAN_FALSE, MapUtils.getString(map, "triggerCodeFlag"))) {
                Assert.state(!StringUtils.isEqual("blank", MapUtils.getString(map, "triggerCodeExistFlag")),
                             Errors.create().key(MessageIdList.TRIGGER_CODE_CAN_NOT_EMPTY)
                                   .content("The Trigger Code can not be empty!")
                                   .args().build());

                Assert.state(!StringUtils.isEqual(StringUtils.BOOLEAN_FALSE, MapUtils.getString(map, "triggerCodeExistFlag")),
                             Errors.create().key(MessageIdList.TRIGGER_CODE_TOO_LONG)
                                   .content("The trigger code length cannot exceed 128!")
                                   .args().build());

            }
            //Trigger Code Spec验证
            if (StringUtils.isEqual(StringUtils.BOOLEAN_FALSE, MapUtils.getString(map, "triggerCodeSpecFlag"))) {
                Assert.state(!StringUtils.isEqual("blank", MapUtils.getString(map, "triggerCodeSpecExistFlag")),
                             Errors.create().key(MessageIdList.CAN_NOT_EMPTY)
                                   .content("The {} cannot be empty!").args("Trigger Code Spec")
                                   .args().build());

                Assert.state(!StringUtils.isEqual(StringUtils.BOOLEAN_FALSE, MapUtils.getString(map, "triggerCodeSpecFlag")),
                             Errors.create().key(MessageIdList.NOT_NUMBER)
                                   .content("The {} is not number!").args("Trigger Code Spec")
                                   .args().build());
            }
            // 验证Trigger Code Desc
            Assert.state(!StringUtils.isEqual(StringUtils.BOOLEAN_FALSE, MapUtils.getString(map, "triggerCodeDescFlag")),
                         Errors.create().key(MessageIdList.TRIGGER_CODE_DESC_TOO_LONG)
                               .content("The Trigger Code Desc {} length cannot exceed 128!")
                               .args(MapUtils.getString(map, "data_2")).build());

            Assert.state(!StringUtils.isEqual(StringUtils.BOOLEAN_FALSE, MapUtils.getString(map, "UOMFlag")),
                         Errors.create().key(MessageIdList.UOM_TOO_LONG)
                               .content("The UOM length cannot exceed 32!")
                               .args().build());

            EquipmentTriggerMaintainQuery etmq = new EquipmentTriggerMaintainQuery();
            etmq.setChamberId(StringUtils.trimToUpperCase(MapUtils.getString(map, "data_2")));
            etmq.setTriggerCode(MapUtils.getString(map, "data_3"));
            etmq.setTriggerCodeSpec(StringUtils.trimToUpperCase(MapUtils.getString(map, "data_4")));
            etmq.setTriggerCodeDesc(StringUtils.trimToUpperCase(MapUtils.getString(map, "data_5")));
            etmq.setUOM(MapUtils.getString(map, "data_6"));
            etmq.setFacilityRrn(LocalContext.getFacilityRrn());
            etmq.setUserId(LocalContext.getUserId());
            etmq.setUserRrn(LocalContext.getUserRrn());
            etmq.setEquipmentId(StringUtils.trimToUpperCase(MapUtils.getString(map, "data_1")));
            if (!MapUtils.getString(map, "data_1").contains(StringUtils.UNDERLINE) && StringUtils.isNotBlank(MapUtils.getString(map, "data_2"))) {
                etmq.setEquipmentId(StringUtils.trimToUpperCase(MapUtils.getString(map, "data_1")) + StringUtils.UNDERLINE + StringUtils.trimToUpperCase(MapUtils.getString(map, "data_2")));
            }
            Entity entity = emsService.getEntity(
                    new Entity(etmq.getEquipmentId(), getNamedSpace(ObjectList.ENTITY_KEY, LocalContext.getFacilityRrn()), ObjectList.ENTITY_KEY));
            etmq.setEquipmentRrn(entity.getInstanceRrn());
            etmq.setChamberId(getChamberType(entity));
            triggerMaintainQueryList.add(etmq);
        }
        pmsService.addTriggerMaintaiList(triggerMaintainQueryList);
    }

}