fff
xiejun
2024-01-05 81c8a849ed4e57141e29c62d9b3a1ffc605ece44
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
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
package com.vci.rmip.code.client.codeapply.Apply410;
 
import com.vci.base.ui.swing.VCIOptionPane;
import com.vci.base.ui.swing.components.VCIJPanel;
import com.vci.base.ui.tree.VCIBaseTree;
import com.vci.base.ui.tree.VCIBaseTreeModel;
import com.vci.base.ui.tree.VCIBaseTreeNode;
import com.vci.rmip.code.client.codeapply.Apply410.object.CodeClassify;
import com.vci.rmip.code.client.codeapply.Apply410.object.R;
import com.vci.rmip.code.client.codeapply.Apply410.object.TokenUserObject;
import com.vci.rmip.code.client.codeapply.Apply410.utils.ConfigUtils;
import com.vci.rmip.code.client.codeapply.Apply410.utils.HttpUtil;
 
import javax.swing.event.TreeExpansionEvent;
import javax.swing.event.TreeExpansionListener;
import javax.swing.event.TreeSelectionEvent;
import javax.swing.event.TreeSelectionListener;
import javax.swing.tree.TreePath;
 
import org.codehaus.jackson.JsonProcessingException;
import org.codehaus.jackson.map.ObjectMapper;
import org.codehaus.jackson.type.TypeReference;
 
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
 
public abstract class CodeApplyFor410TreePanel extends VCIJPanel {
    /**
     *
     */
    private static final long serialVersionUID = 3252637341L;
    private VCIBaseTree tree = null;
    private VCIBaseTreeModel treeModel = null;
    private VCIBaseTreeNode rootNode = null;
 
    private CodeClassify currentRmType = null;
    private TransmitTreeObject transmitTreeObject = new TransmitTreeObject();
    private TokenUserObject tokenUserObject = null;
    private VCIBaseTreeNode selNode = null;
    private String url=ConfigUtils.getConfigValue("410.code.url","http://127.0.0.1:36014/codeApplySwingController");
    /**
     * 存储分类的Map,key:分类名称,value:分类值
     */
    private String clsfName = null;
    //    private String[] clsfVal = new String[2];
    private String libName = "";
    public CodeApplyFor410TreePanel(CodeClassify currentRmType, TokenUserObject tokenUserObject, String clsfName, String libName) {
        this.currentRmType = currentRmType;
        this.tokenUserObject = tokenUserObject;
        this.clsfName = clsfName;
        this.libName = libName;
        if (this.libName == null) {
            libName = "";
        }
    }
 
    public void buildTreePanel(){
        initComponents();
    }
 
    private void initComponents(){
        initLeftPanel();
    }
 
    private void initLeftPanel() {
        rootNode = new VCIBaseTreeNode(currentRmType.getName(), currentRmType);
        treeModel = new VCIBaseTreeModel(rootNode);
        tree = new VCIBaseTree(treeModel, new CodeLibTreeCellRenderer());
        selNode = rootNode;
        if (clsfName == null || clsfName.equals("")) {
            loadTreeData(rootNode);
        } else {
            CodeClassify[] rmTypes = getRMTypeByDescAndLib();
            int len = rmTypes.length;
            addChildrenToParentTreeNode(currentRmType,rootNode,rmTypes, len - 2);
        }
 
        inittreeActions();
    }
 
    /**
     * 展开树
     * <p>Description: </p>
     *
     * @author ligang
     * @time 2013-5-8
     * @param rmTypeObj
     * @param parentNode
     */
    private void addChildrenToParentTreeNode(CodeClassify rmTypeObj, VCIBaseTreeNode parentNode, CodeClassify[] rmTypes, int pos){
        String parentId = rmTypeObj.getOid();
        CodeClassify[] libs = {};
        libs = getChildRMTypeObjects(parentId);
        for(CodeClassify obj : libs) {
            VCIBaseTreeNode node = new VCIBaseTreeNode(obj.getName(), obj);
            treeModel.insertNodeInto(node, parentNode, parentNode.getChildCount());
            node.setLeaf(false);
            node.setExpand(false);
            if (pos < 0) {
                continue;
            }
            if (checkIsSel(obj, rmTypes[pos])) {
                selNode = node;
                addChildrenToParentTreeNode(obj, node, rmTypes, pos - 1);
            }
        }
        parentNode.setLeaf(libs.length == 0);
        parentNode.setExpand(true);
        if(tree != null){
            tree.expandPath(new TreePath(selNode.getPath()));
            tree.setSelectionPath(new TreePath(selNode.getPath()));
        }
    }
 
    private void loadTreeData(VCIBaseTreeNode rootNode){
        CodeClassify currentObj = (CodeClassify) rootNode.getObj();
        String parentId = currentObj.getOid();
        CodeClassify[] libs = {};
        libs = getChildRMTypeObjects(parentId);
        for(CodeClassify obj : libs) {
            VCIBaseTreeNode node = new VCIBaseTreeNode(obj.getName(), obj);
            rootNode.add(node);
            node.setLeaf(false);
            node.setExpand(false);
        }
        rootNode.setLeaf(libs.length == 0);
        rootNode.setExpand(true);
 
        tree.setSelectionPath(new TreePath(selNode));
        tree.updateUI();
 
 
    }
 
    /**
     * 根据参数判断当前分类是否是选中状态
     * <p>Description: </p>
     *
     * @author ligang
     * @time 2013-5-8
     * @param obj
     * @return
     */
    private boolean checkIsSel(CodeClassify obj, CodeClassify selObj) {
        if(obj.getId().equals(selObj.getId())) {
            return true;
        }
        return false;
    }
 
 
    private void inittreeActions(){
        tree.addTreeSelectionListener(new TreeSelectionListener() {
            @Override
            public void valueChanged(TreeSelectionEvent e) {
                if(!e.isAddedPath()) return;
                leftTree_valueChanged(e);
            }
        });
        tree.addTreeExpansionListener(new TreeExpansionListener() {
            @Override
            public void treeExpanded(TreeExpansionEvent e) {
                tree_treeExpanded_local(e);
            }
 
            @Override
            public void treeCollapsed(TreeExpansionEvent e) {
            }
        });
    }
 
    /**
     * 根据分类描述获取传入分类的所有父分类信息
     * @return
     */
    private CodeClassify[] getRMTypeByDescAndLib() {
        CodeClassify[] objs = new CodeClassify[]{};
    //    String url= ConfigUtils.getConfigValue("410.PDM.leftdescLibNode.url","http://127.0.0.1:36014/codeApplySwingController/getRMTypeByDescAndLib");
        /**系统只加载代码项  如果libName不为空,直接获取对应的代码项**/
        Map<String,String> condtionMap=new HashMap<>();
        condtionMap.put("desc", this.clsfName);
        condtionMap.put("codeLibName",rootNode.toString());
        Map<String,String> headerMap=new HashMap<>();
        headerMap.put("Blade-Auth",this.tokenUserObject.getAccess_token());
        R r= HttpUtil.sendGet(url+"/getRMTypeByDescAndLib",condtionMap,headerMap);
        List<CodeClassify> codeClassifyList = new ArrayList<>();
        if(r.isSuccess()){
            Object object= r.getData();
            if(object!=null) {
                ObjectMapper objectMapper = new ObjectMapper();
                try {
                    codeClassifyList = objectMapper.readValue(object.toString(), new TypeReference<List<CodeClassify>>() {
                    });
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }else{
            VCIOptionPane.showMessage(this,r.getMsg());
        }
        return codeClassifyList.toArray(new CodeClassify[]{});
    }
 
    /**
     * 根据ID直接获取子分类,无权限检查
     * <p>Description: </p>
     *
     * @author xchao
     * @time 2013-3-20
     * @param parentId
     * @return
     */
    private CodeClassify[] getChildRMTypeObjects(String parentId){
    //    String url= ConfigUtils.getConfigValue("410.PDM.leftClsfNode.url","http://127.0.0.1:36014/codeApplySwingController/selectCodeClassifyVOByParentId");
        /**系统只加载代码项  如果libName不为空,直接获取对应的代码项**/
        Map<String,String> condtionMap=new HashMap<>();
        condtionMap.put("parentId", parentId );
        Map<String,String> headerMap=new HashMap<>();
        headerMap.put("Blade-Auth",this.tokenUserObject.getAccess_token());
        R r=HttpUtil.sendGet(url+"/selectCodeClassifyVOByParentId",condtionMap,headerMap);
        List<CodeClassify> codeClassifyList = new ArrayList<>();
        if(r.isSuccess()){
            Object object= r.getData();
            if(object!=null) {
                ObjectMapper objectMapper = new ObjectMapper();
                try {
                    codeClassifyList = objectMapper.readValue(object.toString(), new TypeReference<List<CodeClassify>>() {
                    });
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }else{
            VCIOptionPane.showMessage(this,r.getMsg());
        }
        return codeClassifyList.toArray(new CodeClassify[]{});
    }
    private void tree_treeExpanded_local(TreeExpansionEvent e) {
        TreePath treePath = e.getPath();
        VCIBaseTreeNode treeNode = (VCIBaseTreeNode)treePath.getLastPathComponent();
        if(treeNode.isExpand()) return;
        if(!(treeNode.getObj() instanceof CodeClassify)) return;
        CodeClassify rmTypeObject = (CodeClassify)treeNode.getObj();
        CodeClassify[] childs = null;
        childs = getChildRMTypeObjects(rmTypeObject.getOid());
        addRMTypeObjectsToParentTreeNode(childs, treeNode);
        treeNode.setExpand(true);
        treeNode.setLeaf(treeModel.getChildCount(treeNode) == 0);
    }
    private void addRMTypeObjectsToParentTreeNode(CodeClassify[] objs, VCIBaseTreeNode parentNode){
        for(CodeClassify obj : objs){
            VCIBaseTreeNode node = new VCIBaseTreeNode(obj.getName(), obj);
            treeModel.insertNodeInto(node, parentNode, treeModel.getChildCount(parentNode));
        }
    }
 
    private void leftTree_valueChanged(TreeSelectionEvent e) {
        tree_valueChanged(e);
    }
 
    /**
     * 选择了树节点的事件处理
     * <p>Description: </p>
     *
     * @author xchao
     * @time 2012-5-26
     * @param e
     */
    public abstract void tree_valueChanged(TreeSelectionEvent e);
 
    public VCIBaseTree getTree() {
        return tree;
    }
 
    public void setTree(VCIBaseTree tree) {
        this.tree = tree;
    }
 
    public VCIBaseTreeModel getTreeModel() {
        return treeModel;
    }
 
    public void setTreeModel(VCIBaseTreeModel treeModel) {
        this.treeModel = treeModel;
    }
 
    public VCIBaseTreeNode getRootNode() {
        return rootNode;
    }
 
    public void setRootNode(VCIBaseTreeNode rootNode) {
        this.rootNode = rootNode;
    }
 
    public TransmitTreeObject getTransmitTreeObject() {
        return transmitTreeObject;
    }
 
    public void setTransmitTreeObject(TransmitTreeObject transmitTreeObject) {
        this.transmitTreeObject = transmitTreeObject;
    }
 
    public VCIBaseTreeNode getSelNode() {
        return selNode;
    }
 
    public void setSelNode(VCIBaseTreeNode selNode) {
        this.selNode = selNode;
    }
}