DoorPortalAction.java

package com.mycim.webapp.actions.door.doorportal;

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.MapUtils;
import com.mycim.valueobject.MessageIdList;
import com.mycim.valueobject.ObjectList;
import com.mycim.valueobject.SystemConstant;
import com.mycim.valueobject.consts.EventName;
import com.mycim.valueobject.consts.PODConts;
import com.mycim.valueobject.consts.PcdStatus;
import com.mycim.valueobject.ems.Door;
import com.mycim.valueobject.ems.PcdClean;
import com.mycim.valueobject.sys.ReferenceFileDetail;
import com.mycim.webapp.actions.CarrierSetupAction;
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.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Pattern;

public class DoorPortalAction extends CarrierSetupAction {

    public final static int PCD_ID_LENGTH = 7;

    public final static int CLEAN_CYCLE_NUM_SIX = 6;

    public final static String DOOR_ID = "doorId";

    public final static String DOOR_ALLOWABLE_EVENT = "doorAllowableEvent";

    public final static String DOOR_CATEGORY = "doorCategory";

    public final static String DOOR_CLEAN_CYLE = "doorCleanCycle";



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

    public ActionForward doorInfoTab(HttpServletRequest request, ActionMapping mapping) {
        request.setAttribute("pcdId", request.getParameter("doorId"));
        request.setAttribute("transId", "door");
        return mapping.findForward("pcdInfoTab");
    }

    public ActionForward getCommentHistory(HttpServletRequest request, ActionMapping mapping) {
        String user = LocalContext.getUserId();
        long facilityRrn = LocalContext.getFacilityRrn();
        return getCommentHistory(request, mapping, facilityRrn, user, "doorPortal", "getCommentHistory");
    }

    public Map getDoorInfoDetail(Map map) {
        String doorId = map.get("doorId").toString();
        long facilityRrn = LocalContext.getFacilityRrn();
        Map<String, Object> dataMap = new HashMap<String, Object>(10);
        if (StringUtils.isNotBlank(doorId)) {
            String namedSpace = baseService.getNamedSpace(facilityRrn, ObjectList.ENTITY_KEY);
            dataMap = carrierService.getDoorInfoDetailById(doorId, namedSpace);
            PcdClean cleanInfo = carrierService.getPcdCleanInfo(MapUtils.getLong(dataMap, "doorRrn"));
            if (cleanInfo != null && cleanInfo.getInstanceRrn() > 0) {
                dataMap.put("cleanCycle", cleanInfo.getCleanCycle());
                dataMap.put("cleanEqpt", cleanInfo.getCleanEqptId());
            }
            // check是否拥有从当前状态切换为目标状态的权限
            Map<String, Object> btnMap = carrierService
                    .checkPcdChangeStatusButton(facilityRrn, MapUtils.getLong(dataMap, "doorRrn"),
                                                MapUtils.getString(dataMap, "doorStatus"));
            dataMap.put("btnPermissionByEvent", btnMap);
        }
        return dataMap;
    }

    public Map queryDoorByPage(Map map) {
        Map<String, Object> argMap = new HashMap<String, Object>(10);
        long facilityRrn = LocalContext.getFacilityRrn();
        argMap.put("startRow", map.get("start"));
        argMap.put("limit", map.get("limit"));
        argMap.put("doorId", StringUtils.trim(map.get("DOOR").toString()));
        argMap.put("status", StringUtils.trim(map.get("formDoorStatus").toString()));
        argMap.put("type", StringUtils.trim(map.get("formDoorType").toString()));
        argMap.put("category", StringUtils.trim(map.get("formDoorCategory").toString()));
        argMap.put("facility", facilityRrn);
        Map<String, Object> dataMap = new HashMap<String, Object>(20);
        dataMap = carrierService.qryDoorListByPage(argMap);
        return dataMap;
    }

    public Door queryDoorDetail(Map map) {
        String doorId = map.get("doorId").toString();
        long facilityRrn = LocalContext.getFacilityRrn();
        Assert.isFalse(StringUtils.isBlank(doorId),
                       Errors.create().key(MessageIdList.DOOR_ID_CANNOT_EMPTY).content("Door号不能为空!").build());
        long doorRrn = baseService.getNamedObjectRrn(doorId, this.getNamedSpace(ObjectList.ENTITY_KEY, facilityRrn),
                                                     ObjectList.ENTITY_KEY, ObjectList.DOOR_KEY);
        Assert.isFalse(doorRrn < 1, Errors.create().key(MessageIdList.DOOR_DOOR_MISSING).content("Door 不存在").build());
        Door door = carrierService.getDoor(doorRrn);
        PcdClean doorCleanInfo = carrierService.getPcdCleanInfo(door.getInstanceRrn());
        if (doorCleanInfo != null && doorCleanInfo.getInstanceRrn() > 0) {
            door.setCleanCycle(doorCleanInfo.getCleanCycle());
        }
        return door;

    }

    public void delete(Map map) {
        String user = LocalContext.getUserId();
        long facilityRrn = LocalContext.getFacilityRrn();
        String doorId = map.get("winDoorId").toString();
        Assert.isFalse(StringUtils.isBlank(doorId),
                       Errors.create().key(MessageIdList.DOOR_ID_CANNOT_EMPTY).content("Door号不能为空!").build());
        Map<String, Object> resultMap;
        carrierService.deleteDoorEntity(doorId, facilityRrn, user);
    }

    public List<Map> combobxData(HttpServletRequest request) {
        List<Map> list = putDefaultData();
        String type = request.getParameter("type");
        List<ReferenceFileDetail> comboData = queryComboDataList(type);

        for (ReferenceFileDetail detail : comboData) {
            if (SystemConstant.Pcd.CARRIER_TYPE.equalsIgnoreCase(type)) {
                if (StringUtils.isBlank(detail.getData2Value())) {
                    continue;
                }
            }
            Map jo = new HashMap(10);
            if (SystemConstant.Pcd.DOOR_COLOR.equalsIgnoreCase(type)) {
                jo.put("value", detail.getData4Value()); // 实际传递的值
            } else {
                jo.put("value", detail.getKey1Value()); // 实际传递的值
            }
            jo.put("key", detail.getData1Value()); // 显示在页面的值

            list.add(jo);
        }
        return list;
    }

    /**
     * 检查输入的doorid是否已经存在
     *
     * @return
     */
    public Map checkDoor(Map map) {
        long facilityRrn = LocalContext.getFacilityRrn();
        Map result = new HashMap(20);
        String doorId = map.get("winDoorId").toString();
        Assert.isTrue(StringUtils.isNotBlank(doorId),
                      Errors.create().key(MessageIdList.DOOR_ID_CANNOT_EMPTY).content("Door号不能为空!").build());

        doorId = StringUtils.trimToUpperCase(doorId);

        checkNamedObjectIdRule(doorId, "Door");

        long doorRrn = baseService.getNamedObjectRrn(doorId, baseService.getNamedSpace(facilityRrn, ObjectList.ENTITY_KEY),
                                   ObjectList.ENTITY_KEY, ObjectList.DOOR_KEY);
        Assert.isTrue(doorRrn < 1, Errors.create().key(MessageIdList.DOOR_DOOR_ID_EXISTS).content("Door号已存在!").build());

        long namedObjectRrn = baseService.getNamedObjectRrn(doorId, baseService.getNamedSpace(facilityRrn, ObjectList.ENTITY_KEY),
                                   ObjectList.ENTITY_KEY);
        Assert.isTrue(namedObjectRrn < 1,
                      Errors.create().key(MessageIdList.CARRIER_ID_EXISTS).content("系统中已存在此ID").build());

        Map<String, Object> allowableMap = baseService
                .getAllowableEventSetFirst(baseService.getNamedSpace(facilityRrn, ObjectList.ALLOWABLEEVENTSET_KEY),
                                           ObjectList.DOOR_KEY);
        result.put("doorId", doorId);
        result.put("allowableEvent", allowableMap.get("allwoableEventId"));
        return result;
    }

    public void modify(Map map) {
        String user = LocalContext.getUserId();
        long facilityRrn = LocalContext.getFacilityRrn();
        Map<String, Object> attrMap = getRequestParameterMap(map);
        Assert.isFalse(StringUtils.isBlank(MapUtils.getString(attrMap, DOOR_ID)),
                       Errors.create().key(MessageIdList.DOOR_ID_CANNOT_EMPTY).content("Door号不能为空!").build());

        Assert.isFalse(StringUtils.isBlank(MapUtils.getString(attrMap, SystemConstant.Pcd.DOOR_STATUS)),
                       Errors.create().key(MessageIdList.DOOR_DOOR_STATUS_EMPTY).content("Door状态不能为空!").build());

        Assert.isFalse(StringUtils.isBlank(MapUtils.getString(attrMap, SystemConstant.Pcd.DOOR_TYPE)),
                       Errors.create().key(MessageIdList.DOOR_DOOR_TYPE_EMPTY).content("Door类型不能为空!").build());

        Assert.isFalse(StringUtils.isBlank(MapUtils.getString(attrMap, DOOR_ALLOWABLE_EVENT)),
                       Errors.create().key(MessageIdList.CARRIER_ALLOWABLE_EVENT_EMPTY).content("允许事件集号不能为空!").build());

        Assert.isFalse(StringUtils.isBlank(MapUtils.getString(attrMap, DOOR_CATEGORY)),
                       Errors.create().key(MessageIdList.DOOR_DOOR_CATEGORY_EMPTY).content("Door类别不能为空!").build());

        Assert.isFalse(StringUtils.isBlank(MapUtils.getString(attrMap, DOOR_CLEAN_CYLE)),
                       Errors.create().key(MessageIdList.CARRIER_CLEAN_CYCLE_EMPTY).content("清洗周期不能为空!").build());

        String doorCleanCycle = MapUtils.getString(attrMap, DOOR_CLEAN_CYLE);
        Assert.isFalse(StringUtils.length(doorCleanCycle) > CLEAN_CYCLE_NUM_SIX,
                       Errors.create().key(MessageIdList.CARRIER_CLEAN_LENGTH_EXCEED_SIX).content("清洗周期不能超过6位数!")
                             .build());

        // 修改操作
        long doorRrn = baseService.getNamedObjectRrn(MapUtils.getString(attrMap, "doorId"),
                                                     baseService.getNamedSpace(facilityRrn, ObjectList.ENTITY_KEY),
                                                     ObjectList.ENTITY_KEY, ObjectList.DOOR_KEY);

        Assert.isTrue(doorRrn > 0, Errors.create().key(MessageIdList.DOOR_DOOR_MISSING).content("Door 不存在").build());

        Door door = carrierService.getDoor(doorRrn);
        Assert.isTrue(StringUtils.isNotBlank(door.getDoorStatus()) &&
                              StringUtils.equalsIgnoreCase(door.getDoorStatus(), PcdStatus.FREE_KEY),
                      Errors.create().key(MessageIdList.DOOR_FREE_STATUS_CAN_MODIFY).content("只有FREE状态的Door才能修改！")
                            .build());
        attrMap.put("doorRrn", doorRrn);
        carrierService.updateDoorEntity(attrMap, facilityRrn, user);
    }

    private Map<String, Object> getRequestParameterMap(Map paramMap) {
        Map<String, Object> map = new HashMap<String, Object>();
        map.put("doorId", paramMap.get("winDoorId"));
        map.put("doorDesc", paramMap.get("winDoorDesc"));
        map.put("doorStatus", paramMap.get("winDoorStatus"));
        map.put("doorType", paramMap.get("winDoorType"));
        map.put("doorColor", paramMap.get("winDoorColor"));
        map.put("doorPosition", paramMap.get("winDoorLocation"));
        map.put("doorSlotCount", paramMap.get("winSlotCount"));
        map.put("doorPollutionLevel", paramMap.get("winDoorPollutionLevel"));
        map.put("doorAllowableEvent", paramMap.get("winDoorAllowableEvent"));
        map.put("doorEngineerGroupID", paramMap.get("winDoorEngineerGroupID"));
        map.put("doorCategory", paramMap.get("winDoorCategory"));
        map.put("doorCleanCycle", paramMap.get("winDoorCleanCycle"));
        return map;
    }

    public void save(Map map) {
        String user = LocalContext.getUserId();
        long facilityRrn = LocalContext.getFacilityRrn();
        Map<String, Object> attrMap = getRequestParameterMap(map);
        String doorId;
        Assert.isFalse(StringUtils.isBlank(doorId = MapUtils.getString(attrMap, DOOR_ID)),
                       Errors.create().key(MessageIdList.DOOR_ID_CANNOT_EMPTY).content("Door号不能为空!").build());

        Assert.isFalse(StringUtils.isBlank(MapUtils.getString(attrMap, SystemConstant.Pcd.DOOR_STATUS)),
                       Errors.create().key(MessageIdList.DOOR_DOOR_STATUS_EMPTY).content("Door状态不能为空!").build());

        Assert.isFalse(StringUtils.isBlank(MapUtils.getString(attrMap, SystemConstant.Pcd.DOOR_TYPE)),
                       Errors.create().key(MessageIdList.DOOR_DOOR_TYPE_EMPTY).content("Door类型不能为空!").build());

        Assert.isFalse(StringUtils.isBlank(MapUtils.getString(attrMap, DOOR_ALLOWABLE_EVENT)),
                       Errors.create().key(MessageIdList.CARRIER_ALLOWABLE_EVENT_EMPTY).content("允许事件集号不能为空!").build());

        Assert.isFalse(StringUtils.isBlank(MapUtils.getString(attrMap, DOOR_CATEGORY)),
                       Errors.create().key(MessageIdList.DOOR_DOOR_CATEGORY_EMPTY).content("Door类别不能为空!").build());

        Assert.isFalse(StringUtils.isBlank(MapUtils.getString(attrMap, DOOR_CLEAN_CYLE)),
                       Errors.create().key(MessageIdList.CARRIER_CLEAN_CYCLE_EMPTY).content("清洗周期不能为空!").build());

        String doorCleanCycle = MapUtils.getString(attrMap, DOOR_CLEAN_CYLE);
        Assert.isFalse(StringUtils.length(doorCleanCycle) > CLEAN_CYCLE_NUM_SIX,
                       Errors.create().key(MessageIdList.CARRIER_CLEAN_LENGTH_EXCEED_SIX).content("清洗周期不能超过6位数!")
                             .build());

        checkNamedObjectIdRule(doorId, "Door");

        long doorRrn = baseService.getNamedObjectRrn(MapUtils.getString(attrMap, "doorId"),
                                                     baseService.getNamedSpace(facilityRrn, ObjectList.ENTITY_KEY),
                                                     ObjectList.ENTITY_KEY, ObjectList.DOOR_KEY);

        Assert.isTrue(doorRrn < 1, Errors.create().key(MessageIdList.DOOR_DOOR_ID_EXISTS).content("Door号已存在!").build());
        long namedObjectRrn = baseService.getNamedObjectRrn(MapUtils.getString(attrMap, "doorId"), baseService
                .getNamedSpace(facilityRrn, ObjectList.ENTITY_KEY), ObjectList.ENTITY_KEY);
        Assert.isTrue(namedObjectRrn < 1,
                      Errors.create().key(MessageIdList.CARRIER_ID_EXISTS).content("系统中已存在此ID!").build());
        carrierService.addDoorEntity(attrMap, facilityRrn, user);
        initStatusByEvent(facilityRrn, user, MapUtils.getString(attrMap, "doorId"), ObjectList.DOOR_KEY,
                          EventName.INIT_DOOR);
    }

    public Map<String,Object> generateDoorId(Map<String,Object> param){
        String type = org.apache.commons.collections.MapUtils.getString(param, "type");
        String doorId = generatePCDId(SystemConstant.Pcd.DOOR, type);
        return new HashMap<String,Object>(){{
            put("doorId", doorId);
        }};
    }

}