package cn.ksource.web;
|
|
import cn.ksource.config.SysConfigConstants;
|
import redis.clients.jedis.Client;
|
|
import java.io.IOException;
|
import java.io.InputStreamReader;
|
import java.util.HashMap;
|
import java.util.LinkedHashMap;
|
import java.util.Map;
|
import java.util.Properties;
|
|
public class Constants {
|
|
public final static String APP_CONF_FILE = "app.properties";
|
public final static String GG_SMS_URL= "http://yunpian.com/v1/sms/send.json";
|
public final static String GG_SMS_KEY= "faf531146ca1e38abacd3862fb3fc32b";
|
public final static String CFG_ADMIN_ID= "4a932b18ff9c42ee81032953455f50c3";
|
public final static String AES_PWD= "63661766";
|
|
public final static String ROLE_YWADMIN = "SYSADMIN";
|
public final static String ROLE_LEADER = "LEADER";
|
public final static String ROLE_SERVICE = "SERVICE";
|
public final static String ROLE_FLINE = "FLINE";
|
public final static String ROLE_SLINE = "SLINE";
|
public final static String ROLE_TLINE = "TLINE";
|
public final static String ROLE_LOCATION = "LOCATION";
|
public final static String ROLE_OPERATION = "OPERATION";
|
public final static String ROLE_CGFADMIN = "CGFADMIN";
|
public final static String ROLE_KNOW = "KNOW";
|
public final static String ROLE_MANAGE = "MANAGE";
|
public final static String RKSH_REFUSE = "SLINE";
|
|
public final static Map<String, String> INDEX_MAP = new LinkedHashMap<String, String>();
|
static {
|
INDEX_MAP.put("SYSADMIN", "/business/pages/desktop/sysmanager.html");//超级管理员
|
INDEX_MAP.put("LEADER", "/business/pages/desktop/leaderDesk.html");//领导
|
INDEX_MAP.put("SERVICE", "/business/pages/desktop/serviceDesk.html");//服务台
|
INDEX_MAP.put("FLINE", "/business/pages/desktop/flineDesk.html");//一线
|
INDEX_MAP.put("SLINE", "/business/pages/desktop/slineDesk.html");//二线
|
INDEX_MAP.put("TLINE", "/business/pages/desktop/tlineDesk.html");//三线
|
INDEX_MAP.put("LOCATION", "/business/pages/desktop/locationDesk.html");//驻场
|
INDEX_MAP.put("OPERATION", "/business/pages/desktop/operationDesk.html");//运维经理
|
INDEX_MAP.put("CGFADMIN", "/business/pages/desktop/cfgDesk.html");//配置管理员
|
INDEX_MAP.put("KNOW", "/business/pages/desktop/knowDesk.html");//知识管理员
|
INDEX_MAP.put("MANAGE", "/business/pages/desktop/manageDesk.html");//管理层
|
}
|
public final static String getINDEX(String key) {
|
return INDEX_MAP.get(key);
|
}
|
|
public final static int GG_XTGN_TYPE_YJCD = 1;
|
public final static int GG_XTGN_TYPE_EJCD = 2;
|
public final static int GG_XTGN_TYPE_SJCD = 3;
|
public final static int GG_XTGN_TYPE_YMYS = 4;
|
|
public final static Map<Integer, String> GG_XTGN_TYPE_Map = new LinkedHashMap<Integer, String>();
|
|
static {
|
GG_XTGN_TYPE_Map.put(GG_XTGN_TYPE_YJCD, "一级菜单");
|
GG_XTGN_TYPE_Map.put(GG_XTGN_TYPE_EJCD, "二级菜单");
|
GG_XTGN_TYPE_Map.put(GG_XTGN_TYPE_SJCD, "三级菜单");
|
GG_XTGN_TYPE_Map.put(GG_XTGN_TYPE_YMYS, "页面元素");
|
}
|
|
public final static String getGG_XTGN_TYPE_Label(int i) {
|
return GG_XTGN_TYPE_Map.get(i);
|
}
|
|
//公司名称
|
private static String loadProps(){
|
Properties prop = new Properties();
|
String value ="";
|
try {
|
prop.load(new InputStreamReader(Client.class.getResourceAsStream("/app.properties"),"UTF-8"));
|
value = prop.get("company.name").toString();
|
}catch (IOException e){
|
System.out.println(e.getMessage());
|
}
|
return value;
|
}
|
public static String company_name = loadProps();
|
public static String company_tell = loadPropsTell();
|
//公司名称电话
|
private static String loadPropsTell(){
|
Properties prop = new Properties();
|
String value ="";
|
try {
|
prop.load(new InputStreamReader(Client.class.getResourceAsStream("/app.properties"),"UTF-8"));
|
value = prop.get("company.tell").toString();
|
}catch (IOException e){
|
System.out.println(e.getMessage());
|
}
|
return value;
|
}
|
|
//事件消息web页面链接（相对路径）
|
public final static String INCIDENT_WEB_MSG_URL = "/business/pages/incident/incidentDetail.html";
|
//事件消息微信页面链接（绝对路径）
|
|
//问题消息web页面链接（相对路径）
|
public final static String QUESTION_WEB_MSG_URL = "/business/pages/question/questionDetail.html";
|
|
// 链接分类树;
|
|
public static final String TOP_ID = "-1";
|
|
public static final String splitMark = "@";
|
|
/**
|
* 例行维护提醒项等级数据字典
|
*/
|
public final static String REMIND_ITEM_PRIORITY_LEVEL="REMIND_ITEM_PRIORITY_LEVEL";
|
|
/**
|
* CI基本属性扩展表
|
*/
|
public static final String CMDB_CI_BASE_EXTEND_TABLE="CMDB_CI_BASE_EXTEND";
|
|
/**
|
* 子CI基本属性扩展表
|
*/
|
public static final String CMDB_SUB_CI_BASE_EXTEND_TABLE="CMDB_CI_SUB_BASE_EXTEND";
|
/**
|
* 数字
|
*/
|
public final static int CMDB_CI_EXTEND_COLUMN_DATATYPE_NUMBER = 1;
|
/**
|
* 字符串
|
*/
|
public final static int CMDB_CI_EXTEND_COLUMN_DATATYPE_STRING = 2;
|
/**
|
* 长文本
|
*/
|
public final static int CMDB_CI_EXTEND_COLUMN_DATATYPE_TEXT = 3;
|
/**
|
* 时间
|
*/
|
public final static int CMDB_CI_EXTEND_COLUMN_DATATYPE_DATE = 4;
|
/**
|
* 单选
|
*/
|
public final static int CMDB_CI_EXTEND_COLUMN_DATATYPE_SINGLE_SELECT = 5;
|
/**
|
* 多选
|
*/
|
public final static int CMDB_CI_EXTEND_COLUMN_DATATYPE_MULTI_SELECT = 6;
|
|
public final static Map<String, String> CMDB_CI_EXTEND_COLUMN_DATATYPE_Map = new LinkedHashMap<String, String>();
|
static {
|
CMDB_CI_EXTEND_COLUMN_DATATYPE_Map.put(String.valueOf(CMDB_CI_EXTEND_COLUMN_DATATYPE_NUMBER), "数字");
|
CMDB_CI_EXTEND_COLUMN_DATATYPE_Map.put(String.valueOf(CMDB_CI_EXTEND_COLUMN_DATATYPE_STRING), "字符串");
|
CMDB_CI_EXTEND_COLUMN_DATATYPE_Map.put(String.valueOf(CMDB_CI_EXTEND_COLUMN_DATATYPE_TEXT), "长文本");
|
CMDB_CI_EXTEND_COLUMN_DATATYPE_Map.put(String.valueOf(CMDB_CI_EXTEND_COLUMN_DATATYPE_DATE), "时间");
|
CMDB_CI_EXTEND_COLUMN_DATATYPE_Map.put(String.valueOf(CMDB_CI_EXTEND_COLUMN_DATATYPE_SINGLE_SELECT), "单选");
|
CMDB_CI_EXTEND_COLUMN_DATATYPE_Map.put(String.valueOf(CMDB_CI_EXTEND_COLUMN_DATATYPE_MULTI_SELECT), "多选");
|
}
|
public static String getCMDB_CI_EXTEND_COLUMN_DATATYPE_Label(String key){
|
return CMDB_CI_EXTEND_COLUMN_DATATYPE_Map.get(key);
|
}
|
|
|
/**
|
* 事件管理环节流转配置
|
*/
|
public final static String KFRY = "0ae2eeedb6804203bb6f32a371e418eb"; //客服人员
|
public final static String YCJSZC = "4d385dc3c3bd4a57a73a93625a3cc128"; //运维经理
|
public final static String YXCL = "f5e37e27484a414594ff9064f4e99f47"; //一线工程师
|
public final static String EXCL = "4830d361bebd49b58fe87fa28e7560f7"; //二线工程师
|
public final static String SXCL = "f886ad06b38b483da47a961b46ccb936"; //三线工程师
|
|
|
public static final Map<String, String> incidentNode = new LinkedHashMap<String, String>();
|
static {
|
incidentNode.put(KFRY, "客服人员");
|
incidentNode.put(YCJSZC, "运维经理");
|
incidentNode.put(YXCL, "一线工程师");
|
incidentNode.put(EXCL, "二线工程师");
|
incidentNode.put(SXCL, "三线工程师");
|
}
|
public static String getIncidentNodeLabel(String key) {
|
return incidentNode.get(key);
|
}
|
|
/**
|
* 入库管理环节流转配置
|
*/
|
public final static String RKSQ = "a908ebcaf9014ef59809ff834aae47c1"; //入库申请
|
public final static String RKSP = "a908ebcaf9014ef59809ff834aae47c2"; //入库审批
|
|
public static final Map<String, String> stockNode = new LinkedHashMap<String, String>();
|
static {
|
stockNode.put(KFRY, "入库申请");
|
stockNode.put(YCJSZC, "入库审批");
|
}
|
public static String getStockNodeLabel(String key) {
|
return incidentNode.get(key);
|
}
|
/**
|
* 备件申领环节流转配置
|
*/
|
public final static String BJSLSQ = "a908ebcaf9014ef59809ff834aae4723"; //备件申领申请
|
public final static String BJSLSP = "a908ebcaf9014ef59809ff834aae4724"; //备件申领申批
|
|
public static final Map<String, String> spareNode = new LinkedHashMap<String, String>();
|
static {
|
spareNode.put(BJSLSQ, "备件申请");
|
spareNode.put(BJSLSP, "备件审核");
|
}
|
public static String getspareNodeLabel(String key) {
|
return incidentNode.get(key);
|
}
|
/**
|
* 节点对应的字段
|
* @param key
|
* @return
|
*/
|
public static final Map<String, String> incidentNodeColunm = new HashMap<String, String>();
|
static {
|
incidentNodeColunm.put(KFRY, "KFRY");
|
incidentNodeColunm.put(YCJSZC, "YCJSZC");
|
incidentNodeColunm.put(YXCL, "YXGCS");
|
incidentNodeColunm.put(EXCL, "EXGCS");
|
incidentNodeColunm.put(SXCL, "SXGCS");
|
}
|
|
/**
|
* 问题管理环节流转配置
|
*/
|
public final static String WTFQ = "bfb0a3560dc8478bbbe10ecc6b8dc592"; //问题发起
|
public final static String WTSL = "c327d8aa1b314a5a9b37dfa313e4db17"; //问题受理
|
public final static String WTSH = "346f65a623e64ee197c7ef514170ae4e"; //问题审核
|
public final static String WTZD = "666f4b5c631247a1ba473d450f2146b3"; //问题诊断
|
public final static String WTFASP = "401ed1b45ce44c0eadaf861f9462e0b4"; //方案审批
|
public final static String WTFASS = "54b33f8a7680451cb78badbad08915fd"; //方案实施
|
public final static String WTHG = "a3ffc9d274b64ab390e343a6f221d7e6"; //问题回顾
|
|
|
public static final Map<String, String> questionNode = new LinkedHashMap<String, String>();
|
static {
|
questionNode.put(WTFQ, "问题发起");
|
questionNode.put(WTSL, "问题受理");
|
questionNode.put(WTSH, "问题审核");
|
questionNode.put(WTZD, "问题诊断");
|
questionNode.put(WTFASP, "方案审批");
|
questionNode.put(WTFASS, "方案实施");
|
questionNode.put(WTHG, "问题回顾");
|
}
|
|
public static String getquestionNodeLabel(String key) {
|
return questionNode.get(key);
|
}
|
|
/**
|
* 节点对应的字段
|
* @param key
|
* @return
|
*/
|
public static final Map<String, String> questionNodeColunm = new HashMap<String, String>();
|
static {
|
questionNodeColunm.put(WTFQ, "WTFQ");
|
questionNodeColunm.put(WTSL, "WTSL");
|
questionNodeColunm.put(WTSH, "WTSH");
|
questionNodeColunm.put(WTZD, "WTZD");
|
questionNodeColunm.put(WTFASP, "FASP");
|
questionNodeColunm.put(WTFASS, "FASS");
|
questionNodeColunm.put(WTHG, "WTHG");
|
}
|
/**
|
* 模板类型（1=响应支持类；2=预防性维护类；3=驻场服务类；4=综合类满意度）
|
*/
|
public final static String CUSTOMER_SATIS_TEMPLATE_TEMPLATE_TYPE_ONE = "1";
|
public final static String CUSTOMER_SATIS_TEMPLATE_TEMPLATE_TYPE_TWO = "2";
|
public final static String CUSTOMER_SATIS_TEMPLATE_TEMPLATE_TYPE_THREE = "3";
|
public final static String CUSTOMER_SATIS_TEMPLATE_TEMPLATE_TYPE_FOUR = "4";
|
public final static String CUSTOMER_SATIS_TEMPLATE_TEMPLATE_TYPE_FIVE = "5";
|
public final static String CUSTOMER_SATIS_TEMPLATE_TEMPLATE_TYPE_SIX = "6";
|
|
/**
|
* 服务级别状态
|
*/
|
public final static String SC_SLA_TEMPLATE_STATE_OPEN = "1";
|
public final static String SC_SLA_TEMPLATE_STATE_CLOSE = "2";
|
|
public static final Map<String, String> mapSC_SLA_TEMPLATE_STATE = new LinkedHashMap<String, String>();
|
static {
|
mapSC_SLA_TEMPLATE_STATE.put(SC_SLA_TEMPLATE_STATE_OPEN.toString(), "启用");
|
mapSC_SLA_TEMPLATE_STATE.put(SC_SLA_TEMPLATE_STATE_CLOSE.toString(), "禁用");
|
}
|
|
public static String getmapmapSC_SLA_TEMPLATE_STATE_Label(String key) {
|
return mapSC_SLA_TEMPLATE_STATE.get(key);
|
}
|
|
/**
|
* 客户联系人重要等级
|
*/
|
public final static String PROJECT_CONSTACTS="ZY_LEVEL";
|
|
public static final Map<String, String> mapCUSTOMER_SATIS_TEMPLATE_TEMPLATE_TYPE = new LinkedHashMap<String, String>();
|
static {
|
mapCUSTOMER_SATIS_TEMPLATE_TEMPLATE_TYPE.put(CUSTOMER_SATIS_TEMPLATE_TEMPLATE_TYPE_ONE.toString(), "事件响应支持类");
|
mapCUSTOMER_SATIS_TEMPLATE_TEMPLATE_TYPE.put(CUSTOMER_SATIS_TEMPLATE_TEMPLATE_TYPE_THREE.toString(), "驻场服务类");
|
mapCUSTOMER_SATIS_TEMPLATE_TEMPLATE_TYPE.put(CUSTOMER_SATIS_TEMPLATE_TEMPLATE_TYPE_SIX.toString(), "驻场响应支持类");
|
}
|
|
public static String getmapCUSTOMER_SATIS_TEMPLATE_TEMPLATE_TYPE_Label(String key) {
|
return mapCUSTOMER_SATIS_TEMPLATE_TEMPLATE_TYPE.get(key);
|
}
|
|
/**
|
* 满意度模板状态（0=待用；1：启用；2：禁用）
|
*/
|
public final static String CUSTOMER_SATIS_TEMPLATE_STATE_ZERO = "0";
|
public final static String CUSTOMER_SATIS_TEMPLATE_STATE_ONE = "1";
|
public final static String CUSTOMER_SATIS_TEMPLATE_STATE_TWO = "2";
|
|
public static final Map<String, String> mapCUSTOMER_SATIS_TEMPLATE_STATE = new LinkedHashMap<String, String>();
|
static {
|
mapCUSTOMER_SATIS_TEMPLATE_STATE.put(CUSTOMER_SATIS_TEMPLATE_STATE_ZERO.toString(), "待用");
|
mapCUSTOMER_SATIS_TEMPLATE_STATE.put(CUSTOMER_SATIS_TEMPLATE_STATE_ONE.toString(), "启用");
|
mapCUSTOMER_SATIS_TEMPLATE_STATE.put(CUSTOMER_SATIS_TEMPLATE_STATE_TWO.toString(), "禁用");
|
}
|
|
public static String getmapCUSTOMER_SATIS_TEMPLATE_STATE_Label(String key) {
|
return mapCUSTOMER_SATIS_TEMPLATE_STATE.get(key);
|
}
|
|
/**
|
* 维保项类型，1=通用;2=定制;
|
*/
|
public final static Integer WBX_ITEM_TYPE_COMMON = 1;
|
public final static Integer WBX_ITEM_TYPE_CUSTOMIZE = 2;
|
|
public static final Map<String, String> mapWBX_ITEM_TYPE = new LinkedHashMap<String, String>();
|
static {
|
mapWBX_ITEM_TYPE.put(WBX_ITEM_TYPE_COMMON.toString(), "通用");
|
mapWBX_ITEM_TYPE.put(WBX_ITEM_TYPE_CUSTOMIZE.toString(), "定制");
|
}
|
|
public static String getmapWBX_ITEM_TYPE_Label(String key) {
|
return mapWBX_ITEM_TYPE.get(key);
|
}
|
|
|
|
|
/**
|
* 自定义属性类型
|
*/
|
public final static Integer PROP_TYPE_NUMBER = 1;//数字
|
public final static Integer PROP_TYPE_STRING = 2;//字符串
|
public final static Integer PROP_TYPE_TEXT = 3;//长文本
|
public final static Integer PROP_TYPE_DATE = 4;//时间
|
public final static Integer PROP_TYPE_SEL = 5;//单选
|
public final static Integer YSY_TYPE_MULTI_SEL = 6;//多选
|
public final static Map<Integer, String> PROP_TYPE_MAP = new LinkedHashMap<Integer, String>();
|
static {
|
PROP_TYPE_MAP.put(PROP_TYPE_NUMBER, "数字");
|
PROP_TYPE_MAP.put(PROP_TYPE_STRING, "字符串");
|
PROP_TYPE_MAP.put(PROP_TYPE_TEXT, "长文本");
|
PROP_TYPE_MAP.put(PROP_TYPE_DATE, "时间");
|
PROP_TYPE_MAP.put(PROP_TYPE_SEL, "单选");
|
PROP_TYPE_MAP.put(YSY_TYPE_MULTI_SEL, "多选");
|
}
|
public static String getPROP_TYPE(int key){
|
return PROP_TYPE_MAP.get(key);
|
}
|
|
//是否允许为空
|
public final static int PROP_ALLOWNULL_Y = 1;//是
|
public final static int PROP_ALLOWNULL_N = 2;//否
|
public final static Map<Integer, String> PROP_ALLOWNULL_MAP = new LinkedHashMap<Integer, String>();
|
static {
|
PROP_ALLOWNULL_MAP.put(PROP_ALLOWNULL_Y, "是");
|
PROP_ALLOWNULL_MAP.put(PROP_ALLOWNULL_N, "否");
|
}
|
public static String getPROP_ALLOWNULL(Integer key){
|
return PROP_ALLOWNULL_MAP.get(key);
|
}
|
|
//是否列表显示
|
public final static int PROP_SHOWINLIST_Y = 1;//是
|
public final static int PROP_SHOWINLIST_N = 2;//否
|
public final static Map<Integer, String> PROP_SHOWINLIST_MAP = new LinkedHashMap<Integer, String>();
|
static {
|
PROP_SHOWINLIST_MAP.put(PROP_SHOWINLIST_Y, "是");
|
PROP_SHOWINLIST_MAP.put(PROP_SHOWINLIST_N, "否");
|
}
|
public static String getPROP_SHOWINLIST(Integer key){
|
return PROP_SHOWINLIST_MAP.get(key);
|
}
|
|
//是否查询条件
|
public final static int PROP_ALLOWQUERY_Y = 1;//是
|
public final static int PROP_ALLOWQUERY_N = 2;//否
|
public final static Map<Integer, String> PROP_ALLOWQUERY_MAP = new LinkedHashMap<Integer, String>();
|
static {
|
PROP_ALLOWQUERY_MAP.put(PROP_ALLOWQUERY_Y, "是");
|
PROP_ALLOWQUERY_MAP.put(PROP_ALLOWQUERY_N, "否");
|
}
|
public static String getPROP_ALLOWQUERY(Integer key){
|
return PROP_ALLOWQUERY_MAP.get(key);
|
}
|
|
//输入类型
|
public final static int PROP_INPUTTYPE_INPUT = 1;//手工输入
|
public final static int PROP_INPUTTYPE_SELECT = 2;//列表选择
|
public final static Map<Integer, String> PROP_INPUTTYPE_MAP = new LinkedHashMap<Integer, String>();
|
static {
|
PROP_INPUTTYPE_MAP.put(PROP_INPUTTYPE_INPUT, "手工输入");
|
PROP_INPUTTYPE_MAP.put(PROP_INPUTTYPE_SELECT, "列表选择");
|
}
|
public static String getPROP_INPUTTYPE(Integer key){
|
return PROP_INPUTTYPE_MAP.get(key);
|
}
|
|
/**
|
* SLA通知人员类型
|
*/
|
public final static String SC_SLA_USER_NOTICE_TYPE_ANSWER_OVERTIME = "1";
|
public final static String SC_SLA_USER_NOTICE_TYPE_RESOLVE_OVERTIME = "2";
|
|
public static final Map<String, String> mapSC_SLA_USER_NOTICE_TYPE = new LinkedHashMap<String, String>();
|
static {
|
mapSC_SLA_USER_NOTICE_TYPE.put(SC_SLA_USER_NOTICE_TYPE_ANSWER_OVERTIME.toString(), "响应超时通知");
|
mapSC_SLA_USER_NOTICE_TYPE.put(SC_SLA_USER_NOTICE_TYPE_RESOLVE_OVERTIME.toString(), "解决超时通知");
|
}
|
|
public static String getmapSC_SLA_USER_NOTICE_TYPE_Label(String key) {
|
return mapSC_SLA_USER_NOTICE_TYPE.get(key);
|
}
|
|
/**
|
* 厂商集成商类型
|
*/
|
public static Integer CMDB_MAINUFACTURER_CS = 1;
|
public static Integer CMDB_MAINUFACTURER_JCS = 2;
|
|
public static Map<String,String> CMDB_MAINUFACTURER_MAP = new LinkedHashMap<String, String>();
|
|
static {
|
CMDB_MAINUFACTURER_MAP.put(String.valueOf(CMDB_MAINUFACTURER_CS), "厂商");
|
CMDB_MAINUFACTURER_MAP.put(String.valueOf(CMDB_MAINUFACTURER_JCS), "集成商");
|
}
|
|
public static String getCMDB_MAINUFACTURER_MAP(String key){
|
return CMDB_MAINUFACTURER_MAP.get(key);
|
}
|
|
/**
|
* 厂商联系人重要等级
|
*/
|
public static Integer CMDB_CONTACTS_LEVELONE=1;
|
public static Integer CMDB_CONTACTS_LEVELTWO=2;
|
public static Integer CMDB_CONTACTS_LEVELTHREE=3;
|
|
public static Map<String,String> CMDB_CONTACTS_LEVEL_MAP=new LinkedHashMap<String, String>();
|
static{
|
CMDB_CONTACTS_LEVEL_MAP.put(String.valueOf(CMDB_CONTACTS_LEVELONE), "高");
|
CMDB_CONTACTS_LEVEL_MAP.put(String.valueOf(CMDB_CONTACTS_LEVELTWO), "中");
|
CMDB_CONTACTS_LEVEL_MAP.put(String.valueOf(CMDB_CONTACTS_LEVELTHREE), "低");
|
}
|
public static String getCMDB_CONTACTS_LEVEL_MAP(String key){
|
return CMDB_CONTACTS_LEVEL_MAP.get(key);
|
}
|
|
|
//配置状态
|
//public final static int CFG_STATE_W = 0;//未启用
|
public final static int CFG_STATE_Z = 1;//正常
|
public final static int CFG_STATE_F = 2;//禁用
|
/* public final static int CFG_STATE_F = 2;//废弃
|
public final static int CFG_STATE_H = 3;//维护中
|
public final static int CFG_STATE_B = 4;//备用
|
*/ public final static Map<Integer, String> CFG_STATE_MAP = new LinkedHashMap<Integer, String>();
|
static {
|
//CFG_STATE_MAP.put(CFG_STATE_W, "未启用");
|
CFG_STATE_MAP.put(CFG_STATE_Z, "正常");
|
CFG_STATE_MAP.put(CFG_STATE_F, "禁用");
|
/*CFG_STATE_MAP.put(CFG_STATE_F, "废弃");
|
CFG_STATE_MAP.put(CFG_STATE_H, "维护中");
|
CFG_STATE_MAP.put(CFG_STATE_B, "备用");*/
|
}
|
public static String getCFG_STATE(Integer key){
|
return CFG_STATE_MAP.get(key);
|
}
|
|
/**
|
* 客户账户，1：启用;2:禁用;
|
*/
|
public final static Integer SC_PARTNER_CUSTOMER_INFO_STATE_ENABLE = 1;
|
public final static Integer SC_PARTNER_CUSTOMER_INFO_STATE_DISABLE = 2;
|
|
public static final Map<String, String> mapSC_PARTNER_CUSTOMER_INFO_STATE = new LinkedHashMap<String, String>();
|
static {
|
mapSC_PARTNER_CUSTOMER_INFO_STATE.put(SC_PARTNER_CUSTOMER_INFO_STATE_ENABLE.toString(), "启用");
|
mapSC_PARTNER_CUSTOMER_INFO_STATE.put(SC_PARTNER_CUSTOMER_INFO_STATE_DISABLE.toString(), "禁用");
|
}
|
|
public static String getComSC_PARTNER_CUSTOMER_INFO_Label(String key) {
|
return mapSC_PARTNER_CUSTOMER_INFO_STATE.get(key);
|
}
|
|
/**
|
* 客户账号状态，1：启用;2:禁用;
|
*/
|
public final static Integer SC_PARTNER_CUSTOMER_ACCOUNT_STATE_ENABLE = 1;
|
public final static Integer SC_PARTNER_CUSTOMER_ACCOUNT_STATE_DISABLE = 2;
|
|
public static final Map<String, String> mapSC_PARTNER_CUSTOMER_ACCOUNT = new LinkedHashMap<String, String>();
|
static {
|
mapSC_PARTNER_CUSTOMER_ACCOUNT.put(SC_PARTNER_CUSTOMER_ACCOUNT_STATE_ENABLE.toString(), "启用");
|
mapSC_PARTNER_CUSTOMER_ACCOUNT.put(SC_PARTNER_CUSTOMER_ACCOUNT_STATE_DISABLE.toString(), "禁用");
|
}
|
|
public static String getComSC_PARTNER_CUSTOMER_ACCOUNT_Label(String key) {
|
return mapSC_PARTNER_CUSTOMER_ACCOUNT.get(key);
|
}
|
|
/**
|
* 过保状态【1.一周内过保 2.两周内过保 3.一个月内过保 4.三个月内过保 5.已过保】
|
*/
|
public final static int CFG_GB_STATE_YZN = 1;//一周内过保
|
public final static int CFG_GB_STATE_LZN = 2;//两周内过保
|
public final static int CFG_GB_STATE_YGY = 3;//一个月内过保
|
public final static int CFG_GB_STATE_SGY = 4;//三个月内过保
|
public final static int CFG_GB_STATE_YGB = 5;//已过保
|
public final static int CFG_GB_STATE_ZDY = 6;//已过保
|
public final static Map<Integer, String> CFG_GB_STATE_MAP = new LinkedHashMap<Integer, String>();
|
static {
|
CFG_GB_STATE_MAP.put(CFG_GB_STATE_YZN, "一周内过保");
|
CFG_GB_STATE_MAP.put(CFG_GB_STATE_LZN, "两周内过保");
|
CFG_GB_STATE_MAP.put(CFG_GB_STATE_YGY, "一个月内过保");
|
CFG_GB_STATE_MAP.put(CFG_GB_STATE_SGY, "三个月内过保");
|
CFG_GB_STATE_MAP.put(CFG_GB_STATE_YGB, "已过保");
|
CFG_GB_STATE_MAP.put(CFG_GB_STATE_ZDY, "自定义");
|
}
|
public static String getCFG_GB_STATE(Integer key){
|
return CFG_GB_STATE_MAP.get(key);
|
}
|
|
//配置流程状态
|
public final static Integer CFG_FLOW_SC = 0;//删除
|
public final static Integer CFG_FLOW_XZ = 1;//新增
|
public final static Integer CFG_FLOW_DSH = 2;//待审核
|
public final static Integer CFG_FLOW_SB = 3;//审核失败
|
public final static Integer CFG_FLOW_WC = 4;//已审核
|
public final static Map<Integer, String> CFG_FLOW_MAP = new LinkedHashMap<Integer, String>();
|
static {
|
CFG_FLOW_MAP.put(CFG_FLOW_XZ, "新增");
|
CFG_FLOW_MAP.put(CFG_FLOW_DSH, "待审核");
|
CFG_FLOW_MAP.put(CFG_FLOW_SB, "审核失败");
|
CFG_FLOW_MAP.put(CFG_FLOW_WC, "已审核");
|
}
|
public static String getCFG_FLOW(Integer key){
|
return CFG_FLOW_MAP.get(key);
|
}
|
|
/**
|
* CI_DAILY_PATROL状态
|
* 状态（0=删除 1=新建；2=待审批；3=审批通过；4=审批未通过）
|
* */
|
public final static Integer CI_DAILY_PATROL_STATE_XZ = 1;//新增
|
public final static Integer CI_DAILY_PATROL_STATE_DSH = 2;//待审核
|
public final static Integer CI_DAILY_PATROL_STATE_SHTG = 3;//审批通过
|
public final static Integer CI_DAILY_PATROL_STATE_SHSB = 4;//审核失败
|
public final static Map<Integer, String> CI_DAILY_PATROL_STATE_MAP = new LinkedHashMap<Integer, String>();
|
static {
|
CI_DAILY_PATROL_STATE_MAP.put(CI_DAILY_PATROL_STATE_XZ, "新增");
|
CI_DAILY_PATROL_STATE_MAP.put(CI_DAILY_PATROL_STATE_DSH, "待审核");
|
CI_DAILY_PATROL_STATE_MAP.put(CI_DAILY_PATROL_STATE_SHTG, "审核通过");
|
CI_DAILY_PATROL_STATE_MAP.put(CI_DAILY_PATROL_STATE_SHSB, "审核失败");
|
}
|
public static String getCI_DAILY_PATROL_STATE(Integer key){
|
return CI_DAILY_PATROL_STATE_MAP.get(key);
|
}
|
|
/**
|
* 紧急程度数据字典标识
|
*/
|
public final static String EVENT_PRI = "EVENT_PRI";
|
|
/**
|
* 事件影响度数据字典标识
|
*/
|
public final static String EVENT_EFFECT_DG = "EVENT_EFFECT_DG";
|
|
/**
|
* 事件优先级数据字典标识
|
*/
|
public final static String INCIDENT_EVENT_PRI = "EVENT_PRI";
|
/**
|
* 事件类型数据字典标识
|
*/
|
public final static String INCIDENT_TYPE = "INCIDENT_TYPE";
|
|
/**
|
* 事件来源数据字典标识
|
*/
|
public final static String INCIDENT_SOURCE = "INCIDENT_SOURCE";
|
|
/**
|
* 申报方式数据字典标识
|
*/
|
public final static String INCIDENT_APPLY_TYPE = "INCIDENT_APPLY_TYPE";
|
|
/**
|
* 结束方式数据字典标识
|
*/
|
public final static String INCIDENT_CLOSE_TYPE = "INCIDENT_CLOSE_TYPE";
|
|
|
/**
|
* 事件解决方式数据字典
|
*/
|
public final static String RESOLVE_WAY = "RESOLVE_WAY";
|
|
/**
|
* 事件关闭原因数据字典
|
*/
|
public final static String CLOSE_REASON = "CLOSE_REASON";
|
|
|
/**
|
* 事件重复数据字典标识
|
*/
|
public final static String SJCF = "SJCF";
|
|
/**
|
* 事件来源--一键报修
|
*/
|
public final static String INCIDENT_SOURCE_REPAIR_KEY = "INCIDENT_SOURCE_REPAIR";
|
|
/**
|
* 事件来源--一键报修
|
*/
|
public final static String INCIDENT_SOURCE_REPAIR_VALUE = "一键报修";
|
|
/**
|
* 问题关闭解决方式数据字典标识
|
*/
|
public final static String QUESTIONCLOSE_RESOLVE_TYPE = "QUESTIONCLOSE_RESOLVE_TYPE";
|
|
/**
|
* 问题结束解决方式数据字典标识
|
*/
|
public final static String QUESTIONEND_RESOLVE_TYPE = "QUESTIONEND_RESOLVE_TYPE";
|
|
/**
|
* 问题挂起原因数据字典标识
|
*/
|
public final static String QUESTION_GQYY = "QUESTION_GQYY";
|
|
/**
|
* 事件分配类型
|
*/
|
//分配给自己
|
public final static String TO_SELF = "TO_SELF";
|
|
//自动分配
|
public final static String TO_AUTO = "TO_AUTO";
|
|
//分配给指定人员
|
public final static String TO_USER = "TO_USER";
|
|
//分配给桌面
|
public final static String TO_DESK = "TO_DESK";
|
|
|
/**
|
* 事件状态
|
*/
|
public final static String SC_WORKFLOW_INCIDENT_STATE_FPDFWT = "-1"; //分配到服务台
|
public final static String SC_WORKFLOW_INCIDENT_STATE_FWTCLZ = "0"; //服务台处理中
|
public final static String SC_WORKFLOW_INCIDENT_STATE_FPDYCJSZC = "1"; //分配到远程技术支持
|
public final static String SC_WORKFLOW_INCIDENT_STATE_YCJSZCCLZ = "2";//远程技术支持处理中
|
public final static String SC_WORKFLOW_INCIDENT_STATE_FPDYX = "3";//分配到一线
|
public final static String SC_WORKFLOW_INCIDENT_STATE_YXCLZ = "4";//一线处理中
|
public final static String SC_WORKFLOW_INCIDENT_STATE_FPDEX = "5";//分配到二线
|
public final static String SC_WORKFLOW_INCIDENT_STATE_EXCLZ = "6";//二线处理中
|
public final static String SC_WORKFLOW_INCIDENT_STATE_FPDSX = "7";//分配到三线
|
public final static String SC_WORKFLOW_INCIDENT_STATE_SXCLZ = "8";//三线处理中
|
public final static String SC_WORKFLOW_INCIDENT_STATE_YJJ = "9";//已解决
|
public final static String SC_WORKFLOW_INCIDENT_STATE_GB = "10";//关闭
|
public final static String SC_WORKFLOW_INCIDENT_STATE_YPJ = "11";//已评价
|
|
public static final Map<String, String> mapSC_WORKFLOW_INCIDENT_STATE = new LinkedHashMap<String, String>();
|
static {
|
mapSC_WORKFLOW_INCIDENT_STATE.put(SC_WORKFLOW_INCIDENT_STATE_FPDFWT, "分配到服务台");
|
mapSC_WORKFLOW_INCIDENT_STATE.put(SC_WORKFLOW_INCIDENT_STATE_FWTCLZ, "服务台处理中");
|
mapSC_WORKFLOW_INCIDENT_STATE.put(SC_WORKFLOW_INCIDENT_STATE_FPDYCJSZC, "分配到运维经理");
|
mapSC_WORKFLOW_INCIDENT_STATE.put(SC_WORKFLOW_INCIDENT_STATE_YCJSZCCLZ, "运维经理处理中");
|
mapSC_WORKFLOW_INCIDENT_STATE.put(SC_WORKFLOW_INCIDENT_STATE_FPDYX, "分配到一线");
|
mapSC_WORKFLOW_INCIDENT_STATE.put(SC_WORKFLOW_INCIDENT_STATE_YXCLZ, "一线处理中");
|
mapSC_WORKFLOW_INCIDENT_STATE.put(SC_WORKFLOW_INCIDENT_STATE_FPDEX, "分配到二线");
|
mapSC_WORKFLOW_INCIDENT_STATE.put(SC_WORKFLOW_INCIDENT_STATE_EXCLZ, "二线处理中");
|
mapSC_WORKFLOW_INCIDENT_STATE.put(SC_WORKFLOW_INCIDENT_STATE_FPDSX, "分配到三线");
|
mapSC_WORKFLOW_INCIDENT_STATE.put(SC_WORKFLOW_INCIDENT_STATE_SXCLZ, "三线处理中");
|
mapSC_WORKFLOW_INCIDENT_STATE.put(SC_WORKFLOW_INCIDENT_STATE_YJJ, "已完成");
|
mapSC_WORKFLOW_INCIDENT_STATE.put(SC_WORKFLOW_INCIDENT_STATE_GB, "已取消");
|
mapSC_WORKFLOW_INCIDENT_STATE.put(SC_WORKFLOW_INCIDENT_STATE_YPJ, "已评价");
|
}
|
|
|
public static String getmapSC_WORKFLOW_INCIDENT_STATE_Label(String key) {
|
return mapSC_WORKFLOW_INCIDENT_STATE.get(key);
|
}
|
|
/**
|
* 流程-业务类型
|
*/
|
public static final Integer WORKFLOW_BASE_BUSINESS_TYPE_CI_ADD = 3;
|
public static final Integer WORKFLOW_BASE_BUSINESS_TYPE_CI_REMIND = 6;
|
public static final Integer WORKFLOW_BASE_BUSINESS_TYPE_CI_HEALTH = 7;
|
public static final Integer WORKFLOW_BASE_BUSINESS_TYPE_INCIDENT = 8;
|
public static final Integer WORKFLOW_BASE_BUSINESS_TYPE_QUESTION = 9;
|
public static final Integer WORKFLOW_BASE_BUSINESS_TYPE_INCIDENT_LOCAL = 10;
|
public static final Integer WORKFLOW_BASE_BUSINESS_TYPE_RELEASE = 12;
|
public static final Integer WORKFLOW_BASE_BUSINESS_TYPE_CI_CHANGE = 11;
|
public static final Integer WORKFLOW_BASE_BUSINESS_TYPE_STOCK = 13;
|
public static final Integer WORKFLOW_BASE_BUSINESS_TYPE_SPARE = 14;
|
public static final Integer WORKFLOW_BASE_BUSINESS_TYPE_CKLC = 15;
|
public static final Integer WORKFLOW_BASE_BUSINESS_TYPE_KCPD = 16;
|
public static final Integer WORKFLOW_BASE_BUSINESS_TYPE_BSBY = 17;
|
|
public static final Map<String, String> mapWORKFLOW_BASE_BUSINESS_TYPE = new LinkedHashMap();
|
static {
|
mapWORKFLOW_BASE_BUSINESS_TYPE.put(String.valueOf(WORKFLOW_BASE_BUSINESS_TYPE_CI_ADD), "设备新增");
|
mapWORKFLOW_BASE_BUSINESS_TYPE.put(String.valueOf(WORKFLOW_BASE_BUSINESS_TYPE_INCIDENT), "事件管理");
|
mapWORKFLOW_BASE_BUSINESS_TYPE.put(String.valueOf(WORKFLOW_BASE_BUSINESS_TYPE_QUESTION), "问题管理");
|
mapWORKFLOW_BASE_BUSINESS_TYPE.put(String.valueOf(WORKFLOW_BASE_BUSINESS_TYPE_INCIDENT_LOCAL), "驻场运维");
|
mapWORKFLOW_BASE_BUSINESS_TYPE.put(String.valueOf(WORKFLOW_BASE_BUSINESS_TYPE_CI_REMIND), "例行维护");
|
mapWORKFLOW_BASE_BUSINESS_TYPE.put(String.valueOf(WORKFLOW_BASE_BUSINESS_TYPE_CI_HEALTH), "健康检查");
|
mapWORKFLOW_BASE_BUSINESS_TYPE.put(String.valueOf(WORKFLOW_BASE_BUSINESS_TYPE_RELEASE), "发布管理");
|
mapWORKFLOW_BASE_BUSINESS_TYPE.put(String.valueOf(WORKFLOW_BASE_BUSINESS_TYPE_CI_CHANGE), "变更管理");
|
mapWORKFLOW_BASE_BUSINESS_TYPE.put(String.valueOf(WORKFLOW_BASE_BUSINESS_TYPE_STOCK), "入库申请");
|
mapWORKFLOW_BASE_BUSINESS_TYPE.put(String.valueOf(WORKFLOW_BASE_BUSINESS_TYPE_SPARE), "申领申请");
|
mapWORKFLOW_BASE_BUSINESS_TYPE.put(String.valueOf(WORKFLOW_BASE_BUSINESS_TYPE_CKLC), "出库流程");
|
mapWORKFLOW_BASE_BUSINESS_TYPE.put(String.valueOf(WORKFLOW_BASE_BUSINESS_TYPE_KCPD), "库存盘点");
|
mapWORKFLOW_BASE_BUSINESS_TYPE.put(String.valueOf(WORKFLOW_BASE_BUSINESS_TYPE_BSBY), "报损报溢");
|
}
|
|
public static String mapWORKFLOW_BUSINESS_TYPE_Label(String i) {
|
return mapWORKFLOW_BASE_BUSINESS_TYPE.get(i);
|
}
|
|
public static String mapWORKFLOW_BUSINESS_TYPE_Label(Integer i) {
|
return mapWORKFLOW_BASE_BUSINESS_TYPE.get(String.valueOf(i));
|
}
|
|
/**
|
* 流程状态，1：进行中；2：已完成；3：已关闭；4：已评价；5：已删除；6：已挂起
|
*/
|
public static final Integer WORKFLOW_BASE_WFSTATE_DOING = 1;
|
public static final Integer WORKFLOW_BASE_WFSTATE_FINISH = 2;
|
public static final Integer WORKFLOW_BASE_WFSTATE_CLOSE = 3;
|
public static final Integer WORKFLOW_BASE_WFSTATE_EVALUATE = 4;
|
public static final Integer WORKFLOW_BASE_WFSTATE_DELETE = 5;
|
public static final Integer WORKFLOW_BASE_WFSTATE_UP = 6;
|
|
public static final Map<String, String> mapWORKFLOW_BASE_WFSTATE = new LinkedHashMap<String, String>();
|
static {
|
mapWORKFLOW_BASE_WFSTATE.put(String.valueOf(WORKFLOW_BASE_WFSTATE_DOING), "进行中");
|
mapWORKFLOW_BASE_WFSTATE.put(String.valueOf(WORKFLOW_BASE_WFSTATE_FINISH), "已完成");
|
mapWORKFLOW_BASE_WFSTATE.put(String.valueOf(WORKFLOW_BASE_WFSTATE_CLOSE), "已取消");
|
mapWORKFLOW_BASE_WFSTATE.put(String.valueOf(WORKFLOW_BASE_WFSTATE_EVALUATE), "已评价");
|
mapWORKFLOW_BASE_WFSTATE.put(String.valueOf(WORKFLOW_BASE_WFSTATE_DELETE), "已删除");
|
mapWORKFLOW_BASE_WFSTATE.put(String.valueOf(WORKFLOW_BASE_WFSTATE_UP), "已挂起");
|
}
|
|
public static final Map<String, String> mapWORKFLOW_BASE_WFSTATE_PART = new LinkedHashMap<String, String>();
|
static {
|
mapWORKFLOW_BASE_WFSTATE_PART.put(String.valueOf(WORKFLOW_BASE_WFSTATE_DOING), "进行中");
|
mapWORKFLOW_BASE_WFSTATE_PART.put(String.valueOf(WORKFLOW_BASE_WFSTATE_FINISH), "已完成");
|
mapWORKFLOW_BASE_WFSTATE_PART.put(String.valueOf(WORKFLOW_BASE_WFSTATE_CLOSE), "已取消");
|
}
|
|
public static String getWORKFLOW_BASE_WFSTATE_Label(String i){
|
return mapWORKFLOW_BASE_WFSTATE.get(i);
|
}
|
|
public static String getWORKFLOW_BASE_WFSTATE_Label(Integer i) {
|
return mapWORKFLOW_BASE_WFSTATE.get(String.valueOf(i));
|
}
|
|
/**
|
* 节点实例流转状态，1：未处理；2：进行中；3：已处理
|
*/
|
public static final Integer WORKFLOW_NODE_FLOWSTATE_UNDISPOSE = 1;
|
public static final Integer WORKFLOW_NODE_FLOWSTATE_DOING = 2;
|
public static final Integer WORKFLOW_NODE_FLOWSTATE_FINISH = 3;
|
|
public static final Map<Integer, String> WORKFLOW_NODE_FLOWSTATE_Map = new LinkedHashMap<Integer, String>();
|
static {
|
WORKFLOW_NODE_FLOWSTATE_Map.put(WORKFLOW_NODE_FLOWSTATE_UNDISPOSE, "待响应");
|
WORKFLOW_NODE_FLOWSTATE_Map.put(WORKFLOW_NODE_FLOWSTATE_DOING, "进行中");
|
WORKFLOW_NODE_FLOWSTATE_Map.put(WORKFLOW_NODE_FLOWSTATE_FINISH, "已处理");
|
}
|
|
public static String getWORKFLOW_NODE_FLOWSTATE_Label(Integer i) {
|
return WORKFLOW_NODE_FLOWSTATE_Map.get(i);
|
}
|
|
/**
|
* 日常巡检报告状态
|
*/
|
public static final Integer CI_DAILY_PATROL_ITEM_ITEM_TYPE_TY = 1;
|
public static final Integer CI_DAILY_PATROL_ITEM_ITEM_TYPE_DZ = 2;
|
|
public static final Map<Integer, String> mapCI_DAILY_PATROL_ITEM_ITEM_TYPE = new LinkedHashMap<Integer, String>();
|
static {
|
mapCI_DAILY_PATROL_ITEM_ITEM_TYPE.put(CI_DAILY_PATROL_ITEM_ITEM_TYPE_TY, "通用");
|
mapCI_DAILY_PATROL_ITEM_ITEM_TYPE.put(CI_DAILY_PATROL_ITEM_ITEM_TYPE_DZ, "定制");
|
}
|
|
public static String getmapCI_DAILY_PATROL_ITEM_ITEM_TYPE_Label(Integer i) {
|
return mapCI_DAILY_PATROL_ITEM_ITEM_TYPE.get(i);
|
}
|
|
/**
|
* 节点实例流转类型，1：正常流转；2：回退
|
*/
|
public static final Integer WORKFLOW_NODE_FLOW_TYPE_NORMAL = 1;
|
public static final Integer WORKFLOW_NODE_FLOW_TYPE_BACK = 2;
|
|
public static final Map<Integer, String> WORKFLOW_NODE_FLOW_TYPE_Map = new LinkedHashMap<Integer, String>();
|
static {
|
WORKFLOW_NODE_FLOW_TYPE_Map.put(WORKFLOW_NODE_FLOW_TYPE_NORMAL, "正常流转");
|
WORKFLOW_NODE_FLOW_TYPE_Map.put(WORKFLOW_NODE_FLOW_TYPE_BACK, "回退");
|
}
|
|
public static String getWORKFLOW_NODE_FLOW_TYPE_Label(Integer i) {
|
return WORKFLOW_NODE_FLOW_TYPE_Map.get(i);
|
}
|
|
/**
|
* 流程节点-流转类型（1=串行；2=并行；）
|
*/
|
public static final Integer WORKFLOW_TEMPLATE_NODE_FLOWTYPE_SERIAL = 1;
|
public static final Integer WORKFLOW_TEMPLATE_NODE_FLOWTYPE_PARALLEL = 2;
|
|
public static final Map<Integer,String> mapWORKFLOW_TEMPLATE_NODE_FLOWTYPE = new LinkedHashMap();
|
static {
|
mapWORKFLOW_TEMPLATE_NODE_FLOWTYPE.put(WORKFLOW_TEMPLATE_NODE_FLOWTYPE_SERIAL, "串行");
|
mapWORKFLOW_TEMPLATE_NODE_FLOWTYPE.put(WORKFLOW_TEMPLATE_NODE_FLOWTYPE_PARALLEL, "并行");
|
}
|
|
public static String getWORKFLOW_TEMPLATE_NODE_FLOWTYPE_Label(Integer i) {
|
return mapWORKFLOW_TEMPLATE_NODE_FLOWTYPE.get(i);
|
}
|
|
public static final Map<String,String> mapWORKFLOW_TEMPLATE_NODE_FLOWTYPE_Str = new LinkedHashMap();
|
static {
|
mapWORKFLOW_TEMPLATE_NODE_FLOWTYPE_Str.put("1", "串行");
|
mapWORKFLOW_TEMPLATE_NODE_FLOWTYPE_Str.put("2", "并行");
|
}
|
|
/**
|
* 流程节点-并行 类型
|
* 1=1人同意即可；2=全部同意；3=比例同意）
|
*/
|
public static final Integer WORKFLOW_PARALLEL_TYPE_ONE_AGREE = 1;
|
public static final Integer WORKFLOW_PARALLEL_TYPE_ALL_AGREE = 2;
|
public static final Integer WORKFLOW_PARALLEL_TYPE_SCALE_AGREE = 3;
|
|
public static final Map<Integer,String> WORKFLOW_PARALLEL_TYPE_Map = new LinkedHashMap<Integer, String>();
|
static {
|
WORKFLOW_PARALLEL_TYPE_Map.put(WORKFLOW_PARALLEL_TYPE_ONE_AGREE, "1人同意即可");
|
WORKFLOW_PARALLEL_TYPE_Map.put(WORKFLOW_PARALLEL_TYPE_ALL_AGREE, "全部同意");
|
WORKFLOW_PARALLEL_TYPE_Map.put(WORKFLOW_PARALLEL_TYPE_SCALE_AGREE, "比例同意");
|
}
|
|
public static String getWORKFLOW_PARALLEL_TYPE_Label(Integer i) {
|
return WORKFLOW_PARALLEL_TYPE_Map.get(i);
|
}
|
|
/**
|
* 节点实例处理结果，1：通过；2：不通过；3：回退
|
*/
|
public static final Integer WORKFLOW_NODE_DEAL_RESULT_PASS = 1;
|
public static final Integer WORKFLOW_NODE_DEAL_RESULT_NOPASS = 2;
|
public static final Integer WORKFLOW_NODE_DEAL_RESULT_BACK = 3;
|
|
public static final Map<Integer, String> mapWORKFLOW_NODE_DEAL_RESULT = new LinkedHashMap<Integer, String>();
|
static {
|
mapWORKFLOW_NODE_DEAL_RESULT.put(WORKFLOW_NODE_DEAL_RESULT_PASS, "通过");
|
mapWORKFLOW_NODE_DEAL_RESULT.put(WORKFLOW_NODE_DEAL_RESULT_NOPASS, "不通过");
|
mapWORKFLOW_NODE_DEAL_RESULT.put(WORKFLOW_NODE_DEAL_RESULT_BACK, "回退");
|
}
|
|
public static String getmapWORKFLOW_NODE_DEAL_RESULT_Label(Integer i) {
|
return mapWORKFLOW_NODE_DEAL_RESULT.get(i);
|
}
|
|
/**
|
* 流程节点-节点类型
|
* （1=开始节点；2=结束节点；3=中间业务节点；4=中间阅知节点；5=子流程节点）
|
*/
|
public static final Integer WORKFLOW_TEMPLATE_NODE_NODETYPE_START = 1;
|
public static final Integer WORKFLOW_TEMPLATE_NODE_NODETYPE_END = 2;
|
public static final Integer WORKFLOW_TEMPLATE_NODE_NODETYPE_BUSINESS = 3;
|
public static final Integer WORKFLOW_TEMPLATE_NODE_NODETYPE_READ = 4;
|
public static final Integer WORKFLOW_TEMPLATE_NODE_NODETYPE_SUB = 5;
|
|
public static final Map<Integer,String> mapWORKFLOW_TEMPLATE_NODE_NODETYPE = new LinkedHashMap();
|
static {
|
|
mapWORKFLOW_TEMPLATE_NODE_NODETYPE.put(WORKFLOW_TEMPLATE_NODE_NODETYPE_START, "开始节点");
|
mapWORKFLOW_TEMPLATE_NODE_NODETYPE.put(WORKFLOW_TEMPLATE_NODE_NODETYPE_END, "结束节点");
|
mapWORKFLOW_TEMPLATE_NODE_NODETYPE.put(WORKFLOW_TEMPLATE_NODE_NODETYPE_BUSINESS, "中间业务节点");
|
mapWORKFLOW_TEMPLATE_NODE_NODETYPE.put(WORKFLOW_TEMPLATE_NODE_NODETYPE_READ, "中间阅知节点");
|
mapWORKFLOW_TEMPLATE_NODE_NODETYPE.put(WORKFLOW_TEMPLATE_NODE_NODETYPE_SUB, "子流程节点");
|
}
|
|
public static String getWORKFLOW_TEMPLATE_NODE_NODETYPE_Label(Integer i) {
|
return mapWORKFLOW_TEMPLATE_NODE_NODETYPE.get(i);
|
}
|
|
/**
|
* 处理人类型，1：指定角色；2：指定人员；3：上一环节指派；4：自动设为流程发起人
|
*/
|
public static final Integer WORKFLOW_TEMPLATE_NODE_DEALER_TYPE_ROLE = 1;
|
public static final Integer WORKFLOW_TEMPLATE_NODE_DEALER_TYPE_USER = 2;
|
public static final Integer WORKFLOW_TEMPLATE_NODE_DEALER_TYPE_ASSIGN = 3;
|
public static final Integer WORKFLOW_TEMPLATE_NODE_DEALER_TYPE_START = 4;
|
|
public static final Map<Integer, String> WORKFLOW_TEMPLATE_NODE_DEALER_TYPE_Map = new LinkedHashMap<Integer, String>();
|
static {
|
WORKFLOW_TEMPLATE_NODE_DEALER_TYPE_Map.put(WORKFLOW_TEMPLATE_NODE_DEALER_TYPE_ROLE, "指定角色");
|
WORKFLOW_TEMPLATE_NODE_DEALER_TYPE_Map.put(WORKFLOW_TEMPLATE_NODE_DEALER_TYPE_USER, "指定人员");
|
WORKFLOW_TEMPLATE_NODE_DEALER_TYPE_Map.put(WORKFLOW_TEMPLATE_NODE_DEALER_TYPE_ASSIGN, "上一环节指派");
|
WORKFLOW_TEMPLATE_NODE_DEALER_TYPE_Map.put(WORKFLOW_TEMPLATE_NODE_DEALER_TYPE_START, "自动设为流程发起人");
|
}
|
|
public static String getWORKFLOW_TEMPLATE_NODE_DEALER_TYPE_Map(Integer i) {
|
return WORKFLOW_TEMPLATE_NODE_DEALER_TYPE_Map.get(i);
|
}
|
|
/**
|
* 用户及设备涉及工单类型，1：用户工单；2：设备工单
|
*/
|
public static final Integer WORKFLOW_USER_CMDB_TYPE_USER = 1;
|
public static final Integer WORKFLOW_USER_CMDB_TYPE_CI = 2;
|
|
public static final Map<Integer, String> WORKFLOW_USER_CMDB_TYPE_Map = new LinkedHashMap<Integer, String>();
|
static {
|
WORKFLOW_USER_CMDB_TYPE_Map.put(WORKFLOW_USER_CMDB_TYPE_USER, "用户工单");
|
WORKFLOW_USER_CMDB_TYPE_Map.put(WORKFLOW_USER_CMDB_TYPE_CI, "设备工单");
|
}
|
|
public static String getWORKFLOW_USER_CMDB_TYPE_Label(Integer i) {
|
return WORKFLOW_USER_CMDB_TYPE_Map.get(i);
|
}
|
|
/**
|
* 消息类型
|
*/
|
public final static int GG_MESSAGE_TYPE_GGTZ = 0; //公告通知
|
public final static int GG_MESSAGE_TYPE_SJGL = 1; //事件管理
|
public final static int GG_MESSAGE_TYPE_WTGL = 2; //问题管理
|
public final static int GG_MESSAGE_TYPE_BGGL = 3; //变更管理
|
public final static int GG_MESSAGE_TYPE_FBGL = 4; //发布管理
|
public final static int GG_MESSAGE_TYPE_PZGL = 5; //配置管理
|
public final static int GG_MESSAGE_TYPE_SBCJ = 6; //设备采集
|
public final static int GG_MESSAGE_TYPE_LXXJ = 7; //例行巡检
|
public final static int GG_MESSAGE_TYPE_XCYW = 8; //现场运维
|
public final static int GG_MESSAGE_TYPE_ZSGL = 9; //知识管理
|
public final static int GG_MESSAGE_TYPE_JKJC = 10; //健康检查
|
public final static int GG_MESSAGE_TYPE_BX = 11; //报修信息
|
|
public static final Map<String, String> mapSC_MESSAGE_TYPE = new LinkedHashMap<String, String>();
|
static {
|
mapSC_MESSAGE_TYPE.put(String.valueOf(GG_MESSAGE_TYPE_GGTZ), "公告通知");
|
mapSC_MESSAGE_TYPE.put(String.valueOf(GG_MESSAGE_TYPE_SJGL), "事件管理");
|
mapSC_MESSAGE_TYPE.put(String.valueOf(GG_MESSAGE_TYPE_WTGL), "问题管理");
|
mapSC_MESSAGE_TYPE.put(String.valueOf(GG_MESSAGE_TYPE_BGGL), "变更管理");
|
mapSC_MESSAGE_TYPE.put(String.valueOf(GG_MESSAGE_TYPE_FBGL), "发布管理");
|
mapSC_MESSAGE_TYPE.put(String.valueOf(GG_MESSAGE_TYPE_PZGL), "配置管理");
|
mapSC_MESSAGE_TYPE.put(String.valueOf(GG_MESSAGE_TYPE_SBCJ), "设备采集");
|
mapSC_MESSAGE_TYPE.put(String.valueOf(GG_MESSAGE_TYPE_LXXJ), "例行巡检");
|
mapSC_MESSAGE_TYPE.put(String.valueOf(GG_MESSAGE_TYPE_XCYW), "现场运维");
|
mapSC_MESSAGE_TYPE.put(String.valueOf(GG_MESSAGE_TYPE_ZSGL), "知识管理");
|
mapSC_MESSAGE_TYPE.put(String.valueOf(GG_MESSAGE_TYPE_JKJC), "健康检查");
|
mapSC_MESSAGE_TYPE.put(String.valueOf(GG_MESSAGE_TYPE_BX), "用户报修");
|
}
|
|
public static String getmapSC_MESSAGE_TYPE(String key) {
|
return mapSC_MESSAGE_TYPE.get(key);
|
}
|
|
//消息类型和流程类型对应关系
|
public static final Map<Integer, Integer> SC_MESSAGE_TYPE_TO_FLOW_TYPE = new LinkedHashMap<Integer, Integer>();
|
static {
|
SC_MESSAGE_TYPE_TO_FLOW_TYPE.put(GG_MESSAGE_TYPE_SJGL, WORKFLOW_BASE_BUSINESS_TYPE_INCIDENT);
|
SC_MESSAGE_TYPE_TO_FLOW_TYPE.put(GG_MESSAGE_TYPE_WTGL, WORKFLOW_BASE_BUSINESS_TYPE_QUESTION);
|
SC_MESSAGE_TYPE_TO_FLOW_TYPE.put(GG_MESSAGE_TYPE_LXXJ, WORKFLOW_BASE_BUSINESS_TYPE_CI_REMIND);
|
SC_MESSAGE_TYPE_TO_FLOW_TYPE.put(GG_MESSAGE_TYPE_XCYW, WORKFLOW_BASE_BUSINESS_TYPE_INCIDENT_LOCAL);
|
SC_MESSAGE_TYPE_TO_FLOW_TYPE.put(GG_MESSAGE_TYPE_JKJC, WORKFLOW_BASE_BUSINESS_TYPE_CI_HEALTH);
|
}
|
|
public static int getSC_MESSAGE_TYPE_TO_FLOW_TYPE(int key) {
|
return SC_MESSAGE_TYPE_TO_FLOW_TYPE.get(key);
|
}
|
|
/**
|
* 通用属性【CMDB_CI_BASE】，使用状态（1=正常；2=废弃；3=新增；4=维护中；5=备用）
|
*/
|
public static final Integer CMDB_CI_BASE_USINGSTATE_NORMAL = 1;
|
public static final Integer CMDB_CI_BASE_USINGSTATE_WASTE = 2;
|
public static final Integer CMDB_CI_BASE_USINGSTATE_ADD = 3;
|
public static final Integer CMDB_CI_BASE_USINGSTATE_WHZ = 4;
|
public static final Integer CMDB_CI_BASE_USINGSTATE_BY = 5;
|
public static final Map<Integer, String> CMDB_CI_BASE_USINGSTATE_Map = new LinkedHashMap<Integer, String>();
|
static {
|
CMDB_CI_BASE_USINGSTATE_Map.put(CMDB_CI_BASE_USINGSTATE_NORMAL, "正常");
|
CMDB_CI_BASE_USINGSTATE_Map.put(CMDB_CI_BASE_USINGSTATE_WASTE, "废弃");
|
CMDB_CI_BASE_USINGSTATE_Map.put(CMDB_CI_BASE_USINGSTATE_ADD, "新增");
|
CMDB_CI_BASE_USINGSTATE_Map.put(CMDB_CI_BASE_USINGSTATE_WHZ, "维护中");
|
CMDB_CI_BASE_USINGSTATE_Map.put(CMDB_CI_BASE_USINGSTATE_BY, "备用");
|
}
|
public static String getCMDB_CI_BASE_USINGSTATE_Label(Integer i){
|
return CMDB_CI_BASE_USINGSTATE_Map.get(i);
|
}
|
|
/**
|
* 知识审核状态（AUDIT_STATE '审核状态（1：待审核 2：审核通过 3：审核不通过）'）
|
*/
|
public final static Integer KM_LIBRARY_TEMP_AUDIT_STATE_DSH = 1;
|
public final static Integer KM_LIBRARY_TEMP_AUDIT_STATE_SHTG = 2;
|
public final static Integer KM_LIBRARY_TEMP_AUDIT_STATE_SHBTG = 3;
|
|
public static final Map<Integer, String> mapKM_LIBRARY_TEMP_AUDIT_STATE = new LinkedHashMap<Integer, String>();
|
static {
|
mapKM_LIBRARY_TEMP_AUDIT_STATE.put(KM_LIBRARY_TEMP_AUDIT_STATE_DSH, "待审核");
|
mapKM_LIBRARY_TEMP_AUDIT_STATE.put(KM_LIBRARY_TEMP_AUDIT_STATE_SHTG, "审核通过");
|
mapKM_LIBRARY_TEMP_AUDIT_STATE.put(KM_LIBRARY_TEMP_AUDIT_STATE_SHBTG, "审核不通过");
|
}
|
|
public static String getmapKM_LIBRARY_TEMP_AUDIT_STATE_Label(Integer key) {
|
return mapKM_LIBRARY_TEMP_AUDIT_STATE.get(key);
|
}
|
|
/**
|
* 文档类型，1：公司文档;2:客户文档 3：设备文档;
|
*/
|
public final static Integer GG_FOLDERS_TYPE_COMPANY_DOC = 1;
|
public final static Integer GG_FOLDERS_TYPE_CUSTOMER_DOC = 2;
|
public final static Integer GG_FOLDERS_TYPE_DEVICE_DOC = 3;
|
|
public static final Map<String, String> mapGG_FOLDERS_TYPE = new LinkedHashMap<String, String>();
|
static {
|
mapGG_FOLDERS_TYPE.put(GG_FOLDERS_TYPE_COMPANY_DOC.toString(), "公司文档");
|
mapGG_FOLDERS_TYPE.put(GG_FOLDERS_TYPE_CUSTOMER_DOC.toString(), "客户文档");
|
mapGG_FOLDERS_TYPE.put(GG_FOLDERS_TYPE_DEVICE_DOC.toString(), "设备文档");
|
}
|
|
public static String getmapGG_FOLDERS_TYPE_Label(String key) {
|
return mapGG_FOLDERS_TYPE.get(key);
|
}
|
|
//文档管理根目录名称
|
public final static String baseForder = "全部文档";
|
|
/**
|
* 驻场运维事件状态
|
*/
|
public final static String SC_WORKFLOW_INCIDENT_LOCAL_STATE_FPDFWT = "0"; //分配到服务台
|
public final static String SC_WORKFLOW_INCIDENT_LOCAL_STATE_FWTCLZ = "1"; //服务台处理中
|
public final static String SC_WORKFLOW_INCIDENT_LOCAL_STATE_FPDZCGCS = "2"; //分配到驻场工程师
|
public final static String SC_WORKFLOW_INCIDENT_LOCAL_STATE_ZCGCSCLZ = "3";//驻场工程师处理中
|
public final static String SC_WORKFLOW_INCIDENT_LOCAL_STATE_YJJ = "4";//已解决
|
public final static String SC_WORKFLOW_INCIDENT_LOCAL_STATE_YGB = "5";//已关闭
|
public final static String SC_WORKFLOW_INCIDENT_LOCAL_STATE_YPJ = "6";//已评价
|
public final static String SC_WORKFLOW_INCIDENT_LOCAL_STATE_YGQ = "7";//已挂起
|
|
public static final Map<String, String> mapSC_WORKFLOW_INCIDENT_LOCAL_STATE = new LinkedHashMap<String, String>();
|
static {
|
mapSC_WORKFLOW_INCIDENT_LOCAL_STATE.put(SC_WORKFLOW_INCIDENT_LOCAL_STATE_FPDFWT, "分配到服务台");
|
mapSC_WORKFLOW_INCIDENT_LOCAL_STATE.put(SC_WORKFLOW_INCIDENT_LOCAL_STATE_FWTCLZ, "服务台处理中");
|
mapSC_WORKFLOW_INCIDENT_LOCAL_STATE.put(SC_WORKFLOW_INCIDENT_LOCAL_STATE_FPDZCGCS, "分配到驻场工程师");
|
mapSC_WORKFLOW_INCIDENT_LOCAL_STATE.put(SC_WORKFLOW_INCIDENT_LOCAL_STATE_ZCGCSCLZ, "驻场工程师处理中");
|
mapSC_WORKFLOW_INCIDENT_LOCAL_STATE.put(SC_WORKFLOW_INCIDENT_LOCAL_STATE_YJJ, "已解决");
|
mapSC_WORKFLOW_INCIDENT_LOCAL_STATE.put(SC_WORKFLOW_INCIDENT_LOCAL_STATE_YGB, "已取消");
|
mapSC_WORKFLOW_INCIDENT_LOCAL_STATE.put(SC_WORKFLOW_INCIDENT_LOCAL_STATE_YPJ, "已评价");
|
mapSC_WORKFLOW_INCIDENT_LOCAL_STATE.put(SC_WORKFLOW_INCIDENT_LOCAL_STATE_YGQ, "已挂起");
|
}
|
|
public static String mapSC_WORKFLOW_INCIDENT_LOCAL_STATE_Label(String key) {
|
return mapSC_WORKFLOW_INCIDENT_LOCAL_STATE.get(key);
|
}
|
|
/**
|
* 驻场运维事件环节流转配置
|
*/
|
public final static String ZCYW_FWSL = "1024417f84b443b385c287e517c6b885"; //服务受理
|
|
/**
|
* 服务台角色编号
|
*/
|
public final static String AC_ROLE_FWT = "b80bf3c4fa164d209a91d3787bdaf441";
|
/**
|
* 文件审核状态
|
*/
|
public final static String FILE_STATE_XZ = "1"; //新增
|
public final static String FILE_STATE_DSH = "2"; //待审核
|
public final static String FILE_STATE_SHTG= "3"; //审核通过
|
public final static String FILE_STATE_SHBTG = "4"; //审核不通过
|
|
public static final Map<String, String> mapFILE_STATE = new LinkedHashMap<String, String>();
|
static {
|
mapFILE_STATE.put(FILE_STATE_XZ, "新增");
|
mapFILE_STATE.put(FILE_STATE_DSH, "待审核");
|
mapFILE_STATE.put(FILE_STATE_SHTG, "审核通过");
|
mapFILE_STATE.put(FILE_STATE_SHBTG, "审核不通过");
|
}
|
public static String mapFILE_STATE_Label(String key) {
|
return mapFILE_STATE.get(key);
|
}
|
|
/**
|
* 事件文件夹编号
|
*/
|
public final static String GG_FOLDERS_SJFOLDERS = "sjfolders";
|
/**
|
* 问题文件夹编号
|
*/
|
public final static String GG_FOLDERS_WTFOLDERS = "wtfolders";
|
/**
|
* 例行维护文件夹编号
|
*/
|
public final static String GG_FOLDERS_LXWHFOLDERS= "lxwhfolders";
|
/**
|
* 健康检查文件夹编号
|
*/
|
public final static String GG_FOLDERS_JKJCFOLDERS = "jkjcfolders";
|
|
/**
|
* 驻场运维文件夹编号
|
*/
|
public final static String GG_FOLDERS_ZCYWSJFOLDERS = "zcywsjfolders";
|
|
/**
|
* 知识文件夹编号
|
*/
|
public final static String GG_FOLDERS_KNOWFOLDERS = "knowfolders";
|
|
/**
|
* 客户文件夹
|
*/
|
public final static String GG_FOLDERS_CUSTOMERS = "customerfolders";
|
|
/**
|
* 发布文件夹编号
|
*/
|
public final static String GG_FOLDERS_FBFOLDERS = "fbfolders";
|
|
/**
|
* 问题来源数据字典标识
|
*/
|
public final static String QUESTION_SOURCE = "QUESTION_SOURCE";
|
|
/**
|
* 月度满意度最后生成日期数据字典标识
|
*/
|
public final static String SATIS_LAST_TIME = "SATIS_LAST_TIME";
|
|
|
/**
|
* 智能提醒时间表
|
*/
|
public static final Integer CI_REMIND_TIMERTASK_STATE_WZX = 1;
|
public static final Integer CI_REMIND_TIMERTASK_STATE_YZX = 2;
|
public static final Integer CI_REMIND_TIMERTASK_STATE_JY = 3;
|
|
public static final Map<Integer, String> mapCI_REMIND_TIMERTASK_STATE = new LinkedHashMap<Integer, String>();
|
static {
|
mapCI_REMIND_TIMERTASK_STATE.put(CI_REMIND_TIMERTASK_STATE_WZX, "未执行");
|
mapCI_REMIND_TIMERTASK_STATE.put(CI_REMIND_TIMERTASK_STATE_YZX, "已执行");
|
mapCI_REMIND_TIMERTASK_STATE.put(CI_REMIND_TIMERTASK_STATE_JY, "禁用");
|
}
|
|
public static String getmapCI_REMIND_TIMERTASK_STATE_Label(Integer i) {
|
return mapCI_REMIND_TIMERTASK_STATE.get(i);
|
}
|
|
/**
|
* 问题状态（0=已登记；1=问题受理；2=问题审核；3=问题诊断；4=方案审批；5=方案实施；6=问题回顾；7=已关闭；8=挂起；9=已完成；10=已评价）
|
*/
|
public final static String SC_WORKFLOW_QUESTION_STATE_YDJ = "0"; //已登记
|
public final static String SC_WORKFLOW_QUESTION_STATE_SL = "1"; //受理
|
public final static String SC_WORKFLOW_QUESTION_STATE_SH = "2";//审核
|
public final static String SC_WORKFLOW_QUESTION_STATE_WTZD = "3";//问题诊断
|
public final static String SC_WORKFLOW_QUESTION_STATE_FASP = "4";//方案审批
|
public final static String SC_WORKFLOW_QUESTION_STATE_FASS = "5";//方案实施
|
public final static String SC_WORKFLOW_QUESTION_STATE_HG = "6";//回顾
|
public final static String SC_WORKFLOW_QUESTION_STATE_YGB = "7";//已关闭
|
public final static String SC_WORKFLOW_QUESTION_STATE_GQ = "8";//挂起
|
public final static String SC_WORKFLOW_QUESTION_STATE_YWC = "9";//已完成
|
public final static String SC_WORKFLOW_QUESTION_STATE_YPJ = "10";//已评价
|
|
public static final Map<String, String> mapSC_WORKFLOW_QUESTION_STATE = new LinkedHashMap<String, String>();
|
static {
|
mapSC_WORKFLOW_QUESTION_STATE.put(SC_WORKFLOW_QUESTION_STATE_YDJ, "已登记");
|
mapSC_WORKFLOW_QUESTION_STATE.put(SC_WORKFLOW_QUESTION_STATE_SL, "问题受理");
|
mapSC_WORKFLOW_QUESTION_STATE.put(SC_WORKFLOW_QUESTION_STATE_SH, "问题审核");
|
mapSC_WORKFLOW_QUESTION_STATE.put(SC_WORKFLOW_QUESTION_STATE_WTZD, "问题诊断");
|
mapSC_WORKFLOW_QUESTION_STATE.put(SC_WORKFLOW_QUESTION_STATE_FASP, "方案审批");
|
mapSC_WORKFLOW_QUESTION_STATE.put(SC_WORKFLOW_QUESTION_STATE_FASS, "方案实施");
|
mapSC_WORKFLOW_QUESTION_STATE.put(SC_WORKFLOW_QUESTION_STATE_HG, "问题回顾");
|
mapSC_WORKFLOW_QUESTION_STATE.put(SC_WORKFLOW_QUESTION_STATE_YGB, "已取消");
|
mapSC_WORKFLOW_QUESTION_STATE.put(SC_WORKFLOW_QUESTION_STATE_GQ, "问题挂起");
|
mapSC_WORKFLOW_QUESTION_STATE.put(SC_WORKFLOW_QUESTION_STATE_YWC, "已完成");
|
mapSC_WORKFLOW_QUESTION_STATE.put(SC_WORKFLOW_QUESTION_STATE_YPJ, "已评价");
|
}
|
|
public static String getmapSC_WORKFLOW_QUESTION_STATE_Label(String key) {
|
return mapSC_WORKFLOW_QUESTION_STATE.get(key);
|
}
|
|
|
//日常巡检流程状态
|
public final static Integer RCXJ_FLOW_SC = 0;//删除
|
public final static Integer RCXJ_FLOW_XZ = 1;//新增
|
public final static Integer RCXJ_FLOW_DSH = 2;//待审核
|
public final static Integer RCXJ_FLOW_SB = 3;//审核失败
|
public final static Integer RCXJ_FLOW_WC = 4;//已审核
|
public final static Map<Integer, String> RCXJ_FLOW_MAP = new LinkedHashMap<Integer, String>();
|
static {
|
RCXJ_FLOW_MAP.put(RCXJ_FLOW_XZ, "新增");
|
RCXJ_FLOW_MAP.put(RCXJ_FLOW_DSH, "待审核");
|
RCXJ_FLOW_MAP.put(RCXJ_FLOW_SB, "审核失败");
|
RCXJ_FLOW_MAP.put(RCXJ_FLOW_WC, "已审核");
|
}
|
public static String getRCXJ_FLOW(Integer key){
|
return RCXJ_FLOW_MAP.get(key);
|
}
|
|
/**
|
* 智能巡检流转配置
|
*/
|
public final static String REMIND_GENERATED = "7c42903590244ff4b8689b70fca28523"; //工单生成
|
public final static String REMIND_DISPATCH = "50481f12eb654aa2986e63b588961204"; //人员指派
|
public final static String REMIND_DEAL = "8f9a752b1b09480b816de77ae1756046"; //维护执行
|
public final static String REMIND_APPROVE = "04e5ae6861fd4ef6bbc521e30b4d11bc"; //结果审核
|
|
public final static String REMIND_NODETYPE_DISPATCH = "DISPATCH"; //
|
public final static String REMIND_NODETYPE_DEAL = "DEAL"; //
|
|
public static final Map<String, String> remindNode = new LinkedHashMap<String, String>();
|
static {
|
remindNode.put(REMIND_DISPATCH, "人员指派");
|
remindNode.put(REMIND_DEAL, "维护执行");
|
remindNode.put(REMIND_APPROVE, "结果审核");
|
}
|
|
/**
|
* 健康体检时间表状态
|
*/
|
public static final Integer CI_HEALTH_PLAN_TIMER_STATE_WJX = 1;
|
public static final Integer CI_HEALTH_PLAN_TIMER_STATE_JXZ = 2;
|
public static final Integer CI_HEALTH_PLAN_TIMER_STATE_YWC = 3;
|
|
public static final Map<Integer, String> mapCI_HEALTH_PLAN_TIMER_STATE = new LinkedHashMap<Integer, String>();
|
static {
|
mapCI_HEALTH_PLAN_TIMER_STATE.put(CI_HEALTH_PLAN_TIMER_STATE_WJX, "未进行");
|
mapCI_HEALTH_PLAN_TIMER_STATE.put(CI_HEALTH_PLAN_TIMER_STATE_JXZ, "进行中");
|
mapCI_HEALTH_PLAN_TIMER_STATE.put(CI_HEALTH_PLAN_TIMER_STATE_YWC, "已完成");
|
}
|
|
public static String getmapmapCI_HEALTH_PLAN_TIMER_STATE_Label(Integer i) {
|
return mapCI_HEALTH_PLAN_TIMER_STATE.get(i);
|
}
|
/**
|
* 健康检查流转配置
|
*/
|
public final static String HEALTH_DISPATCH = "4fdb7021efbb4ca7af10bed8240dd03e"; //人员指派
|
public final static String HEALTH_PATROL = "22b2d7566757431184edc41188dc4eda"; //工程师执行
|
public final static String HEALTH_APPROVE = "2030516780214b1d9e831a47bec430b8"; //项目经理审核
|
|
public static final Map<String, String> healthNode = new LinkedHashMap<String, String>();
|
static {
|
healthNode.put(HEALTH_DISPATCH, "人员指派");
|
healthNode.put(HEALTH_PATROL, "工程师执行");
|
healthNode.put(HEALTH_APPROVE, "项目经理审核");
|
}
|
|
/**
|
* 驻场监督卡审核状态
|
*/
|
public static final Integer AUDITING_SATIS_INFO_STATE_DSH = 1;
|
public static final Integer AUDITING_SATIS_INFO_STATE_DDC = 2;
|
public static final Integer AUDITING_SATIS_INFO_STATE_YDC = 3;
|
public static final Integer AUDITING_SATIS_INFO_STATE_BTG = 4;
|
|
public static final Map<Integer, String> mapAUDITING_SATIS_INFO_STATE = new LinkedHashMap<Integer, String>();
|
static {
|
mapAUDITING_SATIS_INFO_STATE.put(AUDITING_SATIS_INFO_STATE_DSH, "待审批");
|
mapAUDITING_SATIS_INFO_STATE.put(AUDITING_SATIS_INFO_STATE_DDC, "待调查");
|
mapAUDITING_SATIS_INFO_STATE.put(AUDITING_SATIS_INFO_STATE_YDC, "已调查");
|
mapAUDITING_SATIS_INFO_STATE.put(AUDITING_SATIS_INFO_STATE_BTG, "审批不通过");
|
}
|
|
public static String getmapAUDITING_SATIS_INFO_STATE_Label(Integer i) {
|
return mapAUDITING_SATIS_INFO_STATE.get(i);
|
}
|
|
public static final Integer CI_REMIND_DETAIL_STATE_ONE=1;
|
public static final Integer CI_REMIND_DETAIL_STATE_TWO=2;
|
public static final Integer CI_REMIND_DETAIL_STATE_THREE=3;
|
public static final Map<Integer, String> CI_REMIND_DETAIL_STATE = new LinkedHashMap<Integer, String>();
|
static {
|
CI_REMIND_DETAIL_STATE.put(CI_REMIND_DETAIL_STATE_ONE, "完成");
|
CI_REMIND_DETAIL_STATE.put(CI_REMIND_DETAIL_STATE_TWO, "未完成");
|
CI_REMIND_DETAIL_STATE.put(CI_REMIND_DETAIL_STATE_THREE, "待执行");
|
}
|
public static String getmapCI_REMIND_DETAIL_STATE(Integer i) {
|
return CI_REMIND_DETAIL_STATE.get(i);
|
}
|
|
/**
|
* 配置关系常量 1=包含；2=连接；3=使用；4=安装有；
|
*/
|
public static final Integer CFG_RELATION_CONTAIN = 1;
|
public static final Integer CFG_RELATION_LINK = 2;
|
public static final Integer CFG_RELATION_USE = 3;
|
public static final Integer CFG_RELATION_HAS = 4;
|
public static final Map<Integer, String> CFG_RELATION_Map = new LinkedHashMap<Integer, String>();
|
static {
|
CFG_RELATION_Map.put(CFG_RELATION_CONTAIN, "包含");
|
CFG_RELATION_Map.put(CFG_RELATION_LINK, "连接");
|
CFG_RELATION_Map.put(CFG_RELATION_USE, "使用");
|
CFG_RELATION_Map.put(CFG_RELATION_HAS, "安装有");
|
}
|
public static String getCFG_RELATION(Integer i){
|
return CFG_RELATION_Map.get(i);
|
}
|
|
//通用使用状态-启用
|
public final static int COMMON_STATE_ENABLE = 1;
|
//通用使用状态-禁用
|
public final static int COMMON_STATE_DISABLE = 2;
|
|
public final static Map<String, String> COMMON_STATE_Map = new LinkedHashMap<String, String>();
|
static {
|
COMMON_STATE_Map.put(String.valueOf(COMMON_STATE_ENABLE), "启用");
|
COMMON_STATE_Map.put(String.valueOf(COMMON_STATE_DISABLE), "禁用");
|
}
|
|
public static String getCOMMON_STATE_Label(String key){
|
return COMMON_STATE_Map.get(key);
|
}
|
/**
|
* 健康体检设备状态
|
*/
|
public static final Integer CI_HEALTH_PLAN_CI_STATE_ZC = 1;
|
public static final Integer CI_HEALTH_PLAN_CI_STATE_GZ = 2;
|
public static final Integer CI_HEALTH_PLAN_CI_STATE_YZ = 3;
|
|
public static final Map<Integer, String> mapCI_HEALTH_PLAN_CI_STATE = new LinkedHashMap<Integer, String>();
|
static {
|
mapCI_HEALTH_PLAN_CI_STATE.put(CI_HEALTH_PLAN_CI_STATE_ZC, "正常");
|
mapCI_HEALTH_PLAN_CI_STATE.put(CI_HEALTH_PLAN_CI_STATE_GZ, "告警");
|
mapCI_HEALTH_PLAN_CI_STATE.put(CI_HEALTH_PLAN_CI_STATE_YZ, "异常");
|
}
|
|
public static String getmapCI_HEALTH_PLAN_CI_STATE_Label(Integer i) {
|
return mapCI_HEALTH_PLAN_CI_STATE.get(i);
|
}
|
|
/**
|
* 信息发送方式，1：微信;
|
*/
|
public final static Integer GG_MSG_RECORD_SEND_TYPE_WECHAT = 1;
|
|
/**
|
* 微信通知类型 1：提醒 2：催办
|
*/
|
public final static Integer GG_MSG_RECORD_INFO_TYPE_TX = 1;
|
public final static Integer GG_MSG_RECORD_INFO_TYPE_CB = 2;
|
|
/**
|
* 桌面常量--数据库标识
|
*/
|
|
public final static Map<String, String> wxDeskTopUrl = new LinkedHashMap<String, String>();
|
static {
|
wxDeskTopUrl.put("SYSADMIN", "/ewyw/emanagehome.html");//超级管理员
|
wxDeskTopUrl.put("LEADER", "/ewyw/emanagehome.html");//领导
|
wxDeskTopUrl.put("SERVICE", "/ewyw/emanagehome.html");//服务台
|
wxDeskTopUrl.put("FLINE", "/ewyw/ehome.html");//一线
|
wxDeskTopUrl.put("SLINE", "/ewyw/ehome.html");//二线
|
wxDeskTopUrl.put("TLINE", "/ewyw/ehome.html");//三线
|
wxDeskTopUrl.put("LOCATION", "/ewyw/ezchome.html");//驻场
|
wxDeskTopUrl.put("OPERATION", "/ewyw/ehome.html");//运维经理
|
wxDeskTopUrl.put("CGFADMIN", "/ewyw/emanagehome.html");//配置管理员
|
wxDeskTopUrl.put("KNOW", "/ewyw/emanagehome.html");//知识管理员
|
wxDeskTopUrl.put("MANAGE", "/ewyw/emanagehome.html");//管理层
|
}
|
|
public static String getWxDeskTopUrl(String key) {
|
return wxDeskTopUrl.get(key);
|
}
|
|
/**
|
* 文库积分规则设置【KM_SCORE_RULE】
|
* 类型【1：原创 2：编辑 3：顶 4：踩 5：置顶 6：精华】
|
*/
|
public static final Integer KM_SCORE_RULE_TYPE_YC = 1;
|
public static final Integer KM_SCORE_RULE_TYPE_BJ = 2;
|
public static final Integer KM_SCORE_RULE_TYPE_D = 3;
|
public static final Integer KM_SCORE_RULE_TYPE_C = 4;
|
public static final Integer KM_SCORE_RULE_TYPE_ZJ = 5;
|
public static final Integer KM_SCORE_RULE_TYPE_JH = 6;
|
|
public static final Map<Integer, String> mapKM_SCORE_RULE_TYPE = new LinkedHashMap<Integer, String>();
|
static {
|
mapKM_SCORE_RULE_TYPE.put(KM_SCORE_RULE_TYPE_YC, "原创");
|
mapKM_SCORE_RULE_TYPE.put(KM_SCORE_RULE_TYPE_BJ, "编辑");
|
mapKM_SCORE_RULE_TYPE.put(KM_SCORE_RULE_TYPE_D, "顶");
|
mapKM_SCORE_RULE_TYPE.put(KM_SCORE_RULE_TYPE_C, "踩");
|
mapKM_SCORE_RULE_TYPE.put(KM_SCORE_RULE_TYPE_ZJ, "置顶");
|
mapKM_SCORE_RULE_TYPE.put(KM_SCORE_RULE_TYPE_JH, "精华");
|
}
|
|
public static String getmapKM_SCORE_RULE_TYPE_Label(Integer i) {
|
return mapKM_SCORE_RULE_TYPE.get(i);
|
}
|
|
/**
|
* 专家等级积分设置【KM_EXPERT_LEVEL_RULE】
|
* 类型【1：初级专家 2：中级专家 3：高级专家 4：资深专家】
|
*/
|
public static final Integer KM_EXPERT_LEVEL_RULE_TYPE_CJZJ = 1;
|
public static final Integer KM_EXPERT_LEVEL_RULE_TYPE_ZJZJ = 2;
|
public static final Integer KM_EXPERT_LEVEL_RULE_TYPE_GJZJ = 3;
|
public static final Integer KM_EXPERT_LEVEL_RULE_TYPE_ZSZJ = 4;
|
|
public static final Map<Integer, String> mapKM_EXPERT_LEVEL_RULE_TYPE = new LinkedHashMap<Integer, String>();
|
static {
|
mapKM_EXPERT_LEVEL_RULE_TYPE.put(KM_EXPERT_LEVEL_RULE_TYPE_CJZJ, "初级");
|
mapKM_EXPERT_LEVEL_RULE_TYPE.put(KM_EXPERT_LEVEL_RULE_TYPE_ZJZJ, "中级");
|
mapKM_EXPERT_LEVEL_RULE_TYPE.put(KM_EXPERT_LEVEL_RULE_TYPE_GJZJ, "高级");
|
mapKM_EXPERT_LEVEL_RULE_TYPE.put(KM_EXPERT_LEVEL_RULE_TYPE_ZSZJ, "资深");
|
}
|
|
public static String getmapKM_EXPERT_LEVEL_RULE_TYPE_Label(Integer i) {
|
return mapKM_EXPERT_LEVEL_RULE_TYPE.get(i);
|
}
|
|
|
//报修记录状态【1：待响应 2：处理中 3：已处理 , 4 关闭】
|
public final static Integer REPAIR_STATE_DXY = 1;
|
public final static Integer REPAIR_STATE_CLZ = 2;
|
public final static Integer REPAIR_STATE_YCL = 3;
|
public final static Integer REPAIR_STATE_GB = 4;
|
|
public final static Map<Integer, String> REPAIR_STATE_Map = new LinkedHashMap<Integer, String>();
|
|
static {
|
REPAIR_STATE_Map.put(REPAIR_STATE_DXY, "待响应");
|
REPAIR_STATE_Map.put(REPAIR_STATE_CLZ, "处理中");
|
REPAIR_STATE_Map.put(REPAIR_STATE_YCL, "已处理");
|
REPAIR_STATE_Map.put(REPAIR_STATE_GB, "关闭");
|
}
|
|
public final static String getREPAIR_STATE(Integer i) {
|
return REPAIR_STATE_Map.get(i);
|
}
|
|
|
/**
|
* 通过二维码搜索路径
|
*/
|
public static final String QRCODE_URL = SysConfigConstants.WEBCHAT_ADDRESS+SysConfigConstants.QR_CODE_URL;
|
|
//例行巡检消息web页面链接（相对路径）
|
public final static String REMIND_WEB_MSG_URL = "/business/pages/ciremind/orderdeal/ciRemindDetail.html";
|
|
//健康检查消息web页面链接（相对路径）
|
public final static String HEALTH_WEB_MSG_URL = "/business/pages/health/healthDetail.html";
|
|
/**
|
* 微信端,详情处理操作跳转来源
|
* 【1.事件，2.问题 3.例行维护 4.健康检查】
|
* */
|
public final static Integer WECHAT_DETAIL_DEAL_SCORE_SJ = 1;
|
public final static Integer WECHAT_DETAIL_DEAL_SCORE_WT = 2;
|
public final static Integer WECHAT_DETAIL_DEAL_SCORE_LXWH = 3;
|
public final static Integer WECHAT_DETAIL_DEAL_SCORE_JKJC = 4;
|
|
public final static Map<Integer, String> mapWECHAT_DETAIL_DEAL_SCORE = new LinkedHashMap<Integer, String>();
|
|
static {
|
mapWECHAT_DETAIL_DEAL_SCORE.put(WECHAT_DETAIL_DEAL_SCORE_SJ, "事件管理");
|
mapWECHAT_DETAIL_DEAL_SCORE.put(WECHAT_DETAIL_DEAL_SCORE_WT, "问题管理");
|
mapWECHAT_DETAIL_DEAL_SCORE.put(WECHAT_DETAIL_DEAL_SCORE_LXWH, "例行维护");
|
mapWECHAT_DETAIL_DEAL_SCORE.put(WECHAT_DETAIL_DEAL_SCORE_JKJC, "健康检查");
|
}
|
|
public final static String getMapWECHAT_DETAIL_DEAL_SCORE_Label(Integer i) {
|
return mapWECHAT_DETAIL_DEAL_SCORE.get(i);
|
}
|
|
//原客户常量
|
public final static String CUSTOMER_CONSTANTS = "项目";
|
//原所属单位
|
public final static String UNIT_CONSTANTS = "子项目";
|
|
//发布管理 风险等级 数据字典标识
|
public final static String RELEASERISK = "RISK_LEVEL";
|
//发布管理 影响范围 数据字典标识
|
public final static String RELEASEIMPACT = "IMPACT";
|
public final static String RELEASESOURCE = "FBLY";
|
public final static String RELEASETYPE = "FBLX";
|
|
//发布管理 工单状态
|
public final static String SC_WORKFLOW_RELEASE_STATE_SQZ = "0"; //申请中
|
public final static String SC_WORKFLOW_RELEASE_STATE_YSL = "1"; //已受理
|
public final static String SC_WORKFLOW_RELEASE_STATE_SPZ = "2";//审批中
|
public final static String SC_WORKFLOW_RELEASE_STATE_ZXZ = "3";//执行中
|
public final static String SC_WORKFLOW_RELEASE_STATE_SHZ = "4";//审核中
|
public final static String SC_WORKFLOW_RELEASE_STATE_YWC = "9";//已完成
|
public final static String SC_WORKFLOW_RELEASE_STATE_YGB = "10";//已关闭
|
public final static String SC_WORKFLOW_RELEASE_STATE_YPJ = "11";//已评价
|
|
public static final Map<String, String> mapSC_WORKFLOW_RELEASE_STATE = new LinkedHashMap<String, String>();
|
static {
|
mapSC_WORKFLOW_RELEASE_STATE.put(SC_WORKFLOW_RELEASE_STATE_SQZ, "申请中");
|
mapSC_WORKFLOW_RELEASE_STATE.put(SC_WORKFLOW_RELEASE_STATE_YSL, "已受理");
|
mapSC_WORKFLOW_RELEASE_STATE.put(SC_WORKFLOW_RELEASE_STATE_SPZ, "审批中");
|
mapSC_WORKFLOW_RELEASE_STATE.put(SC_WORKFLOW_RELEASE_STATE_ZXZ, "执行中");
|
mapSC_WORKFLOW_RELEASE_STATE.put(SC_WORKFLOW_RELEASE_STATE_SHZ, "审核中");
|
mapSC_WORKFLOW_RELEASE_STATE.put(SC_WORKFLOW_RELEASE_STATE_YWC, "已完成");
|
mapSC_WORKFLOW_RELEASE_STATE.put(SC_WORKFLOW_RELEASE_STATE_YGB, "已关闭");
|
mapSC_WORKFLOW_RELEASE_STATE.put(SC_WORKFLOW_RELEASE_STATE_YPJ, "已评价");
|
}
|
public static String getmapSC_WORKFLOW_RELEASE_STATE(String key) {
|
return mapSC_WORKFLOW_RELEASE_STATE.get(key);
|
}
|
|
//发布管理节点模板id
|
public final static String RELEASE_APPLY = "cda08f5d6bb94df3af4bb4f8db21951c"; //发布申请
|
public final static String RELEASE_APPROVE = "6951443b43aa4235aa2a4163e25804dc"; //申请审批
|
public final static String RELEASE_NOTICE = "a180f1481853441b80e1f03630490f6b"; //发布通知
|
public final static String RELEASE_EXECUTE = "9a4fce7b4ec14b4e91336b5c9bc2d37b"; //发布执行
|
public final static String RELEASE_APPROVAL = "a908ebcaf9014ef59809ff834aae47cb"; //发布审核
|
public final static String RELEASE_REVIEW = "0a8e06637b5e4f19aa4c8ff2fa0dfb6f"; //关键用户确认
|
|
public static final Map<String, String> mapRELEASE_NODE = new LinkedHashMap<String, String>();
|
static {
|
mapRELEASE_NODE.put(RELEASE_APPLY, "发布申请");
|
mapRELEASE_NODE.put(RELEASE_APPROVE, "申请审批");
|
mapRELEASE_NODE.put(RELEASE_NOTICE, "发布通知");
|
mapRELEASE_NODE.put(RELEASE_EXECUTE, "发布执行");
|
mapRELEASE_NODE.put(RELEASE_APPROVAL, "发布审核");
|
mapRELEASE_NODE.put(RELEASE_REVIEW, "关键用户确认");
|
}
|
public static String getmapRELEASE_NODE(String key) {
|
return mapRELEASE_NODE.get(key);
|
}
|
/**
|
* 变更状态（1=已登记；2=变更受理；3=变更审批；4=变更CCB评审；5=变更执行；6=变更审核；7=变更回顾；9=已解决；10=已关闭；11=已评价；）
|
*/
|
public final static String SC_WORKFLOW_CHANGE_STATE_YDJ = "1"; //已登记
|
public final static String SC_WORKFLOW_CHANGE_STATE_BGSL = "2";//变更受理
|
public final static String SC_WORKFLOW_CHANGE_STATE_BGSP = "3";//变更审批
|
public final static String SC_WORKFLOW_CHANGE_STATE_CCBSP= "4";//变更CCB评审
|
public final static String SC_WORKFLOW_CHANGE_STATE_BGZX= "5";//变更执行
|
public final static String SC_WORKFLOW_CHANGE_STATE_BGSH= "6";//变更审核
|
public final static String SC_WORKFLOW_CHANGE_STATE_BGHG= "7";//变更回顾
|
public final static String SC_WORKFLOW_CHANGE_STATE_YJJ = "9";//已解决
|
public final static String SC_WORKFLOW_CHANGE_STATE_YGB = "10";//已关闭
|
public final static String SC_WORKFLOW_CHANGE_STATE_YPJ = "11";//已评价
|
|
public static final Map<String, String> mapSC_WORKFLOW_CHANGE_STATE = new LinkedHashMap<String, String>();
|
static {
|
mapSC_WORKFLOW_CHANGE_STATE.put(SC_WORKFLOW_CHANGE_STATE_YDJ, "已登记");
|
mapSC_WORKFLOW_CHANGE_STATE.put(SC_WORKFLOW_CHANGE_STATE_BGSL, "变更受理");
|
mapSC_WORKFLOW_CHANGE_STATE.put(SC_WORKFLOW_CHANGE_STATE_BGSP, "变更审批");
|
mapSC_WORKFLOW_CHANGE_STATE.put(SC_WORKFLOW_CHANGE_STATE_CCBSP, "变更CCB评审");
|
mapSC_WORKFLOW_CHANGE_STATE.put(SC_WORKFLOW_CHANGE_STATE_BGZX, "变更执行");
|
mapSC_WORKFLOW_CHANGE_STATE.put(SC_WORKFLOW_CHANGE_STATE_BGSH, "变更审核");
|
mapSC_WORKFLOW_CHANGE_STATE.put(SC_WORKFLOW_CHANGE_STATE_BGHG, "变更回顾");
|
mapSC_WORKFLOW_CHANGE_STATE.put(SC_WORKFLOW_CHANGE_STATE_YJJ, "已解决");
|
mapSC_WORKFLOW_CHANGE_STATE.put(SC_WORKFLOW_CHANGE_STATE_YGB, "已取消");
|
mapSC_WORKFLOW_CHANGE_STATE.put(SC_WORKFLOW_CHANGE_STATE_YPJ, "已评价");
|
}
|
|
public static String getmapSC_WORKFLOW_CHANGE_STATE_Label(String key) {
|
return mapSC_WORKFLOW_CHANGE_STATE.get(key);
|
}
|
/**
|
* 变更来源，1：事件；2:问题;3:配置；4:其它；
|
*/
|
public final static Integer SC_WORKFLOW_CI_CHANGE_CHANGE_SOURCE_EVENT = 1;
|
public final static Integer SC_WORKFLOW_CI_CHANGE_CHANGE_SOURCE_QUESTION = 2;
|
public final static Integer SC_WORKFLOW_CI_CHANGE_CHANGE_SOURCE_CONFIGURE = 3;
|
public final static Integer SC_WORKFLOW_CI_CHANGE_CHANGE_SOURCE_OTHER = 4;
|
|
public static final Map<String, String> mapSC_WORKFLOW_CI_CHANGE_CHANGE_SOURCE = new LinkedHashMap<String, String>();
|
static {
|
mapSC_WORKFLOW_CI_CHANGE_CHANGE_SOURCE.put(SC_WORKFLOW_CI_CHANGE_CHANGE_SOURCE_EVENT.toString(), "事件");
|
mapSC_WORKFLOW_CI_CHANGE_CHANGE_SOURCE.put(SC_WORKFLOW_CI_CHANGE_CHANGE_SOURCE_QUESTION.toString(), "问题");
|
mapSC_WORKFLOW_CI_CHANGE_CHANGE_SOURCE.put(SC_WORKFLOW_CI_CHANGE_CHANGE_SOURCE_CONFIGURE.toString(), "配置");
|
mapSC_WORKFLOW_CI_CHANGE_CHANGE_SOURCE.put(SC_WORKFLOW_CI_CHANGE_CHANGE_SOURCE_OTHER.toString(), "其他");
|
}
|
|
/**
|
* 变更来源数据字典标识
|
*/
|
public final static String CHANGE_SOURCE = "CHANGE_SOURCE";
|
|
/**
|
* 变更类型（1=简单变更；2=标准变更；3=紧急变更）
|
*/
|
public final static String SC_WORKFLOW_CHANGE_TYPE_JDBG = "1"; //简单变更
|
public final static String SC_WORKFLOW_CHANGE_TYPE_BZBG = "2";//标准变更
|
public final static String SC_WORKFLOW_CHANGE_TYPE_JJBG = "3";//紧急变更
|
|
public static final Map<String, String> mapSC_WORKFLOW_CHANGE_TYPE = new LinkedHashMap<String, String>();
|
static {
|
mapSC_WORKFLOW_CHANGE_TYPE.put(SC_WORKFLOW_CHANGE_TYPE_JDBG, "简单变更");
|
mapSC_WORKFLOW_CHANGE_TYPE.put(SC_WORKFLOW_CHANGE_TYPE_BZBG, "标准变更");
|
mapSC_WORKFLOW_CHANGE_TYPE.put(SC_WORKFLOW_CHANGE_TYPE_JJBG, "紧急变更");
|
}
|
|
public static String getmapSC_WORKFLOW_TYPE_Label(String key) {
|
return mapSC_WORKFLOW_CHANGE_TYPE.get(key);
|
}
|
|
/**
|
* 变更风险等级数据字典标识
|
*/
|
public final static String CHANGE_RISK = "CHANGE_RISK";
|
|
/**
|
* 变更影响度数据字典标识
|
*/
|
public final static String CHANGE_EFFECT = "CHANGE_EFFECT";
|
|
|
/**
|
* 标准变更管理环节流转配置
|
*/
|
public final static String BGSQ = "2943c195af31497e8d07ddca302f155a"; //变更申请
|
public final static String BGSL = "672fe02e2a144b64be33a534ed674766"; //变更受理
|
public final static String CCBSP = "6f821b80e5d8424984878b7dad1979d9"; //CCB评审
|
public final static String BGSP = "9dc7fc390f454f21b481251d2852f45e"; //变更审批
|
public final static String BGZX = "9d96d4ed42ae4d189da6396ca5cfe673"; //变更分派
|
public final static String BGSH = "2b5342fef5164a8eaff07a55bad54d4a"; //变更执行
|
public final static String BGHG = "a2189929b04246b59de1011a6a0ed209"; //结果审批
|
|
|
public static final Map<String, String> changeNode = new LinkedHashMap<String, String>();
|
static {
|
changeNode.put(BGSQ, "变更申请");
|
changeNode.put(BGSL, "变更受理");
|
changeNode.put(CCBSP, "CCB评审");
|
changeNode.put(BGSP, "变更审批");
|
changeNode.put(BGZX, "变更分派");
|
changeNode.put(BGSH, "变更执行");
|
changeNode.put(BGHG, "结果审批");
|
}
|
|
public static String getchangeNodeLabel(String key) {
|
return changeNode.get(key);
|
}
|
|
/**
|
* 变更关闭解决方式数据字典标识
|
*/
|
public final static String CHANGE_CLOSE_TYPE = "CHANGE_CLOSE_TYPE";
|
|
/**
|
* 变更结束解决方式数据字典标识
|
*/
|
public final static String CHANGE_END_TYPE = "CHANGE_END_TYPE";
|
|
// public final static String SC_WORKFLOW_CHANGE_STATE_YJJ = "9";//已解决
|
// public final static String SC_WORKFLOW_CHANGE_STATE_YGB = "10";//已关闭
|
|
/**
|
* 通用的紧急程度，1：非常紧急；2：紧急；3：一般；4：不紧急
|
*/
|
public final static Integer COMMON_URGENT_DEGREE_VERY = 1;
|
public final static Integer COMMON_URGENT_DEGREE_URGENT = 2;
|
public final static Integer COMMON_URGENT_DEGREE_GENERAL = 3;
|
public final static Integer COMMON_URGENT_DEGREE_NOT = 4;
|
|
public static final Map<Integer, String> mapCOMMON_URGENT_DEGREE = new LinkedHashMap<Integer, String>();
|
static {
|
mapCOMMON_URGENT_DEGREE.put(COMMON_URGENT_DEGREE_VERY, "非常紧急");
|
mapCOMMON_URGENT_DEGREE.put(COMMON_URGENT_DEGREE_URGENT, "紧急");
|
mapCOMMON_URGENT_DEGREE.put(COMMON_URGENT_DEGREE_GENERAL, "一般");
|
mapCOMMON_URGENT_DEGREE.put(COMMON_URGENT_DEGREE_NOT, "不紧急");
|
}
|
|
public static String getmapCOMMON_URGENT_DEGREE_Label(Integer i) {
|
return mapCOMMON_URGENT_DEGREE.get(i);
|
}
|
|
/**
|
* 采集环节流转配置
|
*/
|
public final static String COLLECTIONTYPE = "CJLX"; //采集类型数据字典标识
|
public final static String CIADD_APPLY = "7bf2a11930af402d9b8a246c8931df30"; //采集申请
|
public final static String CIADD_APPROVE = "7b5ce3f1c7bf4eab8ddb18d3a781ceef"; //项目经理审批
|
public final static String CIADD_COLLECTION = "0eb121bb9532459b8c09c16629483540"; //设备采集
|
public final static String CIADD_CONFIRM = "a6e9147e1a524e669e06f6dccaeb4997"; //项目经理确认
|
public final static String CIADD_ADMIN = "2502826193b04b9197703e0a52d2950d"; //配置管理员确认
|
public final static String CIADD_NODETYPE_START = "START"; //开始环节
|
public final static String CIADD_NODETYPE_APPROVE = "APPROVE"; //采集申请审批
|
public final static String CIADD_NODETYPE_COLLECTION = "COLLECTION"; //设备采集
|
public final static String CIADD_NODETYPE_CONFIRM = "CONFIRM"; //采集结果确认
|
public final static String CIADD_NODETYPE_ADMIN_CONFIRM = "ADMIN_CONFIRM"; //配置管理员确认
|
public final static String CIADD_NODETYPE_END = "END"; //结束环节
|
|
public static final Map<String, String> ciAddNode = new LinkedHashMap<String, String>();
|
static {
|
ciAddNode.put(CIADD_APPLY, "采集申请");
|
ciAddNode.put(CIADD_APPROVE, "采集申请审批");
|
ciAddNode.put(CIADD_COLLECTION, "配置采集");
|
ciAddNode.put(CIADD_CONFIRM, "采集结果确认");
|
ciAddNode.put(CIADD_ADMIN, "配置管理员确认");
|
}
|
|
public static String getCiAddNode(String key) {
|
return ciAddNode.get(key);
|
}
|
/**
|
* 变更文件夹编号
|
*/
|
public final static String GG_FOLDERS_BGFOLDERS = "bgfolders";
|
|
//入库状态【1新增，2待审核 3 审核通过 4 审核不通过 】
|
public final static int SPARE_PART_STORAGE_STATE_Z = 1;//新增
|
public final static int SPARE_PART_STORAGE_STATE_D = 2;//待审核
|
public final static int SPARE_PART_STORAGE_STATE_T = 3;//审核通过
|
public final static int SPARE_PART_STORAGE_STATE_N = 4;//审核不通过
|
public final static Map<Integer, String> SPARE_PART_STORAGE_STATE_MAP = new LinkedHashMap<Integer, String>();
|
static {
|
SPARE_PART_STORAGE_STATE_MAP.put(SPARE_PART_STORAGE_STATE_Z, "新增");
|
SPARE_PART_STORAGE_STATE_MAP.put(SPARE_PART_STORAGE_STATE_D, "待审核");
|
SPARE_PART_STORAGE_STATE_MAP.put(SPARE_PART_STORAGE_STATE_T, "审核通过");
|
SPARE_PART_STORAGE_STATE_MAP.put(SPARE_PART_STORAGE_STATE_N, "审核不通过");
|
|
}
|
public static String getSPARE_PART_STORAGE_STATE(Integer key){
|
return SPARE_PART_STORAGE_STATE_MAP.get(key);
|
}
|
//备件状态状态【0 删除，1正常 2 报损 3 已出库】
|
public final static int SPARE_PART_STATE_S = 0;//删除
|
public final static int SPARE_PART_STATE_Z = 1;//正常
|
public final static int SPARE_PART_STATE_H = 2;//报损
|
public final static int SPARE_PART_STATE_C = 3;//已出库
|
// public final static int SPARE_PART_STATE_D = 4;//待出库
|
public final static int SPARE_PART_STATE_X = 5;//新增
|
public final static Map<Integer, String> SPARE_PART_STATE_MAP = new LinkedHashMap<Integer, String>();
|
static {
|
SPARE_PART_STATE_MAP.put(SPARE_PART_STATE_S, "删除");
|
SPARE_PART_STATE_MAP.put(SPARE_PART_STATE_Z, "正常");
|
SPARE_PART_STATE_MAP.put(SPARE_PART_STATE_H, "报损");
|
SPARE_PART_STATE_MAP.put(SPARE_PART_STATE_C, "已出库");
|
//SPARE_PART_STATE_MAP.put(SPARE_PART_STATE_D, "待出库");
|
SPARE_PART_STATE_MAP.put(SPARE_PART_STATE_X, "新增");
|
}
|
public static String getSPARE_PART_STATE(Integer key){
|
return SPARE_PART_STATE_MAP.get(key);
|
}
|
|
//申领申请状态【0 删除 1新增，2待审核 3待出库 4 待确认 5 申领成功 6申领失败 】
|
public final static int SPARE_PART_APPLY_STATE_X = 1;//新增
|
public final static int SPARE_PART_APPLY_STATE_S = 2;//待审核
|
public final static int SPARE_PART_APPLY_STATE_C = 3;//待出库
|
public final static int SPARE_PART_APPLY_STATE_Q = 4;//待确认
|
public final static int SPARE_PART_APPLY_STATE_T = 5;// 申领成功
|
public final static int SPARE_PART_APPLY_STATE_N = 6;//申领失败
|
public final static int SPARE_PART_APPLY_STATE_B = 7;//审核不通过
|
public final static Map<Integer, String> SPARE_PART_APPLY_STATE_MAP = new LinkedHashMap<Integer, String>();
|
static {
|
SPARE_PART_APPLY_STATE_MAP.put(SPARE_PART_APPLY_STATE_X, "新增");
|
SPARE_PART_APPLY_STATE_MAP.put(SPARE_PART_APPLY_STATE_S, "待审核");
|
SPARE_PART_APPLY_STATE_MAP.put(SPARE_PART_APPLY_STATE_C, "待出库");
|
SPARE_PART_APPLY_STATE_MAP.put(SPARE_PART_APPLY_STATE_Q, "待确认");
|
SPARE_PART_APPLY_STATE_MAP.put(SPARE_PART_APPLY_STATE_T, "申领成功");
|
SPARE_PART_APPLY_STATE_MAP.put(SPARE_PART_APPLY_STATE_N, "申领失败");
|
SPARE_PART_APPLY_STATE_MAP.put(SPARE_PART_APPLY_STATE_B, "审核不通过");
|
|
}
|
public static String getSPARE_PART_APPLY_STATE(Integer key){
|
return SPARE_PART_APPLY_STATE_MAP.get(key);
|
}
|
|
//出库状态【0 删除 1新增，2待审核 3 审核通过 4 审核不通过 】
|
// public final static int SPARE_PART_DELIVERY_STATE_C = 0;//删除
|
public final static int SPARE_PART_DELIVERY_STATE_X = 1;//新增
|
public final static int SPARE_PART_DELIVERY_STATE_S = 2;//待审核
|
public final static int SPARE_PART_DELIVERY_STATE_T = 3;//审核通过
|
public final static int SPARE_PART_DELIVERY_STATE_N = 4;// 审核不通过
|
public final static Map<Integer, String> SPARE_PART_DELIVERY_STATE_MAP = new LinkedHashMap<Integer, String>();
|
static {
|
//SPARE_PART_DELIVERY_STATE_MAP.put(SPARE_PART_DELIVERY_STATE_C, "删除");
|
SPARE_PART_DELIVERY_STATE_MAP.put(SPARE_PART_DELIVERY_STATE_X, "新增");
|
SPARE_PART_DELIVERY_STATE_MAP.put(SPARE_PART_DELIVERY_STATE_S, "待审核");
|
SPARE_PART_DELIVERY_STATE_MAP.put(SPARE_PART_DELIVERY_STATE_T, "审核通过");
|
SPARE_PART_DELIVERY_STATE_MAP.put(SPARE_PART_DELIVERY_STATE_N, "审核不通过");
|
|
}
|
public static String getSPARE_PART_DELIVERY_STATE(Integer key){
|
return SPARE_PART_DELIVERY_STATE_MAP.get(key);
|
}
|
|
/**
|
* 出库环节流转配置
|
*/
|
public final static String CKSQ = "ed2c874415f247d9a31b81c1506cc6a1"; //出库申请
|
public final static String CKSH = "ed2c874415f247d9a31b81c1506cc6a2"; //出库审核
|
|
/**
|
* 库存盘点
|
*/
|
public final static String PDXZ = "ed2c874415f247d9a3cc81c1506cc6af"; //新增盘点
|
public final static String PDSH = "ed2c874415f247d9a3dd81c1506cc6ah"; //盘点审核
|
|
|
|
public final static Map<Integer, String> KCPD_STATE_MAP = new LinkedHashMap<Integer, String>();
|
public final static int KCPD_STATE_DEL = 0; //删除
|
public final static int KCPD_STATE_ADD = 1;//新增
|
public final static int KCPD_STATE_DSH = 2;//待审核
|
public final static int KCPD_STATE_TG = 3;//审核通过
|
public final static int KCPD_STATE_NTG = 4;//审核不通过
|
static {
|
KCPD_STATE_MAP.put(KCPD_STATE_DEL, "删除");
|
KCPD_STATE_MAP.put(KCPD_STATE_ADD, "新增");
|
KCPD_STATE_MAP.put(KCPD_STATE_DSH, "待审核");
|
KCPD_STATE_MAP.put(KCPD_STATE_TG, "审核通过");
|
KCPD_STATE_MAP.put(KCPD_STATE_NTG, "审核不通过");
|
|
}
|
public static String getKCPD_STATE(Integer key){
|
return KCPD_STATE_MAP.get(key);
|
}
|
|
|
/**
|
* 报损报溢
|
*/
|
public final static String BSBYSQ = "ed2c874415f247d9a3dd81c1506cc6ag"; //报损报溢申请
|
public final static String BSBYSH = "ed2c874415f247d9a3dd81c1506cc6ai"; //报损报溢审核
|
|
//报损报溢业务类型 【1报损 2报溢 】
|
public final static int OVERAGE_LOSS_BUS_TYPE_BS = 1;//报损
|
public final static int OVERAGE_LOSS_BUS_TYPE_BY = 2;//报溢
|
public final static Map<Integer, String> OVERAGE_LOSS_BUS_TYPE_MAP = new LinkedHashMap<Integer, String>();
|
static {
|
OVERAGE_LOSS_BUS_TYPE_MAP.put(OVERAGE_LOSS_BUS_TYPE_BS, "报损");
|
OVERAGE_LOSS_BUS_TYPE_MAP.put(OVERAGE_LOSS_BUS_TYPE_BY, "报溢");
|
|
|
}
|
public static String getOVERAGE_LOSS_BUS_TYPE(Integer key){
|
return OVERAGE_LOSS_BUS_TYPE_MAP.get(key);
|
}
|
|
//报损报溢状态【0 删除 1新增，2待审核 3 审核通过 4 审核不通过 】
|
public final static int OVERAGE_LOSS_STATE_S = 0;//删除
|
public final static int OVERAGE_LOSS_STATE_X = 1;//新增
|
public final static int OVERAGE_LOSS_STATE_D = 2;//待审核
|
public final static int OVERAGE_LOSS_STATE_T = 3;//审核通过
|
public final static int OVERAGE_LOSS_STATE_N = 4;//审核不通过
|
public final static Map<Integer, String> OVERAGE_LOSS_STATE_MAP = new LinkedHashMap<Integer, String>();
|
static {
|
OVERAGE_LOSS_STATE_MAP.put(OVERAGE_LOSS_STATE_S, "删除");
|
OVERAGE_LOSS_STATE_MAP.put(OVERAGE_LOSS_STATE_X, "新增");
|
OVERAGE_LOSS_STATE_MAP.put(OVERAGE_LOSS_STATE_D, "待审核");
|
OVERAGE_LOSS_STATE_MAP.put(OVERAGE_LOSS_STATE_T, "审核通过 ");
|
OVERAGE_LOSS_STATE_MAP.put(OVERAGE_LOSS_STATE_N, "审核不通过 ");
|
|
|
}
|
public static String getOVERAGE_LOSS_STATE(Integer key){
|
return OVERAGE_LOSS_STATE_MAP.get(key);
|
}
|
|
public final static String RKSH_BTGYY = "RKSH_REFUSE";
|
public final static String CKSH_BTGYY = "CKBTGYY";
|
public final static String BJSQ_BTGYY = "BJSLBTGYY";
|
public final static String BS_RESULT = "BS_RESULT";
|
//库存盘点不通过原因
|
public final static String KCPD_APPROVE_RESULT = "KCPD_APPROVE_RESULT";
|
//报溢不通过原因
|
public final static String BY_RESULT = "BY_RESULT";
|
|
|
|
|
|
//演练类型
|
public final static String DRILL_TYPE_ACTUAL = "1";//实际演练
|
public final static String DRILL_TYPE_DESK = "2";//桌面演练
|
public final static String DRILL_TYPE_DISCUSS = "3";//提问讨论是演练
|
public final static Map<String, String> DRILL_TYPE_MAP = new LinkedHashMap<String, String>();
|
static {
|
DRILL_TYPE_MAP.put(DRILL_TYPE_ACTUAL, "实际演练");
|
DRILL_TYPE_MAP.put(DRILL_TYPE_DESK, "桌面演练");
|
DRILL_TYPE_MAP.put(DRILL_TYPE_DISCUSS, "提问讨论是演练");
|
}
|
public static String getDRILL_TYPE(String key){
|
return DRILL_TYPE_MAP.get(key);
|
}
|
//预案类型
|
public final static String PLAN_TYPE_ALL = "1";//全部预案
|
public final static String PLAN_TYPE_DEPT = "2";//部门预案
|
public final static Map<String, String> PLAN_TYPE_MAP = new LinkedHashMap<String, String>();
|
static {
|
PLAN_TYPE_MAP.put(PLAN_TYPE_ALL, "全部预案");
|
PLAN_TYPE_MAP.put(PLAN_TYPE_DEPT, "部门预案");
|
}
|
public static String getPLAN_TYPE(String key){
|
return PLAN_TYPE_MAP.get(key);
|
}
|
//适宜性
|
public final static String DRILL_SUITABLE_ALL = "1";//全部能够执行
|
public final static String DRIL_SUITABLE_NO = "2";//执行过程不够顺利
|
public final static String DRIL_SUITABLE_NOS = "3";//明显不适宜
|
public final static Map<String, String> DRIL_SUITABLE_MAP = new LinkedHashMap<String, String>();
|
static {
|
DRIL_SUITABLE_MAP.put(DRILL_SUITABLE_ALL, "全部能够执行");
|
DRIL_SUITABLE_MAP.put(DRIL_SUITABLE_NO, "执行过程不够顺利");
|
DRIL_SUITABLE_MAP.put(DRIL_SUITABLE_NOS, "明显不适宜");
|
}
|
public static String getDRIL_SUITABLE(String key){
|
return DRIL_SUITABLE_MAP.get(key);
|
}
|
//适宜性
|
public final static String DRILL_FULL_ALL = "1";//完全满足应急要求
|
public final static String DRIL_FULL_BASE = "2";//基本满足需要完善
|
public final static String DRIL_FULL_NO = "3";//不充分，必须修改
|
public final static Map<String, String> DRIL_FULL_MAP = new LinkedHashMap<String, String>();
|
static {
|
DRIL_FULL_MAP.put(DRILL_FULL_ALL, "完全满足应急要求");
|
DRIL_FULL_MAP.put(DRIL_FULL_BASE, "基本满足需要完善");
|
DRIL_FULL_MAP.put(DRIL_FULL_NO, "不充分，必须修改");
|
}
|
public static String getDRIL_FULL(String key){
|
return DRIL_FULL_MAP.get(key);
|
}
|
//人员到场情况
|
public final static String DRILL_PERSON_ONE_ONE = "1";//迅速准确
|
public final static String DRILL_PERSON_ONE_TWO = "2";//基本按时到位
|
public final static String DRILL_PERSON_ONE_THREE = "3";//个别人员不到位
|
public final static String DRILL_PERSON_ONE_FOUR = "4";//重点部位人员不到位
|
public final static Map<String, String> DRILL_PERSON_ONE_MAP = new LinkedHashMap<String, String>();
|
static {
|
DRILL_PERSON_ONE_MAP.put(DRILL_PERSON_ONE_ONE, "迅速准确");
|
DRILL_PERSON_ONE_MAP.put(DRILL_PERSON_ONE_TWO, "基本按时到位");
|
DRILL_PERSON_ONE_MAP.put(DRILL_PERSON_ONE_THREE, "个别人员不到位");
|
DRILL_PERSON_ONE_MAP.put(DRILL_PERSON_ONE_FOUR, "重点部位人员不到位");
|
}
|
public static String getDRILL_PERSON_ONE(String key){
|
return DRILL_PERSON_ONE_MAP.get(key);
|
}
|
public final static String DRILL_PERSON_TWO_ONE = "1";//职责明确，操作熟练
|
public final static String DRILL_PERSON_TWO_TWO = "2";//职责明确，操作不够熟练
|
public final static String DRILL_PERSON_TWO_THREE = "3";//职责不明，操作不熟练
|
public final static Map<String, String> DRILL_PERSON_TWO_MAP = new LinkedHashMap<String, String>();
|
static {
|
DRILL_PERSON_TWO_MAP.put(DRILL_PERSON_TWO_ONE, "职责明确，操作熟练");
|
DRILL_PERSON_TWO_MAP.put(DRILL_PERSON_TWO_TWO, "职责明确，操作不够熟练");
|
DRILL_PERSON_TWO_MAP.put(DRILL_PERSON_TWO_THREE, "职责不明，操作不熟练");
|
}
|
public static String getDRILL_PERSON_TWO(String key){
|
return DRILL_PERSON_TWO_MAP.get(key);
|
}
|
//演练准备情况-现场物资
|
public final static String DRILL_MATERIAL_ONE = "1";//现场物资充分，全部有效
|
public final static String DRILL_MATERIAL_TWO = "2";//现场准备不充分
|
public final static String DRILL_MATERIAL_THREE = "3";//现场物资严重缺乏
|
public final static Map<String, String> DRILL_MATERIAL_MAP = new LinkedHashMap<String, String>();
|
static {
|
DRILL_MATERIAL_MAP.put(DRILL_MATERIAL_ONE, "现场物资充分，全部有效");
|
DRILL_MATERIAL_MAP.put(DRILL_MATERIAL_TWO, "现场准备不充分");
|
DRILL_MATERIAL_MAP.put(DRILL_MATERIAL_THREE, "现场物资严重缺乏");
|
}
|
public static String getDRILL_MATERIAL(String key){
|
return DRILL_MATERIAL_MAP.get(key);
|
}
|
//演练准备情况-个人防护
|
public final static String DRILL_PROTECT_ONE = "1";//现场物资充分，全部有效
|
public final static String DRILL_PROTECT_TWO = "2";//现场准备不充分
|
public final static String DRILL_PROTECT_THREE = "3";//现场物资严重缺乏
|
public final static Map<String, String> DRILL_PROTECT_MAP = new LinkedHashMap<String, String>();
|
static {
|
DRILL_PROTECT_MAP.put(DRILL_PROTECT_ONE, "全部人员防护到位");
|
DRILL_PROTECT_MAP.put(DRILL_PROTECT_TWO, "个别人员防护不到位");
|
DRILL_PROTECT_MAP.put(DRILL_PROTECT_THREE, "大部分人员防护不到位");
|
}
|
public static String getDRILL_PROTECT(String key){
|
return DRILL_PROTECT_MAP.get(key);
|
}
|
//协调组织情况-整体组织
|
public final static String DRILL_ZTZZ_ONE = "1";//准确、高效
|
public final static String DRILL_ZTZZ_TWO = "2";//协调基本顺利，能满足要求
|
public final static String DRILL_ZTZZ_THREE = "3";//效率低，有待改进
|
public final static Map<String, String> DRILL_ZTZZ_MAP = new LinkedHashMap<String, String>();
|
static {
|
DRILL_ZTZZ_MAP.put(DRILL_ZTZZ_ONE, "准确、高效");
|
DRILL_ZTZZ_MAP.put(DRILL_ZTZZ_TWO, "协调基本顺利，能满足要求");
|
DRILL_ZTZZ_MAP.put(DRILL_ZTZZ_THREE, "效率低，有待改进");
|
}
|
public static String getDRILL_ZTZZ(String key){
|
return DRILL_ZTZZ_MAP.get(key);
|
}
|
//协调组织情况-应急组分工
|
public final static String DRILL_YJFG_ONE = "1";//合理、高效
|
public final static String DRILL_YJFG_TWO = "2";//基本合理，能完成任务
|
public final static String DRILL_YJFG_THREE = "3";//效率低，没有完成任务
|
public final static Map<String, String> DRILL_YJFG_MAP = new LinkedHashMap<String, String>();
|
static {
|
DRILL_YJFG_MAP.put(DRILL_YJFG_ONE, "合理、高效");
|
DRILL_YJFG_MAP.put(DRILL_YJFG_TWO, "基本合理，能完成任务");
|
DRILL_YJFG_MAP.put(DRILL_YJFG_THREE, "效率低，没有完成任务");
|
}
|
public static String getDRILL_YJFG(String key){
|
return DRILL_YJFG_MAP.get(key);
|
}
|
//实战效果评价
|
public final static String DRILL_PJ_ONE = "1";//报告及时
|
public final static String DRILL_PJ_TWO = "2";//联系不上
|
public final static Map<String, String> DRILL_PJ_MAP = new LinkedHashMap<String, String>();
|
static {
|
DRILL_PJ_MAP.put(DRILL_PJ_ONE, "报告及时");
|
DRILL_PJ_MAP.put(DRILL_PJ_TWO, "联系不上");
|
}
|
public static String getDRILL_PJ(String key){
|
return DRILL_PJ_MAP.get(key);
|
}
|
//外部支援部门和协作有效性-报告上级
|
public final static String DRILL_BG_ONE = "1";//达到预期目标
|
public final static String DRILL_BG_TWO = "2";//基本达到目的，部分环节有待改进
|
public final static String DRILL_BG_THREE = "3";//没有达到目标，须重新演练
|
public final static Map<String, String> DRILL_BG_MAP = new LinkedHashMap<String, String>();
|
static {
|
DRILL_BG_MAP.put(DRILL_BG_ONE, "达到预期目标");
|
DRILL_BG_MAP.put(DRILL_BG_TWO, "基本达到目的，部分环节有待改进");
|
DRILL_BG_MAP.put(DRILL_BG_THREE, "没有达到目标，须重新演练");
|
}
|
public static String getDRILL_BG(String key){
|
return DRILL_BG_MAP.get(key);
|
}
|
//外部支援部门和协作有效性-应急车支援
|
public final static String DRILL_ZY_ONE = "1";//按要求协作
|
public final static String DRILL_ZY_TWO = "2";//行动迟缓
|
public final static Map<String, String> DRILL_ZY_MAP = new LinkedHashMap<String, String>();
|
static {
|
DRILL_ZY_MAP.put(DRILL_ZY_ONE, "按要求协作");
|
DRILL_ZY_MAP.put(DRILL_ZY_TWO, "行动迟缓");
|
}
|
public static String getDRILL_ZY(String key){
|
return DRILL_ZY_MAP.get(key);
|
}
|
}
|
