1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16 package org.kuali.rice.krms.impl.ui;
17
18 import org.apache.commons.lang.StringUtils;
19 import org.kuali.rice.core.api.util.tree.Node;
20 import org.kuali.rice.krad.maintenance.MaintenanceDocument;
21 import org.kuali.rice.krad.service.KRADServiceLocator;
22 import org.kuali.rice.krad.service.SequenceAccessorService;
23 import org.kuali.rice.krad.uif.UifParameters;
24 import org.kuali.rice.krad.util.ObjectUtils;
25 import org.kuali.rice.krad.web.controller.MaintenanceDocumentController;
26 import org.kuali.rice.krad.web.form.MaintenanceForm;
27 import org.kuali.rice.krad.web.form.UifFormBase;
28 import org.kuali.rice.krms.api.repository.rule.RuleDefinition;
29 import org.kuali.rice.krms.api.repository.type.KrmsAttributeDefinition;
30 import org.kuali.rice.krms.impl.repository.ActionBo;
31 import org.kuali.rice.krms.api.repository.LogicalOperator;
32 import org.kuali.rice.krms.api.repository.proposition.PropositionType;
33 import org.kuali.rice.krms.impl.repository.AgendaBo;
34 import org.kuali.rice.krms.impl.repository.AgendaItemBo;
35 import org.kuali.rice.krms.impl.repository.ContextBoService;
36 import org.kuali.rice.krms.impl.repository.KrmsAttributeDefinitionService;
37 import org.kuali.rice.krms.impl.repository.KrmsRepositoryServiceLocator;
38 import org.kuali.rice.krms.impl.repository.PropositionBo;
39 import org.kuali.rice.krms.impl.repository.RuleBo;
40 import org.kuali.rice.krms.impl.repository.RuleBoService;
41 import org.kuali.rice.krms.impl.rule.AgendaEditorBusRule;
42 import org.springframework.stereotype.Controller;
43 import org.springframework.validation.BindingResult;
44 import org.springframework.web.bind.annotation.ModelAttribute;
45 import org.springframework.web.bind.annotation.RequestMapping;
46 import org.springframework.web.servlet.ModelAndView;
47
48 import javax.servlet.http.HttpServletRequest;
49 import javax.servlet.http.HttpServletResponse;
50 import java.util.ArrayList;
51 import java.util.Enumeration;
52 import java.util.HashMap;
53 import java.util.List;
54 import java.util.Map;
55 import java.util.UUID;
56
57
58
59
60
61 @Controller
62 @RequestMapping(value = org.kuali.rice.krms.impl.util.KrmsImplConstants.WebPaths.AGENDA_EDITOR_PATH)
63 public class AgendaEditorController extends MaintenanceDocumentController {
64
65 private SequenceAccessorService sequenceAccessorService;
66
67
68
69
70
71
72 @RequestMapping(params = "methodToCall=" + "refresh")
73 @Override
74 public ModelAndView refresh(@ModelAttribute("KualiForm") UifFormBase form, BindingResult result,
75 HttpServletRequest request, HttpServletResponse response) throws Exception {
76 ModelAndView modelAndView = super.refresh(form, result, request, response);
77
78
79 MaintenanceForm maintenanceForm = (MaintenanceForm) form;
80 AgendaEditor agendaEditor = ((AgendaEditor) maintenanceForm.getDocument().getNewMaintainableObject().getDataObject());
81 AgendaEditorBusRule rule = new AgendaEditorBusRule();
82 if (rule.validContext(agendaEditor) && rule.validAgendaName(agendaEditor)) {
83
84 if (!StringUtils.equals(agendaEditor.getOldContextId(), agendaEditor.getAgenda().getContextId())) {
85 agendaEditor.setOldContextId(agendaEditor.getAgenda().getContextId());
86
87 String namespace = "";
88 if (!StringUtils.isBlank(agendaEditor.getAgenda().getContextId())) {
89 namespace = getContextBoService().getContextByContextId(agendaEditor.getAgenda().getContextId()).getNamespace();
90 }
91
92 for (AgendaItemBo agendaItem : agendaEditor.getAgenda().getItems()) {
93 agendaItem.getRule().setNamespace(namespace);
94 for (ActionBo action : agendaItem.getRule().getActions()) {
95 action.setNamespace(namespace);
96 }
97 }
98 }
99 }
100 return modelAndView;
101 }
102
103
104
105
106 @RequestMapping(params = "methodToCall=" + "goToAddRule")
107 public ModelAndView goToAddRule(@ModelAttribute("KualiForm") UifFormBase form, BindingResult result,
108 HttpServletRequest request, HttpServletResponse response) throws Exception {
109 setAgendaItemLine(form, null);
110 AgendaEditor agendaEditor = getAgendaEditor(form);
111 agendaEditor.setAddRuleInProgress(true);
112 form.getActionParameters().put(UifParameters.NAVIGATE_TO_PAGE_ID, "AgendaEditorView-AddRule-Page");
113 return super.navigate(form, result, request, response);
114 }
115
116
117
118
119
120
121
122
123
124 private void setAgendaItemLine(UifFormBase form, AgendaItemBo agendaItem) {
125 AgendaEditor agendaEditor = getAgendaEditor(form);
126 if (agendaItem == null) {
127 RuleBo rule = new RuleBo();
128 rule.setId(getSequenceAccessorService().getNextAvailableSequenceNumber("KRMS_RULE_S")
129 .toString());
130 if (StringUtils.isBlank(agendaEditor.getAgenda().getContextId())) {
131 rule.setNamespace("");
132 } else {
133 rule.setNamespace(getContextBoService().getContextByContextId(agendaEditor.getAgenda().getContextId()).getNamespace());
134 }
135 agendaItem = new AgendaItemBo();
136 agendaItem.setRule(rule);
137 agendaEditor.setAgendaItemLine(agendaItem);
138 } else {
139
140 agendaEditor.setAgendaItemLine((AgendaItemBo) ObjectUtils.deepCopy(agendaItem));
141 }
142
143
144 if (agendaItem.getRule().getActions().isEmpty()) {
145 ActionBo actionBo = new ActionBo();
146 actionBo.setTypeId("");
147 actionBo.setNamespace(agendaItem.getRule().getNamespace());
148 actionBo.setRuleId(agendaItem.getRule().getId());
149 actionBo.setSequenceNumber(1);
150 agendaEditor.setAgendaItemLineRuleAction(actionBo);
151 } else {
152 agendaEditor.setAgendaItemLineRuleAction(agendaItem.getRule().getActions().get(0));
153 }
154
155 agendaEditor.setCustomRuleActionAttributesMap(agendaEditor.getAgendaItemLineRuleAction().getAttributes());
156 agendaEditor.setCustomRuleAttributesMap(agendaEditor.getAgendaItemLine().getRule().getAttributes());
157 }
158
159
160
161
162
163
164
165 private String getSelectedAgendaItemId(UifFormBase form) {
166 AgendaEditor agendaEditor = getAgendaEditor(form);
167 return agendaEditor.getSelectedAgendaItemId();
168 }
169
170
171
172
173
174
175
176 private void setCutAgendaItemId(UifFormBase form, String cutAgendaItemId) {
177 AgendaEditor agendaEditor = getAgendaEditor(form);
178 agendaEditor.setCutAgendaItemId(cutAgendaItemId);
179 }
180
181
182
183
184
185
186
187 private String getCutAgendaItemId(UifFormBase form) {
188 AgendaEditor agendaEditor = getAgendaEditor(form);
189 return agendaEditor.getCutAgendaItemId();
190 }
191
192
193
194
195 @RequestMapping(params = "methodToCall=" + "goToEditRule")
196 public ModelAndView goToEditRule(@ModelAttribute("KualiForm") UifFormBase form, BindingResult result,
197 HttpServletRequest request, HttpServletResponse response) throws Exception {
198
199 AgendaEditor agendaEditor = getAgendaEditor(form);
200 agendaEditor.setAddRuleInProgress(false);
201
202 AgendaItemBo firstItem = getFirstAgendaItem(agendaEditor.getAgenda());
203 String selectedItemId = agendaEditor.getSelectedAgendaItemId();
204 AgendaItemBo node = getAgendaItemById(firstItem, selectedItemId);
205
206 setAgendaItemLine(form, node);
207
208 form.getActionParameters().put(UifParameters.NAVIGATE_TO_PAGE_ID, "AgendaEditorView-EditRule-Page");
209 return super.navigate(form, result, request, response);
210 }
211
212
213
214
215 @RequestMapping(params = "methodToCall=" + "addRule")
216 public ModelAndView addRule(@ModelAttribute("KualiForm") UifFormBase form, BindingResult result,
217 HttpServletRequest request, HttpServletResponse response) throws Exception {
218
219 AgendaEditor agendaEditor = getAgendaEditor(form);
220 AgendaBo agenda = agendaEditor.getAgenda();
221 AgendaItemBo newAgendaItem = agendaEditor.getAgendaItemLine();
222
223 newAgendaItem.getRule().setAttributes(agendaEditor.getCustomRuleAttributesMap());
224 updateRuleAction(agendaEditor);
225
226 if (agenda.getItems() == null) {
227 agenda.setItems(new ArrayList<AgendaItemBo>());
228 }
229
230 AgendaEditorBusRule rule = new AgendaEditorBusRule();
231 MaintenanceForm maintenanceForm = (MaintenanceForm) form;
232 MaintenanceDocument document = maintenanceForm.getDocument();
233 if (rule.processAgendaItemBusinessRules(document)) {
234 newAgendaItem.setId(getSequenceAccessorService().getNextAvailableSequenceNumber("KRMS_AGENDA_ITM_S")
235 .toString());
236 newAgendaItem.setAgendaId(getCreateAgendaId(agenda));
237 if (agenda.getFirstItemId() == null) {
238 agenda.setFirstItemId(newAgendaItem.getId());
239 } else {
240
241 String selectedAgendaItemId = getSelectedAgendaItemId(form);
242 if (StringUtils.isBlank(selectedAgendaItemId)) {
243
244 AgendaItemBo node = getFirstAgendaItem(agenda);
245 while (node.getAlways() != null) {
246 node = node.getAlways();
247 }
248 node.setAlwaysId(newAgendaItem.getId());
249 node.setAlways(newAgendaItem);
250 } else {
251
252 AgendaItemBo firstItem = getFirstAgendaItem(agenda);
253 AgendaItemBo node = getAgendaItemById(firstItem, selectedAgendaItemId);
254 newAgendaItem.setAlwaysId(node.getAlwaysId());
255 newAgendaItem.setAlways(node.getAlways());
256 node.setAlwaysId(newAgendaItem.getId());
257 node.setAlways(newAgendaItem);
258 }
259 }
260
261 agenda.getItems().add(newAgendaItem);
262 agendaEditor.setAddRuleInProgress(false);
263 form.getActionParameters().put(UifParameters.NAVIGATE_TO_PAGE_ID, "AgendaEditorView-Agenda-Page");
264 } else {
265 form.getActionParameters().put(UifParameters.NAVIGATE_TO_PAGE_ID, "AgendaEditorView-AddRule-Page");
266 }
267 return super.navigate(form, result, request, response);
268 }
269
270
271
272
273 private String getCreateAgendaId(AgendaBo agenda) {
274 if (agenda.getId() == null) {
275 agenda.setId(getSequenceAccessorService().getNextAvailableSequenceNumber("KRMS_AGENDA_S").toString());
276 }
277 return agenda.getId();
278 }
279
280 private void updateRuleAction(AgendaEditor agendaEditor) {
281 agendaEditor.getAgendaItemLine().getRule().setActions(new ArrayList<ActionBo>());
282 if (StringUtils.isNotBlank(agendaEditor.getAgendaItemLineRuleAction().getTypeId())) {
283 agendaEditor.getAgendaItemLineRuleAction().setAttributes(agendaEditor.getCustomRuleActionAttributesMap());
284 agendaEditor.getAgendaItemLine().getRule().getActions().add(agendaEditor.getAgendaItemLineRuleAction());
285 }
286 }
287
288
289
290
291
292
293
294 private Map<String, KrmsAttributeDefinition> buildAttributeDefinitionMap(String actionTypeId) {
295 KrmsAttributeDefinitionService attributeDefinitionService =
296 KrmsRepositoryServiceLocator.getKrmsAttributeDefinitionService();
297
298
299 Map<String, KrmsAttributeDefinition> attributeDefinitionMap = new HashMap<String, KrmsAttributeDefinition>();
300
301 List<KrmsAttributeDefinition> attributeDefinitions =
302 attributeDefinitionService.findAttributeDefinitionsByType(actionTypeId);
303
304 for (KrmsAttributeDefinition attributeDefinition : attributeDefinitions) {
305 attributeDefinitionMap.put(attributeDefinition.getName(), attributeDefinition);
306 }
307 return attributeDefinitionMap;
308 }
309
310
311
312
313 @RequestMapping(params = "methodToCall=" + "editRule")
314 public ModelAndView editRule(@ModelAttribute("KualiForm") UifFormBase form, BindingResult result,
315 HttpServletRequest request, HttpServletResponse response) throws Exception {
316 AgendaEditor agendaEditor = getAgendaEditor(form);
317
318 AgendaItemBo firstItem = getFirstAgendaItem(agendaEditor.getAgenda());
319 AgendaItemBo node = getAgendaItemById(firstItem, getSelectedAgendaItemId(form));
320 AgendaItemBo agendaItemLine = agendaEditor.getAgendaItemLine();
321
322 agendaItemLine.getRule().setAttributes(agendaEditor.getCustomRuleAttributesMap());
323 updateRuleAction(agendaEditor);
324
325 AgendaEditorBusRule rule = new AgendaEditorBusRule();
326 MaintenanceForm maintenanceForm = (MaintenanceForm) form;
327 MaintenanceDocument document = maintenanceForm.getDocument();
328 if (rule.processAgendaItemBusinessRules(document)) {
329 node.setRule(agendaItemLine.getRule());
330 form.getActionParameters().put(UifParameters.NAVIGATE_TO_PAGE_ID, "AgendaEditorView-Agenda-Page");
331 } else {
332 form.getActionParameters().put(UifParameters.NAVIGATE_TO_PAGE_ID, "AgendaEditorView-EditRule-Page");
333 }
334 return super.navigate(form, result, request, response);
335 }
336
337
338
339
340
341
342 private AgendaItemInstanceChildAccessor getLastChildsAlwaysAccessor(AgendaItemInstanceChildAccessor instanceAccessor) {
343 AgendaItemBo next = instanceAccessor.getChild();
344 if (next == null) return instanceAccessor;
345 while (next.getAlways() != null) { next = next.getAlways(); };
346 return new AgendaItemInstanceChildAccessor(AgendaItemChildAccessor.always, next);
347 }
348
349
350
351
352
353
354 private AgendaItemInstanceChildAccessor getInstanceAccessorToChild(AgendaItemBo parent, String agendaItemId) {
355
356
357 for (AgendaItemChildAccessor levelOrderChildAccessor : AgendaItemChildAccessor.children) {
358
359 AgendaItemBo next = levelOrderChildAccessor.getChild(parent);
360
361
362 if (next != null && agendaItemId.equals(next.getId())) return new AgendaItemInstanceChildAccessor(levelOrderChildAccessor, parent);
363
364
365 while (next != null && next.getAlwaysId() != null) {
366 if (next.getAlwaysId().equals(agendaItemId)) return new AgendaItemInstanceChildAccessor(AgendaItemChildAccessor.always, next);
367
368 next = next.getAlways();
369 }
370 }
371
372 return null;
373 }
374
375 @RequestMapping(params = "methodToCall=" + "ajaxRefresh")
376 public ModelAndView ajaxRefresh(@ModelAttribute("KualiForm") UifFormBase form, BindingResult result,
377 HttpServletRequest request, HttpServletResponse response)
378 throws Exception {
379
380 return super.updateComponent(form, result, request, response);
381 }
382
383 @RequestMapping(params = "methodToCall=" + "moveUp")
384 public ModelAndView moveUp(@ModelAttribute("KualiForm") UifFormBase form, BindingResult result,
385 HttpServletRequest request, HttpServletResponse response)
386 throws Exception {
387 moveSelectedSubtreeUp(form);
388
389 return super.refresh(form, result, request, response);
390 }
391
392 @RequestMapping(params = "methodToCall=" + "ajaxMoveUp")
393 public ModelAndView ajaxMoveUp(@ModelAttribute("KualiForm") UifFormBase form, BindingResult result,
394 HttpServletRequest request, HttpServletResponse response)
395 throws Exception {
396 moveSelectedSubtreeUp(form);
397
398
399 return super.updateComponent(form, result, request, response);
400 }
401
402
403
404
405
406
407 private void moveSelectedSubtreeUp(UifFormBase form) {
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428 AgendaEditor agendaEditor = getAgendaEditor(form);
429
430 AgendaItemBo firstItem = getFirstAgendaItem(agendaEditor.getAgenda());
431
432 String selectedItemId = agendaEditor.getSelectedAgendaItemId();
433 AgendaItemBo node = getAgendaItemById(firstItem, selectedItemId);
434 AgendaItemBo parent = getParent(firstItem, selectedItemId);
435 AgendaItemBo parentsOlderCousin = (parent == null) ? null : getNextOldestOfSameGeneration(firstItem, parent);
436
437 AgendaItemChildAccessor childAccessor = getOldestChildAccessor(node, parent);
438 if (childAccessor != null) {
439 if (childAccessor == AgendaItemChildAccessor.whenFalse) {
440
441 AgendaItemInstanceChildAccessor youngestWhenTrueSiblingInsertionPoint =
442 getLastChildsAlwaysAccessor(new AgendaItemInstanceChildAccessor(AgendaItemChildAccessor.whenTrue, parent));
443 youngestWhenTrueSiblingInsertionPoint.setChild(node);
444 AgendaItemChildAccessor.whenFalse.setChild(parent, node.getAlways());
445 AgendaItemChildAccessor.always.setChild(node, null);
446
447 } else if (parentsOlderCousin != null) {
448
449 AgendaItemInstanceChildAccessor youngestWhenFalseSiblingInsertionPoint =
450 getLastChildsAlwaysAccessor(new AgendaItemInstanceChildAccessor(AgendaItemChildAccessor.whenFalse, parentsOlderCousin));
451 youngestWhenFalseSiblingInsertionPoint.setChild(node);
452 AgendaItemChildAccessor.whenTrue.setChild(parent, node.getAlways());
453 AgendaItemChildAccessor.always.setChild(node, null);
454 }
455 } else if (!selectedItemId.equals(firstItem.getId())) {
456
457 AgendaItemBo bogusRootNode = null;
458 if (parent == null) {
459
460 bogusRootNode = new AgendaItemBo();
461 AgendaItemChildAccessor.whenTrue.setChild(bogusRootNode, firstItem);
462 parent = bogusRootNode;
463 }
464
465
466 AgendaItemInstanceChildAccessor accessorToSelectedNode = getInstanceAccessorToChild(parent, node.getId());
467 AgendaItemBo olderSibling = accessorToSelectedNode.getInstance();
468 AgendaItemInstanceChildAccessor accessorToOlderSibling = getInstanceAccessorToChild(parent, olderSibling.getId());
469
470 accessorToOlderSibling.setChild(node);
471 accessorToSelectedNode.setChild(node.getAlways());
472 AgendaItemChildAccessor.always.setChild(node, olderSibling);
473
474 if (bogusRootNode != null) {
475
476 agendaEditor.getAgenda().setFirstItemId(bogusRootNode.getWhenTrueId());
477 }
478 }
479 }
480
481 @RequestMapping(params = "methodToCall=" + "moveDown")
482 public ModelAndView moveDown(@ModelAttribute("KualiForm") UifFormBase form, BindingResult result,
483 HttpServletRequest request, HttpServletResponse response)
484 throws Exception {
485 moveSelectedSubtreeDown(form);
486
487 return super.refresh(form, result, request, response);
488 }
489
490 @RequestMapping(params = "methodToCall=" + "ajaxMoveDown")
491 public ModelAndView ajaxMoveDown(@ModelAttribute("KualiForm") UifFormBase form, BindingResult result,
492 HttpServletRequest request, HttpServletResponse response)
493 throws Exception {
494 moveSelectedSubtreeDown(form);
495
496
497 return super.updateComponent(form, result, request, response);
498 }
499
500
501
502
503
504
505 private void moveSelectedSubtreeDown(UifFormBase form) {
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526 AgendaEditor agendaEditor = getAgendaEditor(form);
527
528 AgendaItemBo firstItem = getFirstAgendaItem(agendaEditor.getAgenda());
529
530 String selectedItemId = agendaEditor.getSelectedAgendaItemId();
531 AgendaItemBo node = getAgendaItemById(firstItem, selectedItemId);
532 AgendaItemBo parent = getParent(firstItem, selectedItemId);
533 AgendaItemBo parentsYoungerCousin = (parent == null) ? null : getNextYoungestOfSameGeneration(firstItem, parent);
534
535 if (node.getAlways() == null && parent != null) {
536
537 if (parent.getWhenTrue() != null && isSiblings(parent.getWhenTrue(), node)) {
538
539
540 AgendaItemInstanceChildAccessor accessorToSelectedNode = getInstanceAccessorToChild(parent, node.getId());
541 accessorToSelectedNode.setChild(null);
542
543 AgendaItemBo parentsFirstChild = parent.getWhenFalse();
544 AgendaItemChildAccessor.whenFalse.setChild(parent, node);
545 AgendaItemChildAccessor.always.setChild(node, parentsFirstChild);
546 } else if (parentsYoungerCousin != null) {
547
548
549 AgendaItemInstanceChildAccessor accessorToSelectedNode = getInstanceAccessorToChild(parent, node.getId());
550 accessorToSelectedNode.setChild(null);
551
552 AgendaItemBo parentsYoungerCousinsFirstChild = parentsYoungerCousin.getWhenTrue();
553 AgendaItemChildAccessor.whenTrue.setChild(parentsYoungerCousin, node);
554 AgendaItemChildAccessor.always.setChild(node, parentsYoungerCousinsFirstChild);
555 }
556 } else if (node.getAlways() != null) {
557
558 AgendaItemBo bogusRootNode = null;
559 if (parent == null) {
560
561 bogusRootNode = new AgendaItemBo();
562 AgendaItemChildAccessor.whenFalse.setChild(bogusRootNode, firstItem);
563 parent = bogusRootNode;
564 }
565
566
567 AgendaItemInstanceChildAccessor accessorToSelectedNode = getInstanceAccessorToChild(parent, node.getId());
568 AgendaItemBo youngerSibling = node.getAlways();
569 accessorToSelectedNode.setChild(youngerSibling);
570 AgendaItemChildAccessor.always.setChild(node, youngerSibling.getAlways());
571 AgendaItemChildAccessor.always.setChild(youngerSibling, node);
572
573 if (bogusRootNode != null) {
574
575 agendaEditor.getAgenda().setFirstItemId(bogusRootNode.getWhenFalseId());
576 }
577 }
578 }
579
580 @RequestMapping(params = "methodToCall=" + "moveLeft")
581 public ModelAndView moveLeft(@ModelAttribute("KualiForm") UifFormBase form, BindingResult result,
582 HttpServletRequest request, HttpServletResponse response)
583 throws Exception {
584 moveSelectedSubtreeLeft(form);
585
586 return super.refresh(form, result, request, response);
587 }
588
589 @RequestMapping(params = "methodToCall=" + "ajaxMoveLeft")
590 public ModelAndView ajaxMoveLeft(@ModelAttribute("KualiForm") UifFormBase form, BindingResult result,
591 HttpServletRequest request, HttpServletResponse response)
592 throws Exception {
593
594 moveSelectedSubtreeLeft(form);
595
596
597 return super.updateComponent(form, result, request, response);
598 }
599
600
601
602
603
604
605 private void moveSelectedSubtreeLeft(UifFormBase form) {
606
607
608
609
610
611 AgendaEditor agendaEditor = getAgendaEditor(form);
612
613 AgendaItemBo firstItem = getFirstAgendaItem(agendaEditor.getAgenda());
614
615 String selectedItemId = agendaEditor.getSelectedAgendaItemId();
616 AgendaItemBo node = getAgendaItemById(firstItem, selectedItemId);
617 AgendaItemBo parent = getParent(firstItem, selectedItemId);
618
619 if (parent != null) {
620 AgendaItemInstanceChildAccessor accessorToSelectedNode = getInstanceAccessorToChild(parent, node.getId());
621 accessorToSelectedNode.setChild(node.getAlways());
622
623 AgendaItemChildAccessor.always.setChild(node, parent.getAlways());
624 AgendaItemChildAccessor.always.setChild(parent, node);
625 }
626 }
627
628
629 @RequestMapping(params = "methodToCall=" + "moveRight")
630 public ModelAndView moveRight(@ModelAttribute("KualiForm") UifFormBase form, BindingResult result,
631 HttpServletRequest request, HttpServletResponse response)
632 throws Exception {
633
634 moveSelectedSubtreeRight(form);
635
636 return super.refresh(form, result, request, response);
637 }
638
639 @RequestMapping(params = "methodToCall=" + "ajaxMoveRight")
640 public ModelAndView ajaxMoveRight(@ModelAttribute("KualiForm") UifFormBase form, BindingResult result,
641 HttpServletRequest request, HttpServletResponse response)
642 throws Exception {
643
644 moveSelectedSubtreeRight(form);
645
646
647 return super.updateComponent(form, result, request, response);
648 }
649
650
651
652
653
654
655 private void moveSelectedSubtreeRight(UifFormBase form) {
656
657
658
659
660
661
662
663 AgendaEditor agendaEditor = getAgendaEditor(form);
664
665 AgendaItemBo firstItem = getFirstAgendaItem(agendaEditor.getAgenda());
666
667 String selectedItemId = agendaEditor.getSelectedAgendaItemId();
668 AgendaItemBo node = getAgendaItemById(firstItem, selectedItemId);
669 AgendaItemBo parent = getParent(firstItem, selectedItemId);
670
671 AgendaItemBo bogusRootNode = null;
672 if (parent == null) {
673
674 bogusRootNode = new AgendaItemBo();
675 AgendaItemChildAccessor.whenFalse.setChild(bogusRootNode, firstItem);
676 parent = bogusRootNode;
677 }
678
679 AgendaItemInstanceChildAccessor accessorToSelectedNode = getInstanceAccessorToChild(parent, node.getId());
680 AgendaItemBo olderSibling = (accessorToSelectedNode.getInstance() == parent) ? null : accessorToSelectedNode.getInstance();
681
682 if (olderSibling != null) {
683 accessorToSelectedNode.setChild(node.getAlways());
684 AgendaItemInstanceChildAccessor yougestWhenFalseSiblingInsertionPoint =
685 getLastChildsAlwaysAccessor(new AgendaItemInstanceChildAccessor(AgendaItemChildAccessor.whenFalse, olderSibling));
686 yougestWhenFalseSiblingInsertionPoint.setChild(node);
687 AgendaItemChildAccessor.always.setChild(node, null);
688 } else if (node.getAlways() != null) {
689 accessorToSelectedNode.setChild(node.getAlways());
690 AgendaItemBo childsWhenTrue = node.getAlways().getWhenTrue();
691 AgendaItemChildAccessor.whenTrue.setChild(node.getAlways(), node);
692 AgendaItemChildAccessor.always.setChild(node, childsWhenTrue);
693 }
694
695 if (bogusRootNode != null) {
696
697 agendaEditor.getAgenda().setFirstItemId(bogusRootNode.getWhenFalseId());
698 }
699 }
700
701
702
703
704
705
706
707
708 private boolean isSiblings(AgendaItemBo cousin1, AgendaItemBo cousin2) {
709 if (cousin1.equals(cousin2)) return true;
710
711
712 AgendaItemBo candidate = cousin2;
713 while (null != (candidate = candidate.getAlways())) {
714 if (candidate.equals(cousin1)) return true;
715 }
716
717 candidate = cousin1;
718 while (null != (candidate = candidate.getAlways())) {
719 if (candidate.equals(cousin2)) return true;
720 }
721 return false;
722 }
723
724
725
726
727
728
729
730 private AgendaItemChildAccessor getOldestChildAccessor(
731 AgendaItemBo child, AgendaItemBo parent) {
732 AgendaItemChildAccessor levelOrderChildAccessor = null;
733
734 if (parent != null) {
735 for (AgendaItemChildAccessor childAccessor : AgendaItemChildAccessor.children) {
736 if (child.equals(childAccessor.getChild(parent))) {
737 levelOrderChildAccessor = childAccessor;
738 break;
739 }
740 }
741 }
742 return levelOrderChildAccessor;
743 }
744
745
746
747
748
749
750
751 private AgendaItemBo getFirstAgendaItem(AgendaBo agenda) {
752 AgendaItemBo firstItem = null;
753 if (agenda != null && agenda.getItems() != null) for (AgendaItemBo agendaItem : agenda.getItems()) {
754 if (agenda.getFirstItemId().equals(agendaItem.getId())) {
755 firstItem = agendaItem;
756 break;
757 }
758 }
759 return firstItem;
760 }
761
762
763
764
765
766
767 private AgendaItemBo getNextYoungestOfSameGeneration(AgendaItemBo root, AgendaItemBo agendaItem) {
768
769 int genNumber = getAgendaItemGenerationNumber(0, root, agendaItem.getId());
770 List<AgendaItemBo> genList = new ArrayList<AgendaItemBo>();
771 buildAgendaItemGenerationList(genList, root, 0, genNumber);
772
773 int itemIndex = genList.indexOf(agendaItem);
774 if (genList.size() > itemIndex + 1) return genList.get(itemIndex + 1);
775
776 return null;
777 }
778
779
780
781
782
783
784
785
786
787 private int getAgendaItemGenerationNumber(int currentLevel, AgendaItemBo node, String agendaItemId) {
788 int result = -1;
789 if (agendaItemId.equals(node.getId())) {
790 result = currentLevel;
791 } else {
792 for (AgendaItemChildAccessor childAccessor : AgendaItemChildAccessor.linkedNodes) {
793 AgendaItemBo child = childAccessor.getChild(node);
794 if (child != null) {
795 int nextLevel = currentLevel;
796
797 if (childAccessor != AgendaItemChildAccessor.always) {
798 nextLevel = currentLevel +1;
799 }
800 result = getAgendaItemGenerationNumber(nextLevel, child, agendaItemId);
801 if (result != -1) break;
802 }
803 }
804 }
805 return result;
806 }
807
808
809
810
811
812
813
814
815
816 private void buildAgendaItemGenerationList(List<AgendaItemBo> genList, AgendaItemBo node, int currentLevel, int generation) {
817 if (currentLevel == generation) {
818 genList.add(node);
819 }
820
821 if (currentLevel > generation) return;
822
823 for (AgendaItemChildAccessor childAccessor : AgendaItemChildAccessor.linkedNodes) {
824 AgendaItemBo child = childAccessor.getChild(node);
825 if (child != null) {
826 int nextLevel = currentLevel;
827
828 if (childAccessor != AgendaItemChildAccessor.always) {
829 nextLevel = currentLevel +1;
830 }
831 buildAgendaItemGenerationList(genList, child, nextLevel, generation);
832 }
833 }
834 }
835
836
837
838
839
840
841 private AgendaItemBo getNextOldestOfSameGeneration(AgendaItemBo root, AgendaItemBo agendaItem) {
842
843 int genNumber = getAgendaItemGenerationNumber(0, root, agendaItem.getId());
844 List<AgendaItemBo> genList = new ArrayList<AgendaItemBo>();
845 buildAgendaItemGenerationList(genList, root, 0, genNumber);
846
847 int itemIndex = genList.indexOf(agendaItem);
848 if (itemIndex >= 1) return genList.get(itemIndex - 1);
849
850 return null;
851 }
852
853
854
855
856
857
858 private AgendaItemBo getParent(AgendaItemBo root, String agendaItemId) {
859 return getParentHelper(root, null, agendaItemId);
860 }
861
862
863
864
865
866
867
868
869
870 private AgendaItemBo getParentHelper(AgendaItemBo node, AgendaItemBo levelOrderParent, String agendaItemId) {
871 AgendaItemBo result = null;
872 if (agendaItemId.equals(node.getId())) {
873 result = levelOrderParent;
874 } else {
875 for (AgendaItemChildAccessor childAccessor : AgendaItemChildAccessor.linkedNodes) {
876 AgendaItemBo child = childAccessor.getChild(node);
877 if (child != null) {
878
879 AgendaItemBo lop = (childAccessor == AgendaItemChildAccessor.always) ? levelOrderParent : node;
880 result = getParentHelper(child, lop, agendaItemId);
881 if (result != null) break;
882 }
883 }
884 }
885 return result;
886 }
887
888
889
890
891 private AgendaItemBo getAgendaItemById(AgendaItemBo node, String agendaItemId) {
892 if (node == null) throw new IllegalArgumentException("node must be non-null");
893
894 AgendaItemBo result = null;
895
896 if (agendaItemId.equals(node.getId())) {
897 result = node;
898 } else {
899 for (AgendaItemChildAccessor childAccessor : AgendaItemChildAccessor.linkedNodes) {
900 AgendaItemBo child = childAccessor.getChild(node);
901 if (child != null) {
902 result = getAgendaItemById(child, agendaItemId);
903 if (result != null) break;
904 }
905 }
906 }
907 return result;
908 }
909
910
911
912
913
914 private AgendaEditor getAgendaEditor(UifFormBase form) {
915 MaintenanceForm maintenanceForm = (MaintenanceForm) form;
916 return ((AgendaEditor)maintenanceForm.getDocument().getDocumentDataObject());
917 }
918
919 private void treeToInOrderList(AgendaItemBo agendaItem, List<AgendaItemBo> listToBuild) {
920 listToBuild.add(agendaItem);
921 for (AgendaItemChildAccessor childAccessor : AgendaItemChildAccessor.linkedNodes) {
922 AgendaItemBo child = childAccessor.getChild(agendaItem);
923 if (child != null) treeToInOrderList(child, listToBuild);
924 }
925 }
926
927
928 @RequestMapping(params = "methodToCall=" + "delete")
929 public ModelAndView delete(@ModelAttribute("KualiForm") UifFormBase form, BindingResult result,
930 HttpServletRequest request, HttpServletResponse response)
931 throws Exception {
932
933 deleteSelectedSubtree(form);
934
935 return super.refresh(form, result, request, response);
936 }
937
938 @RequestMapping(params = "methodToCall=" + "ajaxDelete")
939 public ModelAndView ajaxDelete(@ModelAttribute("KualiForm") UifFormBase form, BindingResult result,
940 HttpServletRequest request, HttpServletResponse response)
941 throws Exception {
942
943 deleteSelectedSubtree(form);
944
945
946 return super.updateComponent(form, result, request, response);
947 }
948
949
950 private void deleteSelectedSubtree(UifFormBase form) {
951 AgendaEditor agendaEditor = getAgendaEditor(form);
952 AgendaItemBo firstItem = getFirstAgendaItem(agendaEditor.getAgenda());
953 String agendaItemSelected = agendaEditor.getSelectedAgendaItemId();
954 AgendaItemBo selectedItem = getAgendaItemById(firstItem, agendaItemSelected);
955
956 if (firstItem != null) {
957
958 if (agendaItemSelected.equals(firstItem.getId())) {
959 agendaEditor.getAgenda().setFirstItemId(firstItem.getAlwaysId());
960 } else {
961 deleteAgendaItem(firstItem, agendaItemSelected);
962 }
963
964
965 if (selectedItem.getWhenTrue() != null) {
966 removeAgendaItem(agendaEditor.getAgenda().getItems(), selectedItem.getWhenTrue());
967 }
968 if (selectedItem.getWhenFalse() != null) {
969 removeAgendaItem(agendaEditor.getAgenda().getItems(), selectedItem.getWhenFalse());
970 }
971 agendaEditor.getAgenda().getItems().remove(selectedItem);
972 }
973 }
974
975 private void deleteAgendaItem(AgendaItemBo root, String agendaItemIdToDelete) {
976 if (deleteAgendaItem(root, AgendaItemChildAccessor.whenTrue, agendaItemIdToDelete) ||
977 deleteAgendaItem(root, AgendaItemChildAccessor.whenFalse, agendaItemIdToDelete) ||
978 deleteAgendaItem(root, AgendaItemChildAccessor.always, agendaItemIdToDelete));
979 }
980
981 private boolean deleteAgendaItem(AgendaItemBo agendaItem, AgendaItemChildAccessor childAccessor, String agendaItemIdToDelete) {
982 if (agendaItem == null || childAccessor.getChild(agendaItem) == null) return false;
983 if (agendaItemIdToDelete.equals(childAccessor.getChild(agendaItem).getId())) {
984
985 AgendaItemBo grandchildToKeep = childAccessor.getChild(agendaItem).getAlways();
986 childAccessor.setChild(agendaItem, grandchildToKeep);
987 return true;
988 } else {
989 AgendaItemBo child = childAccessor.getChild(agendaItem);
990
991 for (AgendaItemChildAccessor nextChildAccessor : AgendaItemChildAccessor.linkedNodes) {
992 if (deleteAgendaItem(child, nextChildAccessor, agendaItemIdToDelete)) return true;
993 }
994 }
995 return false;
996 }
997
998
999
1000
1001
1002
1003 private void removeAgendaItem(List<AgendaItemBo> items, AgendaItemBo removeAgendaItem) {
1004 if (removeAgendaItem.getWhenTrue() != null) {
1005 removeAgendaItem(items, removeAgendaItem.getWhenTrue());
1006 }
1007 if (removeAgendaItem.getWhenFalse() != null) {
1008 removeAgendaItem(items, removeAgendaItem.getWhenFalse());
1009 }
1010 if (removeAgendaItem.getAlways() != null) {
1011 removeAgendaItem(items, removeAgendaItem.getAlways());
1012 }
1013 items.remove(removeAgendaItem);
1014 }
1015
1016 @RequestMapping(params = "methodToCall=" + "ajaxCut")
1017 public ModelAndView ajaxCut(@ModelAttribute("KualiForm") UifFormBase form, BindingResult result,
1018 HttpServletRequest request, HttpServletResponse response) throws Exception {
1019
1020 AgendaEditor agendaEditor = getAgendaEditor(form);
1021
1022 AgendaItemBo firstItem = getFirstAgendaItem(agendaEditor.getAgenda());
1023 String selectedItemId = agendaEditor.getSelectedAgendaItemId();
1024
1025 setCutAgendaItemId(form, selectedItemId);
1026
1027
1028 return super.updateComponent(form, result, request, response);
1029 }
1030
1031 @RequestMapping(params = "methodToCall=" + "ajaxPaste")
1032 public ModelAndView ajaxPaste(@ModelAttribute("KualiForm") UifFormBase form, BindingResult result,
1033 HttpServletRequest request, HttpServletResponse response) throws Exception {
1034
1035 AgendaEditor agendaEditor = getAgendaEditor(form);
1036
1037 AgendaItemBo firstItem = getFirstAgendaItem(agendaEditor.getAgenda());
1038 String selectedItemId = agendaEditor.getSelectedAgendaItemId();
1039
1040 String agendaItemId = getCutAgendaItemId(form);
1041
1042 if (StringUtils.isNotBlank(selectedItemId) && StringUtils.isNotBlank(agendaItemId)) {
1043 AgendaItemBo node = getAgendaItemById(firstItem, agendaItemId);
1044 AgendaItemBo orgRefNode = getReferringNode(firstItem, agendaItemId);
1045 AgendaItemBo newRefNode = getAgendaItemById(firstItem, selectedItemId);
1046
1047 if (isSameOrChildNode(node, newRefNode)) {
1048
1049 } else {
1050
1051 if (orgRefNode == null) {
1052 agendaEditor.getAgenda().setFirstItemId(node.getAlwaysId());
1053 } else {
1054
1055
1056 if (node.getId().equals(orgRefNode.getWhenTrueId())) {
1057 orgRefNode.setWhenTrueId(node.getAlwaysId());
1058 orgRefNode.setWhenTrue(node.getAlways());
1059 } else if(node.getId().equals(orgRefNode.getWhenFalseId())) {
1060 orgRefNode.setWhenFalseId(node.getAlwaysId());
1061 orgRefNode.setWhenFalse(node.getAlways());
1062 } else {
1063 orgRefNode.setAlwaysId(node.getAlwaysId());
1064 orgRefNode.setAlways(node.getAlways());
1065 }
1066 }
1067
1068
1069 node.setAlwaysId(newRefNode.getAlwaysId());
1070 node.setAlways(newRefNode.getAlways());
1071 newRefNode.setAlwaysId(node.getId());
1072 newRefNode.setAlways(node);
1073 }
1074 }
1075
1076 setCutAgendaItemId(form, null);
1077
1078
1079 return super.updateComponent(form, result, request, response);
1080 }
1081
1082
1083
1084
1085
1086 @RequestMapping(params = "methodToCall=" + "ajaxCategoryChangeRefresh")
1087 public ModelAndView ajaxCategoryChangeRefresh(@ModelAttribute("KualiForm") UifFormBase form, BindingResult result,
1088 HttpServletRequest request, HttpServletResponse response)
1089 throws Exception {
1090
1091 String categoryParamName = null;
1092 Enumeration paramNames = request.getParameterNames();
1093 while (paramNames.hasMoreElements()) {
1094 String paramName = paramNames.nextElement().toString();
1095 if (paramName.endsWith("categoryId")) {
1096 categoryParamName = paramName;
1097 break;
1098 }
1099 }
1100
1101 if (categoryParamName != null) {
1102 String categoryId = request.getParameter(categoryParamName);
1103
1104 if (StringUtils.isBlank(categoryId)) { categoryId = null; }
1105
1106 AgendaEditor agendaEditor = getAgendaEditor(form);
1107 RuleBo rule = agendaEditor.getAgendaItemLine().getRule();
1108 String selectedPropId = agendaEditor.getSelectedPropositionId();
1109
1110
1111 if (!StringUtils.isBlank(selectedPropId)) {
1112 Node<RuleTreeNode, String> selectedPropositionNode =
1113 findPropositionTreeNode(rule.getPropositionTree().getRootElement(), selectedPropId);
1114 selectedPropositionNode.getData().getProposition().setCategoryId(categoryId);
1115 }
1116 }
1117
1118 return ajaxRefresh(form, result, request, response);
1119 }
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130 private boolean isSameOrChildNode(AgendaItemBo node, AgendaItemBo newParent) {
1131 return isSameOrChildNodeHelper(node, newParent, AgendaItemChildAccessor.children);
1132 }
1133
1134 private boolean isSameOrChildNodeHelper(AgendaItemBo node, AgendaItemBo newParent, AgendaItemChildAccessor[] childAccessors) {
1135 boolean result = false;
1136 if (StringUtils.equals(node.getId(), newParent.getId())) {
1137 result = true;
1138 } else {
1139 for (AgendaItemChildAccessor childAccessor : childAccessors) {
1140 AgendaItemBo child = childAccessor.getChild(node);
1141 if (child != null) {
1142 result = isSameOrChildNodeHelper(child, newParent, AgendaItemChildAccessor.linkedNodes);
1143 if (result == true) break;
1144 }
1145 }
1146 }
1147 return result;
1148 }
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159 private AgendaItemBo getReferringNode(AgendaItemBo root, String agendaItemId) {
1160 return getReferringNodeHelper(root, null, agendaItemId);
1161 }
1162
1163 private AgendaItemBo getReferringNodeHelper(AgendaItemBo node, AgendaItemBo referringNode, String agendaItemId) {
1164 AgendaItemBo result = null;
1165 if (agendaItemId.equals(node.getId())) {
1166 result = referringNode;
1167 } else {
1168 for (AgendaItemChildAccessor childAccessor : AgendaItemChildAccessor.linkedNodes) {
1169 AgendaItemBo child = childAccessor.getChild(node);
1170 if (child != null) {
1171 result = getReferringNodeHelper(child, node, agendaItemId);
1172 if (result != null) break;
1173 }
1174 }
1175 }
1176 return result;
1177 }
1178
1179
1180
1181
1182 private SequenceAccessorService getSequenceAccessorService() {
1183 if ( sequenceAccessorService == null ) {
1184 sequenceAccessorService = KRADServiceLocator.getSequenceAccessorService();
1185 }
1186 return sequenceAccessorService;
1187 }
1188
1189
1190
1191
1192 private ContextBoService getContextBoService() {
1193 return KrmsRepositoryServiceLocator.getContextBoService();
1194 }
1195
1196
1197
1198
1199 private RuleBoService getRuleBoService() {
1200 return KrmsRepositoryServiceLocator.getRuleBoService();
1201 }
1202
1203
1204
1205
1206
1207 private static class AgendaItemInstanceChildAccessor {
1208
1209 private final AgendaItemChildAccessor accessor;
1210 private final AgendaItemBo instance;
1211
1212 public AgendaItemInstanceChildAccessor(AgendaItemChildAccessor accessor, AgendaItemBo instance) {
1213 this.accessor = accessor;
1214 this.instance = instance;
1215 }
1216
1217 public void setChild(AgendaItemBo child) {
1218 accessor.setChild(instance, child);
1219 }
1220
1221 public AgendaItemBo getChild() {
1222 return accessor.getChild(instance);
1223 }
1224
1225 public AgendaItemBo getInstance() { return instance; }
1226 }
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256 protected static class AgendaItemChildAccessor {
1257
1258 private enum Child { WHEN_TRUE, WHEN_FALSE, ALWAYS };
1259
1260 private static final AgendaItemChildAccessor whenTrue = new AgendaItemChildAccessor(Child.WHEN_TRUE);
1261 private static final AgendaItemChildAccessor whenFalse = new AgendaItemChildAccessor(Child.WHEN_FALSE);
1262 private static final AgendaItemChildAccessor always = new AgendaItemChildAccessor(Child.ALWAYS);
1263
1264
1265
1266
1267 private static final AgendaItemChildAccessor [] linkedNodes = { whenTrue, whenFalse, always };
1268
1269
1270
1271
1272 private static final AgendaItemChildAccessor [] children = { whenTrue, whenFalse };
1273
1274 private final Child whichChild;
1275
1276 private AgendaItemChildAccessor(Child whichChild) {
1277 if (whichChild == null) throw new IllegalArgumentException("whichChild must be non-null");
1278 this.whichChild = whichChild;
1279 }
1280
1281
1282
1283
1284 public AgendaItemBo getChild(AgendaItemBo parent) {
1285 switch (whichChild) {
1286 case WHEN_TRUE: return parent.getWhenTrue();
1287 case WHEN_FALSE: return parent.getWhenFalse();
1288 case ALWAYS: return parent.getAlways();
1289 default: throw new IllegalStateException();
1290 }
1291 }
1292
1293
1294
1295
1296 public void setChild(AgendaItemBo parent, AgendaItemBo child) {
1297 switch (whichChild) {
1298 case WHEN_TRUE:
1299 parent.setWhenTrue(child);
1300 parent.setWhenTrueId(child == null ? null : child.getId());
1301 break;
1302 case WHEN_FALSE:
1303 parent.setWhenFalse(child);
1304 parent.setWhenFalseId(child == null ? null : child.getId());
1305 break;
1306 case ALWAYS:
1307 parent.setAlways(child);
1308 parent.setAlwaysId(child == null ? null : child.getId());
1309 break;
1310 default: throw new IllegalStateException();
1311 }
1312 }
1313 }
1314
1315
1316
1317 @RequestMapping(params = "methodToCall=" + "copyRule")
1318 public ModelAndView copyRule(@ModelAttribute("KualiForm") UifFormBase form, BindingResult result,
1319 HttpServletRequest request, HttpServletResponse response) throws Exception {
1320
1321 AgendaEditor agendaEditor = getAgendaEditor(form);
1322 String name = agendaEditor.getCopyRuleName();
1323 String namespace = agendaEditor.getNamespace();
1324
1325 RuleDefinition oldRuleDefinition = getRuleBoService().getRuleByNameAndNamespace(name, namespace);
1326 RuleBo oldRule = RuleBo.from(oldRuleDefinition);
1327 RuleBo newRule = RuleBo.copyRule(oldRule);
1328 agendaEditor.getAgendaItemLine().setRule( newRule );
1329
1330 if (!newRule.getActions().isEmpty()) {
1331 agendaEditor.setAgendaItemLineRuleAction( newRule.getActions().get(0));
1332 }
1333 return super.refresh(form, result, request, response);
1334 }
1335
1336
1337
1338
1339
1340 @RequestMapping(params = "methodToCall=" + "goToEditProposition")
1341 public ModelAndView goToEditProposition(@ModelAttribute("KualiForm") UifFormBase form, BindingResult result,
1342 HttpServletRequest request, HttpServletResponse response) throws Exception {
1343
1344
1345 AgendaEditor agendaEditor = getAgendaEditor(form);
1346 RuleBo rule = agendaEditor.getAgendaItemLine().getRule();
1347 String selectedPropId = agendaEditor.getSelectedPropositionId();
1348
1349 Node<RuleTreeNode,String> root = rule.getPropositionTree().getRootElement();
1350 PropositionBo propositionToToggleEdit = null;
1351 boolean newEditMode = true;
1352
1353
1354 Node<RuleTreeNode,String> parent = findParentPropositionNode( root, selectedPropId);
1355 if (parent != null){
1356 List<Node<RuleTreeNode,String>> children = parent.getChildren();
1357 for( int index=0; index< children.size(); index++){
1358 Node<RuleTreeNode,String> child = children.get(index);
1359 if (propIdMatches(child, selectedPropId)){
1360 PropositionBo prop = child.getData().getProposition();
1361 propositionToToggleEdit = prop;
1362 newEditMode = !prop.getEditMode();
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373 break;
1374 } else {
1375 child.getData().getProposition().setEditMode(false);
1376 }
1377 }
1378 }
1379
1380 resetEditModeOnPropositionTree(root);
1381 if (propositionToToggleEdit != null) {
1382 propositionToToggleEdit.setEditMode(newEditMode);
1383
1384 rule.refreshPropositionTree(null);
1385 }
1386
1387 return super.updateComponent(form, result, request, response);
1388 }
1389
1390 @RequestMapping(params = "methodToCall=" + "addProposition")
1391 public ModelAndView addProposition(@ModelAttribute("KualiForm") UifFormBase form, BindingResult result,
1392 HttpServletRequest request, HttpServletResponse response) throws Exception {
1393
1394 AgendaEditor agendaEditor = getAgendaEditor(form);
1395 RuleBo rule = agendaEditor.getAgendaItemLine().getRule();
1396 String selectedPropId = agendaEditor.getSelectedPropositionId();
1397
1398
1399
1400 Node<RuleTreeNode,String> root = agendaEditor.getAgendaItemLine().getRule().getPropositionTree().getRootElement();
1401 Node<RuleTreeNode,String> parent = findParentPropositionNode( root, selectedPropId);
1402
1403 resetEditModeOnPropositionTree(root);
1404
1405
1406 if (parent != null){
1407 List<Node<RuleTreeNode,String>> children = parent.getChildren();
1408 for( int index=0; index< children.size(); index++){
1409 Node<RuleTreeNode,String> child = children.get(index);
1410
1411
1412 if (propIdMatches(child, selectedPropId)){
1413
1414
1415
1416
1417 if (parent == root &&
1418 (SimplePropositionNode.NODE_TYPE.equalsIgnoreCase(child.getNodeType()) ||
1419 SimplePropositionEditNode.NODE_TYPE.equalsIgnoreCase(child.getNodeType()))){
1420
1421
1422 PropositionBo compound = PropositionBo.createCompoundPropositionBoStub(child.getData().getProposition(), true);
1423 compound.setEditMode(true);
1424 rule.setProposition(compound);
1425 rule.refreshPropositionTree(null);
1426 }
1427
1428 else if(SimplePropositionNode.NODE_TYPE.equalsIgnoreCase(child.getNodeType()) ||
1429 SimplePropositionEditNode.NODE_TYPE.equalsIgnoreCase(child.getNodeType())){
1430
1431
1432 PropositionBo blank = PropositionBo.createSimplePropositionBoStub(child.getData().getProposition(),PropositionType.SIMPLE.getCode());
1433
1434 PropositionBo parentProp = parent.getData().getProposition();
1435 parentProp.getCompoundComponents().add(((index/2)+1), blank);
1436
1437 rule.refreshPropositionTree(true);
1438 }
1439
1440 break;
1441 }
1442 }
1443 } else {
1444
1445
1446 if (root.getChildren().isEmpty()){
1447 PropositionBo blank = PropositionBo.createSimplePropositionBoStub(null,PropositionType.SIMPLE.getCode());
1448 blank.setRuleId(rule.getId());
1449 blank.setTypeId(rule.getTypeId());
1450 rule.setPropId(blank.getId());
1451 rule.setProposition(blank);
1452 rule.refreshPropositionTree(true);
1453 }
1454 }
1455 return super.updateComponent(form, result, request, response);
1456 }
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466 private void addOpCodeNode(Node currentNode, PropositionBo prop, int index){
1467 String opCodeLabel = "";
1468
1469 if (LogicalOperator.AND.getCode().equalsIgnoreCase(prop.getCompoundOpCode())){
1470 opCodeLabel = "AND";
1471 } else if (LogicalOperator.OR.getCode().equalsIgnoreCase(prop.getCompoundOpCode())){
1472 opCodeLabel = "OR";
1473 }
1474 Node<RuleTreeNode, String> aNode = new Node<RuleTreeNode, String>();
1475 aNode.setNodeLabel("");
1476 aNode.setNodeType("ruleTreeNode compoundOpCodeNode");
1477 aNode.setData(new CompoundOpCodeNode(prop));
1478 currentNode.insertChildAt(index, aNode);
1479 }
1480
1481
1482 private boolean propIdMatches(Node<RuleTreeNode, String> node, String propId){
1483 if (propId!=null && node != null && node.getData() != null && propId.equalsIgnoreCase(node.getData().getProposition().getId())) {
1484 return true;
1485 }
1486 return false;
1487 }
1488
1489
1490
1491
1492
1493 private void resetEditModeOnPropositionTree(Node<RuleTreeNode, String> currentNode){
1494 if (currentNode.getData() != null){
1495 RuleTreeNode dataNode = currentNode.getData();
1496 dataNode.getProposition().setEditMode(false);
1497 }
1498 List<Node<RuleTreeNode,String>> children = currentNode.getChildren();
1499 for( Node<RuleTreeNode,String> child : children){
1500 resetEditModeOnPropositionTree(child);
1501 }
1502 }
1503
1504 private Node<RuleTreeNode, String> findPropositionTreeNode(Node<RuleTreeNode, String> currentNode, String selectedPropId){
1505 Node<RuleTreeNode,String> bingo = null;
1506 if (currentNode.getData() != null){
1507 RuleTreeNode dataNode = currentNode.getData();
1508 if (selectedPropId.equalsIgnoreCase(dataNode.getProposition().getId())){
1509 return currentNode;
1510 }
1511 }
1512 List<Node<RuleTreeNode,String>> children = currentNode.getChildren();
1513 for( Node<RuleTreeNode,String> child : children){
1514 bingo = findPropositionTreeNode(child, selectedPropId);
1515 if (bingo != null) break;
1516 }
1517 return bingo;
1518 }
1519
1520 private Node<RuleTreeNode, String> findParentPropositionNode(Node<RuleTreeNode, String> currentNode, String selectedPropId){
1521 Node<RuleTreeNode,String> bingo = null;
1522 if (selectedPropId != null) {
1523
1524 List<Node<RuleTreeNode,String>> children = currentNode.getChildren();
1525 for( Node<RuleTreeNode,String> child : children){
1526 RuleTreeNode dataNode = child.getData();
1527 if (selectedPropId.equalsIgnoreCase(dataNode.getProposition().getId()))
1528 return currentNode;
1529 }
1530
1531
1532 for( Node<RuleTreeNode,String> kid : children){
1533 bingo = findParentPropositionNode(kid, selectedPropId);
1534 if (bingo != null) break;
1535 }
1536 }
1537 return bingo;
1538 }
1539
1540
1541
1542
1543
1544
1545
1546 private int findChildIndex(Node<RuleTreeNode,String> parent, String propId){
1547 int index;
1548 List<Node<RuleTreeNode,String>> children = parent.getChildren();
1549 for(index=0; index< children.size(); index++){
1550 Node<RuleTreeNode,String> child = children.get(index);
1551
1552 if (propIdMatches(child, propId)){
1553 return index;
1554 }
1555 }
1556 return -1;
1557 }
1558
1559 @RequestMapping(params = "methodToCall=" + "movePropositionUp")
1560 public ModelAndView movePropositionUp(@ModelAttribute("KualiForm") UifFormBase form, BindingResult result,
1561 HttpServletRequest request, HttpServletResponse response)
1562 throws Exception {
1563 moveSelectedProposition(form, true);
1564
1565 return super.updateComponent(form, result, request, response);
1566 }
1567
1568 @RequestMapping(params = "methodToCall=" + "movePropositionDown")
1569 public ModelAndView movePropositionDown(@ModelAttribute("KualiForm") UifFormBase form, BindingResult result,
1570 HttpServletRequest request, HttpServletResponse response)
1571 throws Exception {
1572 moveSelectedProposition(form, false);
1573
1574 return super.updateComponent(form, result, request, response);
1575 }
1576
1577 private void moveSelectedProposition(UifFormBase form, boolean up) {
1578
1579
1580
1581
1582
1583
1584
1585
1586
1587 AgendaEditor agendaEditor = getAgendaEditor(form);
1588 RuleBo rule = agendaEditor.getAgendaItemLine().getRule();
1589 String selectedPropId = agendaEditor.getSelectedPropositionId();
1590
1591
1592 Node<RuleTreeNode,String> parent = findParentPropositionNode(rule.getPropositionTree().getRootElement(), selectedPropId);
1593
1594
1595 if (parent != null){
1596 List<Node<RuleTreeNode,String>> children = parent.getChildren();
1597 for( int index=0; index< children.size(); index++){
1598 Node<RuleTreeNode,String> child = children.get(index);
1599
1600 if (propIdMatches(child, selectedPropId)){
1601 if(SimplePropositionNode.NODE_TYPE.equalsIgnoreCase(child.getNodeType()) ||
1602 SimplePropositionEditNode.NODE_TYPE.equalsIgnoreCase(child.getNodeType()) ||
1603 RuleTreeNode.COMPOUND_NODE_TYPE.equalsIgnoreCase(child.getNodeType()) ){
1604
1605 if (((index > 0) && up) || ((index <(children.size() - 1)&& !up))){
1606
1607 PropositionBo parentProp = parent.getData().getProposition();
1608 PropositionBo workingProp = parentProp.getCompoundComponents().remove(index/2);
1609 if (up){
1610 parentProp.getCompoundComponents().add((index/2)-1, workingProp);
1611 }else{
1612 parentProp.getCompoundComponents().add((index/2)+1, workingProp);
1613 }
1614
1615
1616
1617 boolean editMode = (SimplePropositionEditNode.NODE_TYPE.equalsIgnoreCase(child.getNodeType()));
1618 rule.refreshPropositionTree(editMode);
1619 }
1620 }
1621
1622 break;
1623 }
1624 }
1625 }
1626 }
1627 @RequestMapping(params = "methodToCall=" + "movePropositionLeft")
1628 public ModelAndView movePropositionLeft(@ModelAttribute("KualiForm") UifFormBase form, BindingResult result,
1629 HttpServletRequest request, HttpServletResponse response)
1630 throws Exception {
1631
1632
1633
1634
1635
1636
1637
1638
1639
1640 AgendaEditor agendaEditor = getAgendaEditor(form);
1641 RuleBo rule = agendaEditor.getAgendaItemLine().getRule();
1642 String selectedPropId = agendaEditor.getSelectedPropositionId();
1643
1644
1645 Node<RuleTreeNode,String> root = rule.getPropositionTree().getRootElement();
1646 Node<RuleTreeNode,String> parent = findParentPropositionNode(root, selectedPropId);
1647 if ((parent != null) && (RuleTreeNode.COMPOUND_NODE_TYPE.equalsIgnoreCase(parent.getNodeType()))){
1648 Node<RuleTreeNode,String> granny = findParentPropositionNode(root,parent.getData().getProposition().getId());
1649 if (granny != root){
1650 int oldIndex = findChildIndex(parent, selectedPropId);
1651 int newIndex = findChildIndex(granny, parent.getData().getProposition().getId());
1652 if (oldIndex >= 0 && newIndex >= 0){
1653 PropositionBo prop = parent.getData().getProposition().getCompoundComponents().remove(oldIndex/2);
1654 granny.getData().getProposition().getCompoundComponents().add((newIndex/2)+1, prop);
1655 rule.refreshPropositionTree(false);
1656 }
1657 } else {
1658
1659
1660
1661 }
1662 }
1663 return super.updateComponent(form, result, request, response);
1664 }
1665
1666 @RequestMapping(params = "methodToCall=" + "movePropositionRight")
1667 public ModelAndView movePropositionRight(@ModelAttribute("KualiForm") UifFormBase form, BindingResult result,
1668 HttpServletRequest request, HttpServletResponse response)
1669 throws Exception {
1670
1671
1672
1673
1674
1675
1676
1677
1678
1679 AgendaEditor agendaEditor = getAgendaEditor(form);
1680 RuleBo rule = agendaEditor.getAgendaItemLine().getRule();
1681 String selectedPropId = agendaEditor.getSelectedPropositionId();
1682
1683
1684 Node<RuleTreeNode,String> parent = findParentPropositionNode(
1685 rule.getPropositionTree().getRootElement(), selectedPropId);
1686 if (parent != null){
1687 int index = findChildIndex(parent, selectedPropId);
1688
1689 if (index >= 0 && index+1 < parent.getChildren().size()){
1690 Node<RuleTreeNode,String> child = parent.getChildren().get(index);
1691 Node<RuleTreeNode,String> nextSibling = parent.getChildren().get(index+2);
1692
1693 if(RuleTreeNode.COMPOUND_NODE_TYPE.equalsIgnoreCase(nextSibling.getNodeType()) ){
1694
1695 PropositionBo prop = parent.getData().getProposition().getCompoundComponents().remove(index/2);
1696
1697 nextSibling.getData().getProposition().getCompoundComponents().add(0, prop);
1698 rule.refreshPropositionTree(false);
1699 }
1700 }
1701 }
1702 return super.updateComponent(form, result, request, response);
1703 }
1704
1705
1706
1707
1708
1709
1710 @RequestMapping(params = "methodToCall=" + "togglePropositionSimpleCompound")
1711 public ModelAndView togglePropositionSimpleCompound(@ModelAttribute("KualiForm") UifFormBase form, BindingResult result,
1712 HttpServletRequest request, HttpServletResponse response)
1713 throws Exception {
1714
1715 AgendaEditor agendaEditor = getAgendaEditor(form);
1716 RuleBo rule = agendaEditor.getAgendaItemLine().getRule();
1717 String selectedPropId = agendaEditor.getSelectedPropositionId();
1718
1719 resetEditModeOnPropositionTree(rule.getPropositionTree().getRootElement());
1720
1721 if (!StringUtils.isBlank(selectedPropId)) {
1722
1723 Node<RuleTreeNode,String> parent = findParentPropositionNode(
1724 rule.getPropositionTree().getRootElement(), selectedPropId);
1725 if (parent != null){
1726
1727 int index = findChildIndex(parent, selectedPropId);
1728
1729 PropositionBo propBo = parent.getChildren().get(index).getData().getProposition();
1730
1731
1732 PropositionBo compound = PropositionBo.createCompoundPropositionBoStub(propBo, true);
1733 compound.setDescription("New Compound Proposition " + UUID.randomUUID().toString());
1734 compound.setEditMode(false);
1735
1736 if (parent.getData() == null) {
1737 rule.setProposition(compound);
1738 } else {
1739 PropositionBo parentBo = parent.getData().getProposition();
1740 List<PropositionBo> siblings = parentBo.getCompoundComponents();
1741
1742 int propIndex = -1;
1743 for (int i=0; i<siblings.size(); i++) {
1744 if (propBo.getId().equals(siblings.get(i).getId())) {
1745 propIndex = i;
1746 break;
1747 }
1748 }
1749
1750 parentBo.getCompoundComponents().set(propIndex, compound);
1751 }
1752 }
1753 }
1754
1755 agendaEditor.getAgendaItemLine().getRule().refreshPropositionTree(true);
1756 return super.updateComponent(form, result, request, response);
1757 }
1758
1759
1760 @RequestMapping(params = "methodToCall=" + "cutProposition")
1761 public ModelAndView cutProposition(@ModelAttribute("KualiForm") UifFormBase form, BindingResult result,
1762 HttpServletRequest request, HttpServletResponse response)
1763 throws Exception {
1764
1765 AgendaEditor agendaEditor = getAgendaEditor(form);
1766 String selectedPropId = agendaEditor.getSelectedPropositionId();
1767 agendaEditor.setCutPropositionId(selectedPropId);
1768
1769 return super.updateComponent(form, result, request, response);
1770 }
1771
1772 @RequestMapping(params = "methodToCall=" + "pasteProposition")
1773 public ModelAndView pasteProposition(@ModelAttribute("KualiForm") UifFormBase form, BindingResult result,
1774 HttpServletRequest request, HttpServletResponse response)
1775 throws Exception {
1776
1777 AgendaEditor agendaEditor = getAgendaEditor(form);
1778 RuleBo rule = agendaEditor.getAgendaItemLine().getRule();
1779
1780
1781 String cutPropId = agendaEditor.getCutPropositionId();
1782 String selectedPropId = agendaEditor.getSelectedPropositionId();
1783
1784 if (selectedPropId == cutPropId) {
1785
1786 } else {
1787
1788
1789 Node<RuleTreeNode, String> root = rule.getPropositionTree().getRootElement();
1790
1791 if (StringUtils.isNotBlank(selectedPropId) && StringUtils.isNotBlank(cutPropId)) {
1792 Node<RuleTreeNode,String> parentNode = findParentPropositionNode(root, selectedPropId);
1793 PropositionBo newParent;
1794 if (parentNode == root){
1795
1796
1797
1798
1799 newParent = PropositionBo.createCompoundPropositionBoStub2(
1800 root.getChildren().get(0).getData().getProposition());
1801 newParent.setEditMode(true);
1802 rule.setProposition(newParent);
1803 } else {
1804 newParent = parentNode.getData().getProposition();
1805 }
1806 PropositionBo oldParent = findParentPropositionNode(root, cutPropId).getData().getProposition();
1807
1808 PropositionBo workingProp = null;
1809
1810 if (oldParent != null){
1811 List <PropositionBo> children = oldParent.getCompoundComponents();
1812 for( int index=0; index< children.size(); index++){
1813 if (cutPropId.equalsIgnoreCase(children.get(index).getId())){
1814 workingProp = oldParent.getCompoundComponents().remove(index);
1815 break;
1816 }
1817 }
1818 }
1819
1820
1821 if (newParent != null && workingProp != null){
1822 List <PropositionBo> children = newParent.getCompoundComponents();
1823 for( int index=0; index< children.size(); index++){
1824 if (selectedPropId.equalsIgnoreCase(children.get(index).getId())){
1825 children.add(index+1, workingProp);
1826 break;
1827 }
1828 }
1829 }
1830
1831
1832 rule.refreshPropositionTree(false);
1833 }
1834 }
1835 agendaEditor.setCutPropositionId(null);
1836
1837 return super.updateComponent(form, result, request, response);
1838 }
1839
1840 @RequestMapping(params = "methodToCall=" + "deleteProposition")
1841 public ModelAndView deleteProposition(@ModelAttribute("KualiForm") UifFormBase form, BindingResult result,
1842 HttpServletRequest request, HttpServletResponse response)
1843 throws Exception {
1844 AgendaEditor agendaEditor = getAgendaEditor(form);
1845 String selectedPropId = agendaEditor.getSelectedPropositionId();
1846 Node<RuleTreeNode, String> root = agendaEditor.getAgendaItemLine().getRule().getPropositionTree().getRootElement();
1847
1848 PropositionBo parent = findParentPropositionNode(root, selectedPropId).getData().getProposition();
1849 if (parent != null){
1850 List <PropositionBo> children = parent.getCompoundComponents();
1851 for( int index=0; index< children.size(); index++){
1852 if (selectedPropId.equalsIgnoreCase(children.get(index).getId())){
1853 parent.getCompoundComponents().remove(index);
1854 break;
1855 }
1856 }
1857 }
1858
1859 agendaEditor.getAgendaItemLine().getRule().refreshPropositionTree(false);
1860 return super.updateComponent(form, result, request, response);
1861 }
1862
1863 @RequestMapping(params = "methodToCall=" + "updateCompoundOperator")
1864 public ModelAndView updateCompoundOperator(@ModelAttribute("KualiForm") UifFormBase form, BindingResult result,
1865 HttpServletRequest request, HttpServletResponse response)
1866 throws Exception {
1867
1868 AgendaEditor agendaEditor = getAgendaEditor(form);
1869 RuleBo rule = agendaEditor.getAgendaItemLine().getRule();
1870 rule.refreshPropositionTree(false);
1871
1872 return super.updateComponent(form, result, request, response);
1873 }
1874
1875 }