|
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){
|
|
7
|
56
|
|
12
|
57 LinkedList<String> names = personIdsSearch(orgId, roleIds);
|
|
7
|
58 return names.iterator();
|
|
|
59 }
|
|
|
60
|
|
12
|
61 public Iterator<String> personIds(LinkedList<String> orgIds ,LinkedList<String> roleIds){
|
|
7
|
62
|
|
13
|
63 LinkedList<String> personIds = new LinkedList<String>();
|
|
11
|
64
|
|
12
|
65 for (String orgId : orgIds) {
|
|
|
66 personIds.addAll(personIdsSearch(orgId, roleIds));
|
|
7
|
67 }
|
|
|
68 return personIds.iterator();
|
|
|
69 }
|
|
|
70
|
|
12
|
71 private LinkedList<String> personIdsSearch(String id, LinkedList<String> roleIds) {
|
|
|
72
|
|
|
73 if (!filter(id, roleIds))
|
|
|
74 return new LinkedList<String>();
|
|
|
75
|
|
|
76 InterfaceTraverser personTraverser = personTree.getTraverser();
|
|
|
77 Iterator<Pair<TreeNode, NodePath>> pairPersonIterator = personTraverser.find(
|
|
7
|
78 (TreeNode node) -> {
|
|
|
79 String personId = node.getAttributes().getString("element");
|
|
|
80 if (personId == null)
|
|
|
81 return false;
|
|
|
82 if (personId.equals("Person"))
|
|
|
83 return true;
|
|
|
84 return false;
|
|
|
85 }
|
|
|
86 ,"element","Person");
|
|
|
87
|
|
11
|
88 LinkedList<String> names = new LinkedList<String>();
|
|
12
|
89
|
|
7
|
90 for (;pairPersonIterator.hasNext();) {
|
|
|
91
|
|
|
92 Pair<TreeNode, NodePath> pairPerson = pairPersonIterator.next();
|
|
12
|
93 Iterator<Pair<TreeNode,NodePath>> pairIdIterator = personTraverser.find(
|
|
7
|
94 (TreeNode node) -> {
|
|
|
95 String personId = node.getAttributes().getString("text");
|
|
|
96 if (personId == null)
|
|
|
97 return false;
|
|
|
98 if (personId.equals(id))
|
|
|
99 return true;
|
|
|
100 return false;
|
|
|
101 }
|
|
15
|
102 ,pairPerson.left());
|
|
12
|
103
|
|
|
104 if (pairIdIterator.hasNext()) {
|
|
|
105 String name = pairPerson.left().getAttributes().getString("id");
|
|
|
106 names.add(name);
|
|
|
107 }
|
|
|
108 }
|
|
|
109 return names;
|
|
|
110 }
|
|
|
111
|
|
|
112
|
|
|
113 public boolean filter(String orgId, LinkedList<String> roleIds) {
|
|
|
114 if (roleIds == null)
|
|
|
115 return true;
|
|
|
116
|
|
|
117 InterfaceTraverser orgTraverser = organizationTree.getTraverser();
|
|
|
118
|
|
|
119 Iterator<Pair<TreeNode,NodePath>> orgNodeIterator = orgTraverser.find(
|
|
|
120 (TreeNode node) -> {
|
|
|
121 String personId = node.getAttributes().getString("element");
|
|
|
122 if (personId == null)
|
|
|
123 return false;
|
|
15
|
124 if (personId.equals("Organization"))
|
|
|
125 return true;
|
|
12
|
126 String compareOrgId = node.getAttributes().getString("id");
|
|
|
127 if (orgId == null)
|
|
|
128 return false;
|
|
|
129 if (compareOrgId.equals(orgId))
|
|
|
130 return true;
|
|
|
131 return false;
|
|
|
132 }
|
|
|
133 ,"element","orgId");
|
|
|
134
|
|
|
135 if (!orgNodeIterator.hasNext())
|
|
|
136 return false;
|
|
|
137
|
|
|
138 TreeNode searchNode = orgNodeIterator.next().left();
|
|
|
139
|
|
|
140 for (String id : roleIds) {
|
|
|
141 Pattern personPattern = Pattern.compile("r:");
|
|
|
142 Matcher personMacher = personPattern.matcher(id);
|
|
|
143 if (personMacher.find()) {
|
|
|
144 if (!roleFilter(id , searchNode))
|
|
|
145 return false;
|
|
|
146 }
|
|
|
147
|
|
|
148 Pattern organizationPattern = Pattern.compile("rde:");
|
|
|
149 Matcher organizationMacher = organizationPattern.matcher(id);
|
|
|
150 if (organizationMacher.find()) {
|
|
|
151 if (!rdeFilter(id,searchNode))
|
|
|
152 return false;
|
|
|
153 }
|
|
|
154 }
|
|
|
155 return true;
|
|
|
156 }
|
|
|
157
|
|
|
158 private boolean rdeFilter(String id, TreeNode targetNode) {
|
|
|
159
|
|
|
160 InterfaceTraverser orgTraverser = organizationTree.getTraverser();
|
|
|
161 Iterator<Pair<TreeNode,NodePath>> pairIdIterator = orgTraverser.find(
|
|
|
162 (TreeNode node) -> {
|
|
|
163 String element = node.getAttributes().getString("element");
|
|
|
164 if (element == null)
|
|
|
165 return false;
|
|
|
166 if (!element.equals("roleRefId"))
|
|
|
167 return false;
|
|
|
168 String roleId = node.getAttributes().getString("text");
|
|
|
169 if (roleId != null)
|
|
|
170 return true;
|
|
|
171 return false;
|
|
|
172 }
|
|
15
|
173 ,targetNode);
|
|
12
|
174
|
|
|
175 TreeMap<String, String> idMap = TreeMap.empty(Ord.stringOrd);
|
|
|
176 for (; pairIdIterator.hasNext();) {
|
|
|
177 String roleId = pairIdIterator.next().left().getAttributes().getString("text");
|
|
|
178 idMap = idMap.set(roleId,roleId);
|
|
|
179 }
|
|
|
180
|
|
|
181 Iterator<P2<String, String>> ids = idMap.iterator();
|
|
|
182 InterfaceTraverser roleTraverser = roleTree.getTraverser();
|
|
|
183
|
|
|
184 for (;ids.hasNext();) {
|
|
|
185 String roleId = ids.next()._1();
|
|
|
186 Iterator<Pair<TreeNode,NodePath>> roleNodeIterator = roleTraverser.find(
|
|
|
187 (TreeNode node) -> {
|
|
|
188 String element = node.getAttributes().getString("element");
|
|
|
189 if (element == null)
|
|
|
190 return false;
|
|
|
191 if (!element.equals("Role"))
|
|
|
192 return false;
|
|
|
193 String compareRoleId = node.getAttributes().getString("id");
|
|
|
194 if (compareRoleId == null)
|
|
|
195 return false;
|
|
|
196 if (compareRoleId.equals(roleId))
|
|
|
197 return true;
|
|
|
198 return false;
|
|
|
199 }
|
|
|
200 ,"id",roleId);
|
|
|
201
|
|
|
202 for (;roleNodeIterator.hasNext();) {
|
|
|
203 TreeNode roleNode = roleNodeIterator.next().left();
|
|
|
204 Iterator<Pair<TreeNode,NodePath>> rdeNodeIterator = roleTraverser.find(
|
|
|
205 (TreeNode node) -> {
|
|
|
206 String elementName = node.getAttributes().getString("element");
|
|
|
207 if (elementName == null)
|
|
|
208 return false;
|
|
|
209 if (!elementName.equals("roleDescriptionElementRefIds"))
|
|
|
210 return false;
|
|
|
211 String rdeId = node.getAttributes().getString("text");
|
|
|
212 if (rdeId == null)
|
|
|
213 return false;
|
|
|
214 Pattern personPattern = Pattern.compile(id);
|
|
|
215 Matcher personMacher = personPattern.matcher(rdeId);
|
|
|
216 if (personMacher.find())
|
|
|
217 return true;
|
|
|
218 return false;
|
|
|
219 }
|
|
15
|
220 ,roleNode);
|
|
12
|
221
|
|
|
222 if (!rdeNodeIterator.hasNext())
|
|
|
223 return false;
|
|
|
224 }
|
|
7
|
225
|
|
|
226 }
|
|
12
|
227 return true;
|
|
|
228 }
|
|
|
229
|
|
|
230 public boolean roleFilter(String id, TreeNode orgNode) {
|
|
|
231
|
|
|
232 InterfaceTraverser orgTraverser = organizationTree.getTraverser();
|
|
|
233
|
|
|
234 Iterator<Pair<TreeNode,NodePath>> pairIdIterator = orgTraverser.find(
|
|
|
235 (TreeNode node) -> {
|
|
|
236 String elementName = node.getAttributes().getString("element");
|
|
|
237 if (elementName == null)
|
|
|
238 return false;
|
|
|
239 if (!elementName.equals("roleRefId"))
|
|
|
240 return false;
|
|
|
241 String roleId = node.getAttributes().getString("text");
|
|
|
242 if (roleId == null)
|
|
|
243 return false;
|
|
|
244 if (roleId.equals(id))
|
|
|
245 return true;
|
|
|
246 return false;
|
|
|
247 }
|
|
15
|
248 ,orgNode);
|
|
12
|
249
|
|
|
250 if (pairIdIterator.hasNext()){
|
|
|
251 System.out.println(pairIdIterator.next().left().getAttributes().getString("text"));
|
|
|
252 return true;
|
|
|
253 }
|
|
|
254 return false;
|
|
7
|
255 }
|
|
8
|
256
|
|
|
257 public Iterator<String> roleIds(String id) {
|
|
|
258 Pattern personPattern = Pattern.compile("p:");
|
|
|
259 Matcher personMacher = personPattern.matcher(id);
|
|
|
260 if (personMacher.find()) {
|
|
|
261 return searchRoleIds(personTree, id, "Person");
|
|
|
262 }
|
|
|
263
|
|
|
264 Pattern organizationPattern = Pattern.compile("o:");
|
|
|
265 Matcher organizationMacher = organizationPattern.matcher(id);
|
|
|
266 if (organizationMacher.find()) {
|
|
|
267 return searchRoleIds(organizationTree, id, "Organization");
|
|
|
268 }
|
|
|
269
|
|
|
270 return null;
|
|
|
271 }
|
|
7
|
272
|
|
8
|
273 public Iterator<String> searchRoleIds(JungleTree tree, String id, String element){
|
|
|
274
|
|
|
275 InterfaceTraverser ifTraverser = tree.getTraverser();
|
|
|
276 Iterator<Pair<TreeNode,NodePath>> searchTargetIterator = ifTraverser.find(
|
|
|
277 (TreeNode node) -> {
|
|
|
278 String nodeElement = node.getAttributes().getString("element");
|
|
|
279 if (nodeElement == null)
|
|
|
280 return false;
|
|
|
281 if (!nodeElement.equals(element))
|
|
|
282 return false;
|
|
|
283 String nodeId = node.getAttributes().getString("id");
|
|
|
284 if (nodeId == null)
|
|
|
285 return false;
|
|
|
286 if (nodeId.equals(id))
|
|
|
287 return true;
|
|
|
288 return false;
|
|
|
289 }
|
|
|
290 ,"id",id);
|
|
|
291
|
|
11
|
292 LinkedList<String> ids = new LinkedList<String>();
|
|
9
|
293
|
|
8
|
294 for (;searchTargetIterator.hasNext();) {
|
|
|
295
|
|
|
296 Pair<TreeNode, NodePath> searchTargetPair = searchTargetIterator.next();
|
|
|
297 Iterator<Pair<TreeNode,NodePath>> pairIdIterator = ifTraverser.find(
|
|
|
298 (TreeNode node) -> {
|
|
|
299 String nodeElement = node.getAttributes().getString("element");
|
|
|
300 if (nodeElement == null)
|
|
|
301 return false;
|
|
|
302 if (!nodeElement.equals("roleRefId"))
|
|
|
303 return false;
|
|
|
304 String nodeId = node.getAttributes().getString("text");
|
|
|
305 if (nodeId != null)
|
|
|
306 return true;
|
|
|
307 return false;
|
|
|
308 }
|
|
|
309 ,searchTargetPair.left());
|
|
|
310
|
|
|
311
|
|
|
312 for (;pairIdIterator.hasNext();){
|
|
|
313 Pair<TreeNode, NodePath> idNodePath = pairIdIterator.next();
|
|
|
314 String attribute = idNodePath.left().getAttributes().getString("text");
|
|
|
315
|
|
|
316 Iterator<String> checkList = ids.iterator();
|
|
|
317 for (;checkList.hasNext();) {
|
|
|
318 if(checkList.next().equals(attribute))
|
|
|
319 attribute = null;
|
|
|
320 }
|
|
|
321
|
|
|
322 if (attribute != null) {
|
|
11
|
323 ids.add(attribute);
|
|
8
|
324 System.out.println("-------------------------" + attribute + "-------------------------");
|
|
|
325 }
|
|
|
326 }
|
|
|
327 }
|
|
|
328 return ids.iterator();
|
|
|
329 }
|
|
|
330
|
|
|
331
|
|
|
332 public Iterator<String> competentRoleId(String personId) {
|
|
|
333
|
|
|
334 InterfaceTraverser ifTraverser = personTree.getTraverser();
|
|
11
|
335 Iterator<Pair<TreeNode, NodePath>> pairPersonIterator = searchPerson(personId, ifTraverser);
|
|
8
|
336
|
|
9
|
337 if (!pairPersonIterator.hasNext())
|
|
|
338 return new NullIterator();
|
|
|
339 TreeNode person = pairPersonIterator.next().left();
|
|
|
340
|
|
|
341 Iterator<Pair<TreeNode,NodePath>> targetPairIterator = ifTraverser.find(
|
|
|
342 (TreeNode node) -> {
|
|
|
343 String nodeElement = node.getAttributes().getString("element");
|
|
|
344 if (nodeElement == null)
|
|
|
345 return false;
|
|
|
346 if (!nodeElement.equals("priority"))
|
|
|
347 return false;
|
|
|
348 String priority = node.getAttributes().getString("text");
|
|
|
349 if (priority == null)
|
|
|
350 return false;
|
|
|
351 if (priority.equals("0"))
|
|
|
352 return true;
|
|
|
353 return false;
|
|
|
354 }
|
|
|
355 ,person);
|
|
|
356
|
|
|
357
|
|
11
|
358 LinkedList<String> idList = new LinkedList<String>();
|
|
9
|
359 for (;targetPairIterator.hasNext();) {
|
|
|
360 NodePath searchPath = targetPairIterator.next().right();
|
|
|
361 Pair<Integer, NodePath> searchPair = searchPath.last();
|
|
|
362 NodePath targetPath = searchPair.right().add(searchPair.left() + 1);
|
|
|
363 TreeNode targetNode = getTarget(person, targetPath);
|
|
|
364 String id = targetNode.getAttributes().getString("text");
|
|
11
|
365 idList.add(id);
|
|
9
|
366 }
|
|
|
367
|
|
|
368 return idList.iterator();
|
|
8
|
369 }
|
|
7
|
370
|
|
10
|
371
|
|
|
372 public Iterator<String> concurrentRoleIds(String personId) {
|
|
|
373
|
|
|
374 InterfaceTraverser ifTraverser = personTree.getTraverser();
|
|
11
|
375 Iterator<Pair<TreeNode, NodePath>> pairPersonIterator = searchPerson(
|
|
|
376 personId, ifTraverser);
|
|
10
|
377
|
|
|
378 if (!pairPersonIterator.hasNext())
|
|
|
379 return new NullIterator();
|
|
|
380 TreeNode person = pairPersonIterator.next().left();
|
|
|
381
|
|
|
382 Iterator<Pair<TreeNode,NodePath>> targetPairIterator = ifTraverser.find(
|
|
|
383 (TreeNode node) -> {
|
|
|
384 String nodeElement = node.getAttributes().getString("element");
|
|
|
385 if (nodeElement == null)
|
|
|
386 return false;
|
|
|
387 if (!nodeElement.equals("priority"))
|
|
|
388 return false;
|
|
|
389 String priority = node.getAttributes().getString("text");
|
|
|
390 if (priority == null)
|
|
|
391 return false;
|
|
|
392 if (!priority.equals("0"))
|
|
|
393 return true;
|
|
|
394 return false;
|
|
|
395 }
|
|
|
396 ,person);
|
|
|
397
|
|
|
398
|
|
11
|
399 LinkedList<String> idList = new LinkedList<String>();
|
|
10
|
400 for (;targetPairIterator.hasNext();) {
|
|
|
401 NodePath searchPath = targetPairIterator.next().right();
|
|
|
402 Pair<Integer, NodePath> searchPair = searchPath.last();
|
|
|
403 NodePath targetPath = searchPair.right().add(searchPair.left() + 1);
|
|
|
404 TreeNode targetNode = getTarget(person, targetPath);
|
|
|
405 String id = targetNode.getAttributes().getString("text");
|
|
11
|
406 idList.add(id);
|
|
10
|
407 }
|
|
|
408
|
|
|
409 return idList.iterator();
|
|
|
410 }
|
|
11
|
411 private Iterator<Pair<TreeNode, NodePath>> searchPerson(String personId,
|
|
|
412 InterfaceTraverser ifTraverser) {
|
|
|
413 Iterator<Pair<TreeNode,NodePath>> pairPersonIterator = ifTraverser.find(
|
|
|
414 (TreeNode node) -> {
|
|
|
415 String nodeElement = node.getAttributes().getString("element");
|
|
|
416 if (nodeElement == null)
|
|
|
417 return false;
|
|
|
418 if (!nodeElement.equals("Person"))
|
|
|
419 return false;
|
|
|
420 String nodeId = node.getAttributes().getString("id");
|
|
|
421 if (nodeId == null)
|
|
|
422 return false;
|
|
|
423 if (nodeId.equals(personId))
|
|
|
424 return true;
|
|
|
425 return false;
|
|
|
426 }
|
|
|
427 ,"element","Person");
|
|
|
428 return pairPersonIterator;
|
|
|
429 }
|
|
|
430
|
|
|
431
|
|
|
432 public Iterator<String> childOrganizationIds(String orgId) {
|
|
|
433 InterfaceTraverser ifTraverser = organizationTree.getTraverser();
|
|
|
434 Iterator<Pair<TreeNode, NodePath>> pairPersonIterator = searchOrganization(orgId, ifTraverser);
|
|
|
435
|
|
|
436 if (!pairPersonIterator.hasNext())
|
|
|
437 return new NullIterator();
|
|
|
438 TreeNode person = pairPersonIterator.next().left();
|
|
|
439
|
|
|
440 Iterator<Pair<TreeNode,NodePath>> chilrenOrgIdsIterator = ifTraverser.find(
|
|
|
441 (TreeNode node) -> {
|
|
|
442 String nodeElement = node.getAttributes().getString("element");
|
|
|
443 if (nodeElement == null)
|
|
|
444 return false;
|
|
|
445 if (nodeElement.equals("childOrganizations"))
|
|
|
446 return true;
|
|
|
447 return false;
|
|
|
448 }
|
|
|
449 ,person);
|
|
|
450
|
|
|
451 if (!chilrenOrgIdsIterator.hasNext())
|
|
|
452 return new NullIterator();
|
|
|
453
|
|
|
454 TreeNode chilerenOrgIds = chilrenOrgIdsIterator.next().left();
|
|
|
455
|
|
|
456 Iterator<Pair<TreeNode,NodePath>> chilrenOrgIdIterator = ifTraverser.find(
|
|
|
457 (TreeNode node) -> {
|
|
|
458 String nodeElement = node.getAttributes().getString("element");
|
|
|
459 if (nodeElement == null)
|
|
|
460 return false;
|
|
|
461 if (!nodeElement.equals("organizationRefIds"))
|
|
|
462 return false;
|
|
|
463 nodeElement = node.getAttributes().getString("text");
|
|
|
464 if (nodeElement != null)
|
|
|
465 return true;
|
|
|
466 return false;
|
|
|
467 }
|
|
16
|
468 ,chilerenOrgIds);
|
|
11
|
469
|
|
|
470 LinkedList<String> ids = new LinkedList<String>();
|
|
|
471
|
|
|
472 for (;chilrenOrgIdIterator.hasNext();) {
|
|
|
473 ids.add(chilrenOrgIdIterator.next().left().getAttributes().getString("text"));
|
|
|
474 }
|
|
|
475
|
|
|
476 return ids.iterator();
|
|
|
477 }
|
|
|
478
|
|
|
479
|
|
|
480 private Iterator<Pair<TreeNode, NodePath>> searchOrganization(String orgId,
|
|
|
481 InterfaceTraverser ifTraverser) {
|
|
|
482 Iterator<Pair<TreeNode,NodePath>> pairPersonIterator = ifTraverser.find(
|
|
|
483 (TreeNode node) -> {
|
|
|
484 String nodeElement = node.getAttributes().getString("element");
|
|
|
485 if (nodeElement == null)
|
|
|
486 return false;
|
|
|
487 if (!nodeElement.equals("Organization"))
|
|
|
488 return false;
|
|
|
489 String nodeId = node.getAttributes().getString("id");
|
|
|
490 if (nodeId == null)
|
|
|
491 return false;
|
|
|
492 if (nodeId.equals(orgId))
|
|
|
493 return true;
|
|
|
494 return false;
|
|
|
495 }
|
|
|
496 ,"element","Organization");
|
|
|
497 return pairPersonIterator;
|
|
|
498 }
|
|
10
|
499
|
|
9
|
500 public TreeNode getTarget(TreeNode node , NodePath path){
|
|
|
501 TreeNode target;
|
|
|
502 Pair<Integer, NodePath> pathNode = path.pop();
|
|
|
503 int num = pathNode.left();
|
|
|
504 NodePath newPath = pathNode.right();
|
|
|
505 if (num == -1 && newPath.size() != 0)
|
|
|
506 return getTarget(node, newPath);
|
|
|
507
|
|
|
508 Either<Error, TreeNode> either = node.getChildren().at(num);
|
|
|
509 if (either.isA())
|
|
|
510 return node;
|
|
|
511
|
|
|
512 TreeNode child = either.b();
|
|
|
513 if (pathNode.right().size() == 0)
|
|
|
514 return child;
|
|
|
515
|
|
|
516 target = getTarget(child,pathNode.right());
|
|
|
517 return target;
|
|
|
518 }
|
|
10
|
519
|
|
9
|
520 class NullIterator implements Iterator<String>{
|
|
7
|
521
|
|
9
|
522 @Override
|
|
|
523 public boolean hasNext() {
|
|
|
524 return false;
|
|
|
525 }
|
|
|
526
|
|
|
527 @Override
|
|
|
528 public String next() {
|
|
|
529 return null;
|
|
|
530 }
|
|
|
531
|
|
|
532 }
|
|
10
|
533
|
|
15
|
534 public String rolePriority(String personId, String roleId) {
|
|
|
535 InterfaceTraverser personTraverser = personTree.getTraverser();
|
|
|
536 Iterator<Pair<TreeNode,NodePath>> personIterator = personTraverser.find(
|
|
|
537 (TreeNode node) -> {
|
|
|
538 String element = node.getAttributes().getString("element");
|
|
|
539 if (element == null)
|
|
|
540 return false;
|
|
|
541 if (!element.equals("Person"))
|
|
|
542 return false;
|
|
|
543 String nodeId = node.getAttributes().getString("id");
|
|
|
544 if (nodeId == null)
|
|
|
545 return false;
|
|
|
546 if (nodeId.equals(personId))
|
|
|
547 return true;
|
|
|
548 return false;
|
|
|
549 });
|
|
|
550
|
|
|
551 if (!personIterator.hasNext())
|
|
|
552 return "";
|
|
|
553
|
|
|
554 TreeNode targetNode = personIterator.next().left();
|
|
|
555
|
|
|
556 Iterator<Pair<TreeNode,NodePath>> priorityIterator = personTraverser.find(
|
|
|
557 (TreeNode node) -> {
|
|
|
558 String element = node.getAttributes().getString("element");
|
|
|
559 if (element == null)
|
|
|
560 return false;
|
|
|
561 if (!element.equals("roleRefId"))
|
|
|
562 return false;
|
|
|
563 String compareRoleId = node.getAttributes().getString("text");
|
|
|
564 if (compareRoleId == null)
|
|
|
565 return false;
|
|
|
566 if (compareRoleId.equals(roleId))
|
|
|
567 return true;
|
|
|
568 return false;
|
|
|
569 },targetNode);
|
|
|
570
|
|
|
571 for (;priorityIterator.hasNext();) {
|
|
|
572 Pair<TreeNode, NodePath> priorityPair = priorityIterator.next();
|
|
|
573 NodePath roleNodePath = priorityPair.right();
|
|
|
574 Pair<Integer, NodePath> last = roleNodePath.last();
|
|
|
575 NodePath priorityNodePath = last.right().add(last.left() - 1);
|
|
|
576 TreeNode priorityNode = getTarget(targetNode,priorityNodePath);
|
|
|
577 if (priorityNode.getAttributes().getString("element").equals("priority"))
|
|
|
578 return priorityNode.getAttributes().getString("text");
|
|
|
579 }
|
|
|
580 return "";
|
|
|
581 }
|
|
|
582
|
|
11
|
583
|
|
16
|
584
|
|
|
585
|
|
7
|
586 }
|
