|
7
|
1 package jp.ac.u_ryukyu.cr.ie.tatsuki.bbs;
|
|
|
2
|
|
|
3 import java.util.Iterator;
|
|
11
|
4 import java.util.LinkedList;
|
|
8
|
5 import java.util.regex.Matcher;
|
|
|
6 import java.util.regex.Pattern;
|
|
7
|
7
|
|
15
|
8 import fj.Ord;
|
|
|
9 import fj.P2;
|
|
|
10 import fj.data.TreeMap;
|
|
7
|
11 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTree;
|
|
|
12 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath;
|
|
|
13 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
|
|
|
14 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser.InterfaceTraverser;
|
|
9
|
15 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
|
|
|
16 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
|
|
7
|
17 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Pair;
|
|
|
18
|
|
|
19 public class JuGrix {
|
|
|
20
|
|
8
|
21 JungleTree personTree;
|
|
|
22 JungleTree organizationTree;
|
|
12
|
23 JungleTree roleTree;
|
|
8
|
24 public JuGrix(){
|
|
|
25 try{
|
|
|
26 loadXml reader = new loadXml();
|
|
|
27 personTree = reader.loadTestData("Person.xml");
|
|
|
28 organizationTree = reader.loadTestData("Organization.xml");
|
|
12
|
29 roleTree = reader.loadTestData("Role.xml");
|
|
8
|
30 } catch (Exception e) {
|
|
|
31 e.printStackTrace();
|
|
|
32 }
|
|
|
33 }
|
|
12
|
34
|
|
8
|
35 public boolean isActive(String id){
|
|
7
|
36
|
|
8
|
37 InterfaceTraverser ifTraverser = personTree.getTraverser();
|
|
7
|
38 Iterator<Pair<TreeNode,NodePath>> pairIterator = ifTraverser.find(
|
|
|
39 (TreeNode node) -> {
|
|
|
40 String personId = node.getAttributes().getString("id");
|
|
|
41 if (personId == null)
|
|
|
42 return false;
|
|
|
43 if (personId.equals(id))
|
|
|
44 return true;
|
|
|
45 return false;
|
|
|
46 }
|
|
|
47 ,"id",id);
|
|
|
48
|
|
|
49 if (pairIterator.hasNext())
|
|
|
50 return true;
|
|
|
51 return false;
|
|
|
52
|
|
|
53 }
|
|
|
54
|
|
12
|
55 public Iterator<String> personIds(String orgId, LinkedList<String> roleIds){
|
|
17
|
56 return personIdsSearch(orgId, roleIds).iterator();
|
|
7
|
57 }
|
|
|
58
|
|
18
|
59 public LinkedList<String> personIdLink(String orgId, LinkedList<String> roleIds){
|
|
|
60 return personIdsSearch(orgId, roleIds);
|
|
|
61 }
|
|
|
62
|
|
12
|
63 public Iterator<String> personIds(LinkedList<String> orgIds ,LinkedList<String> roleIds){
|
|
7
|
64
|
|
13
|
65 LinkedList<String> personIds = new LinkedList<String>();
|
|
11
|
66
|
|
12
|
67 for (String orgId : orgIds) {
|
|
|
68 personIds.addAll(personIdsSearch(orgId, roleIds));
|
|
7
|
69 }
|
|
|
70 return personIds.iterator();
|
|
|
71 }
|
|
|
72
|
|
12
|
73 private LinkedList<String> personIdsSearch(String id, LinkedList<String> roleIds) {
|
|
|
74
|
|
|
75 if (!filter(id, roleIds))
|
|
|
76 return new LinkedList<String>();
|
|
|
77
|
|
|
78 InterfaceTraverser personTraverser = personTree.getTraverser();
|
|
|
79 Iterator<Pair<TreeNode, NodePath>> pairPersonIterator = personTraverser.find(
|
|
7
|
80 (TreeNode node) -> {
|
|
|
81 String personId = node.getAttributes().getString("element");
|
|
|
82 if (personId == null)
|
|
|
83 return false;
|
|
|
84 if (personId.equals("Person"))
|
|
|
85 return true;
|
|
|
86 return false;
|
|
|
87 }
|
|
|
88 ,"element","Person");
|
|
|
89
|
|
11
|
90 LinkedList<String> names = new LinkedList<String>();
|
|
12
|
91
|
|
7
|
92 for (;pairPersonIterator.hasNext();) {
|
|
|
93
|
|
|
94 Pair<TreeNode, NodePath> pairPerson = pairPersonIterator.next();
|
|
12
|
95 Iterator<Pair<TreeNode,NodePath>> pairIdIterator = personTraverser.find(
|
|
7
|
96 (TreeNode node) -> {
|
|
|
97 String personId = node.getAttributes().getString("text");
|
|
|
98 if (personId == null)
|
|
|
99 return false;
|
|
|
100 if (personId.equals(id))
|
|
|
101 return true;
|
|
|
102 return false;
|
|
|
103 }
|
|
15
|
104 ,pairPerson.left());
|
|
12
|
105
|
|
|
106 if (pairIdIterator.hasNext()) {
|
|
|
107 String name = pairPerson.left().getAttributes().getString("id");
|
|
|
108 names.add(name);
|
|
|
109 }
|
|
|
110 }
|
|
|
111 return names;
|
|
|
112 }
|
|
|
113
|
|
|
114
|
|
|
115 public boolean filter(String orgId, LinkedList<String> roleIds) {
|
|
|
116 if (roleIds == null)
|
|
|
117 return true;
|
|
|
118
|
|
|
119 InterfaceTraverser orgTraverser = organizationTree.getTraverser();
|
|
|
120
|
|
|
121 Iterator<Pair<TreeNode,NodePath>> orgNodeIterator = orgTraverser.find(
|
|
|
122 (TreeNode node) -> {
|
|
|
123 String personId = node.getAttributes().getString("element");
|
|
|
124 if (personId == null)
|
|
|
125 return false;
|
|
17
|
126 if (!personId.equals("Organization"))
|
|
|
127 return false;
|
|
12
|
128 String compareOrgId = node.getAttributes().getString("id");
|
|
17
|
129 if (compareOrgId == null)
|
|
12
|
130 return false;
|
|
|
131 if (compareOrgId.equals(orgId))
|
|
|
132 return true;
|
|
|
133 return false;
|
|
17
|
134 });
|
|
12
|
135
|
|
|
136 if (!orgNodeIterator.hasNext())
|
|
|
137 return false;
|
|
|
138
|
|
|
139 TreeNode searchNode = orgNodeIterator.next().left();
|
|
|
140
|
|
|
141 for (String id : roleIds) {
|
|
|
142 Pattern personPattern = Pattern.compile("r:");
|
|
|
143 Matcher personMacher = personPattern.matcher(id);
|
|
|
144 if (personMacher.find()) {
|
|
|
145 if (!roleFilter(id , searchNode))
|
|
|
146 return false;
|
|
|
147 }
|
|
|
148
|
|
|
149 Pattern organizationPattern = Pattern.compile("rde:");
|
|
|
150 Matcher organizationMacher = organizationPattern.matcher(id);
|
|
|
151 if (organizationMacher.find()) {
|
|
|
152 if (!rdeFilter(id,searchNode))
|
|
|
153 return false;
|
|
|
154 }
|
|
|
155 }
|
|
|
156 return true;
|
|
|
157 }
|
|
|
158
|
|
|
159 private boolean rdeFilter(String id, TreeNode targetNode) {
|
|
|
160
|
|
|
161 InterfaceTraverser orgTraverser = organizationTree.getTraverser();
|
|
|
162 Iterator<Pair<TreeNode,NodePath>> pairIdIterator = orgTraverser.find(
|
|
|
163 (TreeNode node) -> {
|
|
|
164 String element = node.getAttributes().getString("element");
|
|
|
165 if (element == null)
|
|
|
166 return false;
|
|
|
167 if (!element.equals("roleRefId"))
|
|
|
168 return false;
|
|
|
169 String roleId = node.getAttributes().getString("text");
|
|
|
170 if (roleId != null)
|
|
|
171 return true;
|
|
|
172 return false;
|
|
|
173 }
|
|
15
|
174 ,targetNode);
|
|
12
|
175
|
|
|
176 TreeMap<String, String> idMap = TreeMap.empty(Ord.stringOrd);
|
|
|
177 for (; pairIdIterator.hasNext();) {
|
|
|
178 String roleId = pairIdIterator.next().left().getAttributes().getString("text");
|
|
|
179 idMap = idMap.set(roleId,roleId);
|
|
|
180 }
|
|
|
181
|
|
|
182 Iterator<P2<String, String>> ids = idMap.iterator();
|
|
|
183 InterfaceTraverser roleTraverser = roleTree.getTraverser();
|
|
|
184
|
|
|
185 for (;ids.hasNext();) {
|
|
|
186 String roleId = ids.next()._1();
|
|
|
187 Iterator<Pair<TreeNode,NodePath>> roleNodeIterator = roleTraverser.find(
|
|
|
188 (TreeNode node) -> {
|
|
|
189 String element = node.getAttributes().getString("element");
|
|
|
190 if (element == null)
|
|
|
191 return false;
|
|
|
192 if (!element.equals("Role"))
|
|
|
193 return false;
|
|
|
194 String compareRoleId = node.getAttributes().getString("id");
|
|
|
195 if (compareRoleId == null)
|
|
|
196 return false;
|
|
|
197 if (compareRoleId.equals(roleId))
|
|
|
198 return true;
|
|
|
199 return false;
|
|
|
200 }
|
|
|
201 ,"id",roleId);
|
|
|
202
|
|
|
203 for (;roleNodeIterator.hasNext();) {
|
|
|
204 TreeNode roleNode = roleNodeIterator.next().left();
|
|
|
205 Iterator<Pair<TreeNode,NodePath>> rdeNodeIterator = roleTraverser.find(
|
|
|
206 (TreeNode node) -> {
|
|
|
207 String elementName = node.getAttributes().getString("element");
|
|
|
208 if (elementName == null)
|
|
|
209 return false;
|
|
|
210 if (!elementName.equals("roleDescriptionElementRefIds"))
|
|
|
211 return false;
|
|
|
212 String rdeId = node.getAttributes().getString("text");
|
|
|
213 if (rdeId == null)
|
|
|
214 return false;
|
|
|
215 Pattern personPattern = Pattern.compile(id);
|
|
|
216 Matcher personMacher = personPattern.matcher(rdeId);
|
|
|
217 if (personMacher.find())
|
|
|
218 return true;
|
|
|
219 return false;
|
|
|
220 }
|
|
15
|
221 ,roleNode);
|
|
12
|
222
|
|
|
223 if (!rdeNodeIterator.hasNext())
|
|
|
224 return false;
|
|
|
225 }
|
|
7
|
226
|
|
|
227 }
|
|
12
|
228 return true;
|
|
|
229 }
|
|
|
230
|
|
|
231 public boolean roleFilter(String id, TreeNode orgNode) {
|
|
17
|
232 System.out.println(orgNode.getAttributes().getString("id"));
|
|
12
|
233 InterfaceTraverser orgTraverser = organizationTree.getTraverser();
|
|
|
234
|
|
|
235 Iterator<Pair<TreeNode,NodePath>> pairIdIterator = orgTraverser.find(
|
|
|
236 (TreeNode node) -> {
|
|
|
237 String elementName = node.getAttributes().getString("element");
|
|
|
238 if (elementName == null)
|
|
|
239 return false;
|
|
17
|
240 if (!elementName.equals("roleRefIds"))
|
|
12
|
241 return false;
|
|
|
242 String roleId = node.getAttributes().getString("text");
|
|
|
243 if (roleId == null)
|
|
|
244 return false;
|
|
|
245 if (roleId.equals(id))
|
|
|
246 return true;
|
|
|
247 return false;
|
|
|
248 }
|
|
15
|
249 ,orgNode);
|
|
12
|
250
|
|
|
251 if (pairIdIterator.hasNext()){
|
|
|
252 System.out.println(pairIdIterator.next().left().getAttributes().getString("text"));
|
|
|
253 return true;
|
|
|
254 }
|
|
|
255 return false;
|
|
7
|
256 }
|
|
8
|
257
|
|
|
258 public Iterator<String> roleIds(String id) {
|
|
|
259 Pattern personPattern = Pattern.compile("p:");
|
|
|
260 Matcher personMacher = personPattern.matcher(id);
|
|
|
261 if (personMacher.find()) {
|
|
|
262 return searchRoleIds(personTree, id, "Person");
|
|
|
263 }
|
|
|
264
|
|
|
265 Pattern organizationPattern = Pattern.compile("o:");
|
|
|
266 Matcher organizationMacher = organizationPattern.matcher(id);
|
|
|
267 if (organizationMacher.find()) {
|
|
|
268 return searchRoleIds(organizationTree, id, "Organization");
|
|
|
269 }
|
|
|
270
|
|
|
271 return null;
|
|
|
272 }
|
|
7
|
273
|
|
8
|
274 public Iterator<String> searchRoleIds(JungleTree tree, String id, String element){
|
|
|
275
|
|
|
276 InterfaceTraverser ifTraverser = tree.getTraverser();
|
|
|
277 Iterator<Pair<TreeNode,NodePath>> searchTargetIterator = ifTraverser.find(
|
|
|
278 (TreeNode node) -> {
|
|
|
279 String nodeElement = node.getAttributes().getString("element");
|
|
|
280 if (nodeElement == null)
|
|
|
281 return false;
|
|
|
282 if (!nodeElement.equals(element))
|
|
|
283 return false;
|
|
|
284 String nodeId = node.getAttributes().getString("id");
|
|
|
285 if (nodeId == null)
|
|
|
286 return false;
|
|
|
287 if (nodeId.equals(id))
|
|
|
288 return true;
|
|
|
289 return false;
|
|
|
290 }
|
|
|
291 ,"id",id);
|
|
|
292
|
|
11
|
293 LinkedList<String> ids = new LinkedList<String>();
|
|
9
|
294
|
|
8
|
295 for (;searchTargetIterator.hasNext();) {
|
|
|
296
|
|
|
297 Pair<TreeNode, NodePath> searchTargetPair = searchTargetIterator.next();
|
|
|
298 Iterator<Pair<TreeNode,NodePath>> pairIdIterator = ifTraverser.find(
|
|
|
299 (TreeNode node) -> {
|
|
|
300 String nodeElement = node.getAttributes().getString("element");
|
|
|
301 if (nodeElement == null)
|
|
|
302 return false;
|
|
|
303 if (!nodeElement.equals("roleRefId"))
|
|
|
304 return false;
|
|
|
305 String nodeId = node.getAttributes().getString("text");
|
|
|
306 if (nodeId != null)
|
|
|
307 return true;
|
|
|
308 return false;
|
|
|
309 }
|
|
|
310 ,searchTargetPair.left());
|
|
|
311
|
|
|
312
|
|
|
313 for (;pairIdIterator.hasNext();){
|
|
|
314 Pair<TreeNode, NodePath> idNodePath = pairIdIterator.next();
|
|
|
315 String attribute = idNodePath.left().getAttributes().getString("text");
|
|
|
316
|
|
|
317 Iterator<String> checkList = ids.iterator();
|
|
|
318 for (;checkList.hasNext();) {
|
|
|
319 if(checkList.next().equals(attribute))
|
|
|
320 attribute = null;
|
|
|
321 }
|
|
|
322
|
|
|
323 if (attribute != null) {
|
|
11
|
324 ids.add(attribute);
|
|
8
|
325 System.out.println("-------------------------" + attribute + "-------------------------");
|
|
|
326 }
|
|
|
327 }
|
|
|
328 }
|
|
|
329 return ids.iterator();
|
|
|
330 }
|
|
|
331
|
|
|
332
|
|
|
333 public Iterator<String> competentRoleId(String personId) {
|
|
|
334
|
|
|
335 InterfaceTraverser ifTraverser = personTree.getTraverser();
|
|
11
|
336 Iterator<Pair<TreeNode, NodePath>> pairPersonIterator = searchPerson(personId, ifTraverser);
|
|
8
|
337
|
|
9
|
338 if (!pairPersonIterator.hasNext())
|
|
|
339 return new NullIterator();
|
|
|
340 TreeNode person = pairPersonIterator.next().left();
|
|
|
341
|
|
|
342 Iterator<Pair<TreeNode,NodePath>> targetPairIterator = ifTraverser.find(
|
|
|
343 (TreeNode node) -> {
|
|
|
344 String nodeElement = node.getAttributes().getString("element");
|
|
|
345 if (nodeElement == null)
|
|
|
346 return false;
|
|
|
347 if (!nodeElement.equals("priority"))
|
|
|
348 return false;
|
|
|
349 String priority = node.getAttributes().getString("text");
|
|
|
350 if (priority == null)
|
|
|
351 return false;
|
|
|
352 if (priority.equals("0"))
|
|
|
353 return true;
|
|
|
354 return false;
|
|
|
355 }
|
|
|
356 ,person);
|
|
|
357
|
|
|
358
|
|
11
|
359 LinkedList<String> idList = new LinkedList<String>();
|
|
9
|
360 for (;targetPairIterator.hasNext();) {
|
|
|
361 NodePath searchPath = targetPairIterator.next().right();
|
|
|
362 Pair<Integer, NodePath> searchPair = searchPath.last();
|
|
|
363 NodePath targetPath = searchPair.right().add(searchPair.left() + 1);
|
|
|
364 TreeNode targetNode = getTarget(person, targetPath);
|
|
|
365 String id = targetNode.getAttributes().getString("text");
|
|
11
|
366 idList.add(id);
|
|
9
|
367 }
|
|
|
368
|
|
|
369 return idList.iterator();
|
|
8
|
370 }
|
|
7
|
371
|
|
10
|
372
|
|
|
373 public Iterator<String> concurrentRoleIds(String personId) {
|
|
|
374
|
|
|
375 InterfaceTraverser ifTraverser = personTree.getTraverser();
|
|
11
|
376 Iterator<Pair<TreeNode, NodePath>> pairPersonIterator = searchPerson(
|
|
|
377 personId, ifTraverser);
|
|
10
|
378
|
|
|
379 if (!pairPersonIterator.hasNext())
|
|
|
380 return new NullIterator();
|
|
|
381 TreeNode person = pairPersonIterator.next().left();
|
|
|
382
|
|
|
383 Iterator<Pair<TreeNode,NodePath>> targetPairIterator = ifTraverser.find(
|
|
|
384 (TreeNode node) -> {
|
|
|
385 String nodeElement = node.getAttributes().getString("element");
|
|
|
386 if (nodeElement == null)
|
|
|
387 return false;
|
|
|
388 if (!nodeElement.equals("priority"))
|
|
|
389 return false;
|
|
|
390 String priority = node.getAttributes().getString("text");
|
|
|
391 if (priority == null)
|
|
|
392 return false;
|
|
|
393 if (!priority.equals("0"))
|
|
|
394 return true;
|
|
|
395 return false;
|
|
|
396 }
|
|
|
397 ,person);
|
|
|
398
|
|
|
399
|
|
11
|
400 LinkedList<String> idList = new LinkedList<String>();
|
|
10
|
401 for (;targetPairIterator.hasNext();) {
|
|
|
402 NodePath searchPath = targetPairIterator.next().right();
|
|
|
403 Pair<Integer, NodePath> searchPair = searchPath.last();
|
|
|
404 NodePath targetPath = searchPair.right().add(searchPair.left() + 1);
|
|
|
405 TreeNode targetNode = getTarget(person, targetPath);
|
|
|
406 String id = targetNode.getAttributes().getString("text");
|
|
11
|
407 idList.add(id);
|
|
10
|
408 }
|
|
|
409
|
|
|
410 return idList.iterator();
|
|
|
411 }
|
|
11
|
412 private Iterator<Pair<TreeNode, NodePath>> searchPerson(String personId,
|
|
|
413 InterfaceTraverser ifTraverser) {
|
|
|
414 Iterator<Pair<TreeNode,NodePath>> pairPersonIterator = ifTraverser.find(
|
|
|
415 (TreeNode node) -> {
|
|
|
416 String nodeElement = node.getAttributes().getString("element");
|
|
|
417 if (nodeElement == null)
|
|
|
418 return false;
|
|
|
419 if (!nodeElement.equals("Person"))
|
|
|
420 return false;
|
|
|
421 String nodeId = node.getAttributes().getString("id");
|
|
|
422 if (nodeId == null)
|
|
|
423 return false;
|
|
|
424 if (nodeId.equals(personId))
|
|
|
425 return true;
|
|
|
426 return false;
|
|
|
427 }
|
|
|
428 ,"element","Person");
|
|
|
429 return pairPersonIterator;
|
|
|
430 }
|
|
|
431
|
|
18
|
432
|
|
|
433
|
|
|
434 public Iterator<String> deepPersonIds(String orgId, LinkedList<String> filterIds) {
|
|
|
435
|
|
|
436 Iterator<String> childrensIterator = deepChildOrganizationIds(orgId, new LinkedList<String>());
|
|
|
437 if (!childrensIterator.hasNext())
|
|
|
438 return new NullIterator();
|
|
|
439
|
|
|
440 LinkedList<String> childrenPersonList = new LinkedList<String>();
|
|
19
|
441 //childrenPersonList.addAll(personIdLink(orgId, filterIds));
|
|
18
|
442 for (;childrensIterator.hasNext();) {
|
|
|
443 String id = childrensIterator.next();
|
|
|
444 childrenPersonList.addAll(personIdLink(id, filterIds));
|
|
|
445 }
|
|
|
446
|
|
|
447 return childrenPersonList.iterator();
|
|
|
448 }
|
|
|
449
|
|
19
|
450 public Iterator<String> deepChildOrganizationIdsPlus(String orgId, LinkedList<String> filterIds) {
|
|
|
451 LinkedList<String> orgList = new LinkedList<String>();
|
|
|
452 if (filter(orgId, filterIds))
|
|
|
453 orgList.add(orgId);
|
|
|
454 orgList.addAll(_deepChildOrganizationIds(orgId,filterIds));
|
|
|
455 return orgList.iterator();
|
|
|
456 }
|
|
|
457
|
|
17
|
458 public Iterator<String> deepChildOrganizationIds(String orgId, LinkedList<String> filterIds) {
|
|
|
459 return _deepChildOrganizationIds(orgId,filterIds).iterator();
|
|
|
460 }
|
|
|
461
|
|
|
462 public LinkedList<String> _deepChildOrganizationIds(String orgId, LinkedList<String> filterIds) {
|
|
|
463
|
|
19
|
464 Iterator<String> childrensIterator = childOrganizationIds(orgId,new LinkedList<String>());
|
|
17
|
465 if (!childrensIterator.hasNext())
|
|
|
466 return new LinkedList<String>();
|
|
|
467
|
|
|
468 LinkedList<String> childrenList = new LinkedList<String>();
|
|
|
469 for (;childrensIterator.hasNext();) {
|
|
|
470 String childrenId = childrensIterator.next();
|
|
|
471 if(filter(childrenId,filterIds))
|
|
|
472 childrenList.add(childrenId);
|
|
|
473 childrenList.addAll(_deepChildOrganizationIds(childrenId, filterIds));
|
|
|
474 }
|
|
|
475
|
|
|
476 return childrenList;
|
|
|
477 }
|
|
|
478
|
|
11
|
479
|
|
19
|
480 public Iterator<String> childOrganizationIds(String orgId, LinkedList<String> filterIds) {
|
|
|
481 if(!filter(orgId,filterIds))
|
|
|
482 return new NullIterator();
|
|
|
483 InterfaceTraverser orgTraverser = organizationTree.getTraverser();
|
|
|
484 Iterator<Pair<TreeNode, NodePath>> pairPersonIterator = orgTraverser.find(
|
|
|
485 (TreeNode node) -> {
|
|
|
486 String nodeElement = node.getAttributes().getString("element");
|
|
|
487 if (nodeElement == null)
|
|
|
488 return false;
|
|
|
489 if (!nodeElement.equals("Organization"))
|
|
|
490 return false;
|
|
|
491 String nodeId = node.getAttributes().getString("id");
|
|
|
492 if (nodeId == null)
|
|
|
493 return false;
|
|
|
494 if (nodeId.equals(orgId))
|
|
|
495 return true;
|
|
|
496 return false;
|
|
|
497 }
|
|
|
498 ,"element","Organization");
|
|
11
|
499
|
|
|
500 if (!pairPersonIterator.hasNext())
|
|
|
501 return new NullIterator();
|
|
|
502 TreeNode person = pairPersonIterator.next().left();
|
|
|
503
|
|
19
|
504
|
|
|
505 Iterator<Pair<TreeNode,NodePath>> chilrenOrgIdsIterator = orgTraverser.find(
|
|
11
|
506 (TreeNode node) -> {
|
|
|
507 String nodeElement = node.getAttributes().getString("element");
|
|
|
508 if (nodeElement == null)
|
|
|
509 return false;
|
|
|
510 if (nodeElement.equals("childOrganizations"))
|
|
|
511 return true;
|
|
|
512 return false;
|
|
|
513 }
|
|
|
514 ,person);
|
|
|
515
|
|
|
516 if (!chilrenOrgIdsIterator.hasNext())
|
|
|
517 return new NullIterator();
|
|
|
518
|
|
|
519 TreeNode chilerenOrgIds = chilrenOrgIdsIterator.next().left();
|
|
|
520
|
|
19
|
521 Iterator<Pair<TreeNode,NodePath>> chilrenOrgIdIterator = orgTraverser.find(
|
|
11
|
522 (TreeNode node) -> {
|
|
|
523 String nodeElement = node.getAttributes().getString("element");
|
|
|
524 if (nodeElement == null)
|
|
|
525 return false;
|
|
|
526 if (!nodeElement.equals("organizationRefIds"))
|
|
|
527 return false;
|
|
|
528 nodeElement = node.getAttributes().getString("text");
|
|
|
529 if (nodeElement != null)
|
|
|
530 return true;
|
|
|
531 return false;
|
|
|
532 }
|
|
16
|
533 ,chilerenOrgIds);
|
|
11
|
534
|
|
|
535 LinkedList<String> ids = new LinkedList<String>();
|
|
|
536
|
|
|
537 for (;chilrenOrgIdIterator.hasNext();) {
|
|
|
538 ids.add(chilrenOrgIdIterator.next().left().getAttributes().getString("text"));
|
|
|
539 }
|
|
|
540
|
|
|
541 return ids.iterator();
|
|
|
542 }
|
|
|
543
|
|
|
544
|
|
10
|
545
|
|
9
|
546 public TreeNode getTarget(TreeNode node , NodePath path){
|
|
|
547 TreeNode target;
|
|
|
548 Pair<Integer, NodePath> pathNode = path.pop();
|
|
|
549 int num = pathNode.left();
|
|
|
550 NodePath newPath = pathNode.right();
|
|
|
551 if (num == -1 && newPath.size() != 0)
|
|
|
552 return getTarget(node, newPath);
|
|
|
553
|
|
|
554 Either<Error, TreeNode> either = node.getChildren().at(num);
|
|
|
555 if (either.isA())
|
|
|
556 return node;
|
|
|
557
|
|
|
558 TreeNode child = either.b();
|
|
|
559 if (pathNode.right().size() == 0)
|
|
|
560 return child;
|
|
|
561
|
|
|
562 target = getTarget(child,pathNode.right());
|
|
|
563 return target;
|
|
|
564 }
|
|
10
|
565
|
|
9
|
566 class NullIterator implements Iterator<String>{
|
|
7
|
567
|
|
9
|
568 @Override
|
|
|
569 public boolean hasNext() {
|
|
|
570 return false;
|
|
|
571 }
|
|
|
572
|
|
|
573 @Override
|
|
|
574 public String next() {
|
|
|
575 return null;
|
|
|
576 }
|
|
|
577
|
|
|
578 }
|
|
10
|
579
|
|
15
|
580 public String rolePriority(String personId, String roleId) {
|
|
|
581 InterfaceTraverser personTraverser = personTree.getTraverser();
|
|
|
582 Iterator<Pair<TreeNode,NodePath>> personIterator = personTraverser.find(
|
|
|
583 (TreeNode node) -> {
|
|
|
584 String element = node.getAttributes().getString("element");
|
|
|
585 if (element == null)
|
|
|
586 return false;
|
|
|
587 if (!element.equals("Person"))
|
|
|
588 return false;
|
|
|
589 String nodeId = node.getAttributes().getString("id");
|
|
|
590 if (nodeId == null)
|
|
|
591 return false;
|
|
|
592 if (nodeId.equals(personId))
|
|
|
593 return true;
|
|
|
594 return false;
|
|
|
595 });
|
|
|
596
|
|
|
597 if (!personIterator.hasNext())
|
|
|
598 return "";
|
|
|
599
|
|
|
600 TreeNode targetNode = personIterator.next().left();
|
|
|
601
|
|
|
602 Iterator<Pair<TreeNode,NodePath>> priorityIterator = personTraverser.find(
|
|
|
603 (TreeNode node) -> {
|
|
|
604 String element = node.getAttributes().getString("element");
|
|
|
605 if (element == null)
|
|
|
606 return false;
|
|
|
607 if (!element.equals("roleRefId"))
|
|
|
608 return false;
|
|
|
609 String compareRoleId = node.getAttributes().getString("text");
|
|
|
610 if (compareRoleId == null)
|
|
|
611 return false;
|
|
|
612 if (compareRoleId.equals(roleId))
|
|
|
613 return true;
|
|
|
614 return false;
|
|
|
615 },targetNode);
|
|
|
616
|
|
|
617 for (;priorityIterator.hasNext();) {
|
|
|
618 Pair<TreeNode, NodePath> priorityPair = priorityIterator.next();
|
|
|
619 NodePath roleNodePath = priorityPair.right();
|
|
|
620 Pair<Integer, NodePath> last = roleNodePath.last();
|
|
|
621 NodePath priorityNodePath = last.right().add(last.left() - 1);
|
|
|
622 TreeNode priorityNode = getTarget(targetNode,priorityNodePath);
|
|
|
623 if (priorityNode.getAttributes().getString("element").equals("priority"))
|
|
|
624 return priorityNode.getAttributes().getString("text");
|
|
|
625 }
|
|
|
626 return "";
|
|
|
627 }
|
|
|
628
|
|
20
|
629 public Iterator<String> parentOrganizationIds(String orgId, LinkedList<String> filterIds) {
|
|
|
630
|
|
|
631 InterfaceTraverser orgTraverser = organizationTree.getTraverser();
|
|
|
632 Iterator<Pair<TreeNode,NodePath>> orgIterator = orgTraverser.find(
|
|
|
633 (TreeNode node) -> {
|
|
|
634 String element = node.getAttributes().getString("element");
|
|
|
635 if (element == null)
|
|
|
636 return false;
|
|
|
637 if (!element.equals("Organization"))
|
|
|
638 return false;
|
|
|
639 String nodeId = node.getAttributes().getString("id");
|
|
|
640 if (nodeId == null)
|
|
|
641 return false;
|
|
|
642 if (nodeId.equals(orgId))
|
|
|
643 return true;
|
|
|
644 return false;
|
|
|
645 });
|
|
|
646
|
|
|
647 if (!orgIterator.hasNext())
|
|
|
648 return new NullIterator();
|
|
|
649
|
|
|
650 TreeNode orgNode = orgIterator.next().left();
|
|
|
651
|
|
|
652 Iterator<Pair<TreeNode,NodePath>> parentOrgIterator = orgTraverser.find(
|
|
|
653 (TreeNode node) -> {
|
|
|
654 String element = node.getAttributes().getString("element");
|
|
|
655 if (element == null)
|
|
|
656 return false;
|
|
|
657 if (element.equals("parentOrganizations"))
|
|
|
658 return true;
|
|
|
659 return false;
|
|
|
660 }, orgNode);
|
|
|
661
|
|
|
662 LinkedList<String> parentIds = new LinkedList<String>();
|
|
|
663
|
|
|
664 for (;parentOrgIterator.hasNext();) {
|
|
|
665 TreeNode parentOrgNode = parentOrgIterator.next().left();
|
|
|
666
|
|
|
667 Iterator<Pair<TreeNode,NodePath>> parentNodeIterator = orgTraverser.find(
|
|
|
668 (TreeNode node) -> {
|
|
|
669 String element = node.getAttributes().getString("element");
|
|
|
670 if (element == null)
|
|
|
671 return false;
|
|
|
672 if (!element.equals("organizationRefId"))
|
|
|
673 return false;
|
|
|
674 String parentId = node.getAttributes().getString("text");
|
|
|
675 if (parentId != null)
|
|
|
676 return true;
|
|
|
677 return false;
|
|
|
678 }, parentOrgNode);
|
|
|
679
|
|
|
680 for (;parentNodeIterator.hasNext();) {
|
|
|
681 String parentId = parentNodeIterator.next().left().getAttributes().getString("text");
|
|
|
682 if (filter(parentId, filterIds))
|
|
|
683 parentIds.add(parentId);
|
|
|
684 }
|
|
|
685
|
|
|
686
|
|
|
687 }
|
|
|
688
|
|
|
689 return parentIds.iterator();
|
|
|
690 }
|
|
|
691
|
|
11
|
692
|
|
16
|
693
|
|
|
694
|
|
17
|
695
|
|
18
|
696
|
|
|
697
|
|
7
|
698 }
|
