1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
package com.vci.server.omd.enumtype.delegate;
 
import com.vci.server.base.exception.ExceptionLocalHandler;
import com.vci.server.cache.OMCacheProvider;
import com.vci.server.omd.enumtype.cache.EnumServerCacheUtil;
import com.vci.server.omd.enumtype.service.EnumService;
 
import java.util.ArrayList;
import java.util.List;
 
import com.vci.common.exception.VciExceptionTool;
import com.vci.corba.common.VCIError;
import com.vci.corba.omd.etm.EnumItem;
 
public class EnumTypeServerDelegate implements IEnumServerDelegate{
 
    private static EnumTypeServerDelegate instance;
    
    public static EnumTypeServerDelegate getInstance() {
        if (instance == null) {
            instance = new EnumTypeServerDelegate();
        }
        
        return instance;
    }
    
    protected VCIError getLocalVciError(String key, Throwable e) {
        VCIError error = null;
        if (e == null) {
            error = new VCIError(key, new String[0]);
        } else {
            error = new VCIError(key, new String[]{VciExceptionTool.getExceptionStr(e), VciExceptionTool.getExceptionDetail(e)});
        }
        VCIError rsError = ExceptionLocalHandler.getInstance().getLocalString(error, "PLMENUM");
        return rsError;
    }
    
    /**
     * 查询枚举
     */
    public EnumItem[] getEmItems(String filter, int start, int rows)
            throws VCIError {
        return OMCacheProvider.getEnumTypeByFilter(filter);
        //return EnumServerCacheUtil.getInstance().getEmItems(filter, start, rows);
    }
 
    /**
     * 检查枚举名是否存在
     */
    @Override
    public boolean checkRowIsExists(String name) throws VCIError {
        return OMCacheProvider.existEnumType(name);
        //return EnumServerCacheUtil.getInstance().checkRowIsExists(name);
    }
    
    /**
     * 根据枚举类型查询枚举
     */
    public EnumItem[] getEmItemsByType(String type) throws VCIError {
        EnumItem[] eis = OMCacheProvider.getEnumTypeByFilter("");
        
        EnumService es = new EnumService();
        List<EnumItem> emItemList = new ArrayList<EnumItem>();
        try{
            for (EnumItem em : eis) {
                if (type.equals(em.type)) {
                    EnumItem eiRes = es.FilterSecretGrade(em);
                    emItemList.add(eiRes);
                }
            }
        }catch(Throwable e){
            e.printStackTrace();
            throw getLocalVciError("P0010PLMENUM-00006", e);
        }
        return emItemList.toArray(new EnumItem[emItemList.size()]);
        
        //return EnumServerCacheUtil.getInstance().getEmItemsByType(type);
    }
    
    
    /**
     * 根据枚举名字查询枚举
     */
    public EnumItem getEmItemByName(String name) throws VCIError {
        return OMCacheProvider.getEnumType(name);
    }
    
    @Override
    public boolean addEmItem(EnumItem emItem) throws VCIError {
        try{
            boolean success = EnumService.getInstance().addEmItem(emItem);
            if (success) {
                EnumServerCacheUtil.setEnumType(emItem);
            }
            
            return success;
        }catch(Throwable e){
            e.printStackTrace();
            throw getLocalVciError("P0010PLMENUM-00001", e);
        }
    }
 
    @Override
    public boolean deleteEmItem(EnumItem em) throws VCIError {
        try{
            boolean success =  EnumService.getInstance().deleteEmItem(em);
            if (success) {
                EnumServerCacheUtil.delEnumType(em.name);
            }
            return success;
        }catch(Throwable e){
            e.printStackTrace();
            throw getLocalVciError("P0010PLMENUM-00003", e);
        }
    }
 
    @Override
    public boolean deleteEmItems(EnumItem[] emItems) throws VCIError {
        try{
            boolean success = EnumService.getInstance().deleteEmItems(emItems);
            if (success) {
                for (int i = 0; i < emItems.length; i++)
                    EnumServerCacheUtil.delEnumType(emItems[i].name);
            }
            return success;
        }catch(Throwable e){
            e.printStackTrace();
            throw getLocalVciError("P0010PLMENUM-00003", e);
        }
    }
 
    @Override
    public boolean modifyEmItem(EnumItem emItem) throws VCIError {
        try{
            boolean success = EnumService.getInstance().modifyEmItem(emItem);
            if (success) {
                EnumServerCacheUtil.delEnumType(emItem.name);
            }
            return success;
        }catch(Throwable e){
            e.printStackTrace();
            throw getLocalVciError("P0010PLMENUM-00002", e);
        }
    }
 
    public boolean xml2DB(String userName) throws VCIError {
        return EnumService.getInstance().xml2DB(userName);
    }
 
 
}