View Javadoc
1   package edu.internet2.middleware.grouper.grouperUi.serviceLogic;
2   
3   import java.util.ArrayList;
4   import java.util.HashMap;
5   import java.util.List;
6   import java.util.Map;
7   
8   import javax.servlet.http.HttpServletRequest;
9   import javax.servlet.http.HttpServletResponse;
10  
11  import org.apache.commons.lang3.StringUtils;
12  
13  import edu.internet2.middleware.grouper.GrouperSession;
14  import edu.internet2.middleware.grouper.grouperUi.beans.json.GuiResponseJs;
15  import edu.internet2.middleware.grouper.grouperUi.beans.json.GuiScreenAction;
16  import edu.internet2.middleware.grouper.grouperUi.beans.json.GuiScreenAction.GuiMessageType;
17  import edu.internet2.middleware.grouper.grouperUi.beans.ui.GrouperRequestContainer;
18  import edu.internet2.middleware.grouper.grouperUi.beans.ui.GuiUserLifecycleActionConfiguration;
19  import edu.internet2.middleware.grouper.grouperUi.beans.ui.GuiUserLifecycleEventConfiguration;
20  import edu.internet2.middleware.grouper.grouperUi.beans.ui.GuiUserLifecyclePolicyConfiguration;
21  import edu.internet2.middleware.grouper.grouperUi.beans.ui.GuiUserLifecyclePolicyPartConfiguration;
22  import edu.internet2.middleware.grouper.grouperUi.beans.ui.UserLifecycleContainer;
23  import edu.internet2.middleware.grouper.grouperUi.beans.ui.TextContainer;
24  import edu.internet2.middleware.grouper.userLifecycle.UserLifecycleActionConfiguration;
25  import edu.internet2.middleware.grouper.userLifecycle.UserLifecycleEventConfiguration;
26  import edu.internet2.middleware.grouper.userLifecycle.UserLifecyclePolicyConfiguration;
27  import edu.internet2.middleware.grouper.userLifecycle.UserLifecyclePolicyPartConfiguration;
28  import edu.internet2.middleware.grouper.userLifecycle.UserLifecycleService;
29  import edu.internet2.middleware.grouper.ui.GrouperUiFilter;
30  import edu.internet2.middleware.grouper.util.GrouperUtil;
31  import edu.internet2.middleware.subject.Subject;
32  
33  public class UiV2UserLifecycle {
34    
35    /**
36     * view users lifecycle summary
37     * @param request
38     * @param response
39     */
40    public void viewUserLifecycleSummary(final HttpServletRequest request, final HttpServletResponse response) {
41  
42      final Subject loggedInSubject = GrouperUiFilter.retrieveSubjectLoggedIn();
43      
44      GrouperSession grouperSession = null;
45    
46      final GuiResponseJs guiResponseJs = GuiResponseJs.retrieveGuiResponseJs();
47      
48      try {
49    
50        grouperSession = GrouperSession.start(loggedInSubject);
51        
52        final UserLifecycleContainer userLifecycleContainer = GrouperRequestContainer.retrieveFromRequestOrCreate().getUserLifecycleContainer();
53        
54        //TODO verify with Chris
55        if (!userLifecycleContainer.isCanOperateOnUserLifecycleConfigs()) {
56          throw new RuntimeException("Not allowed!!!!!");
57        }
58        
59        int lifecycleEventNumberOfConfigs = UserLifecycleService.retrieveUserLifecycleEventNumberOfConfigs();
60        userLifecycleContainer.setUserLifecycleEventCount(lifecycleEventNumberOfConfigs);
61        
62        int lifecycleActionNumberOfConfigs = UserLifecycleService.retrieveUserLifecycleActionNumberOfConfigs();
63        userLifecycleContainer.setUserLifecycleActionCount(lifecycleActionNumberOfConfigs);
64        
65        int lifecyclePolicyNumberOfConfigs = UserLifecycleService.retrieveUserLifecyclePolicyNumberOfConfigs();
66        userLifecycleContainer.setUserLifecyclePolicyCount(lifecyclePolicyNumberOfConfigs);
67        
68        int lifecyclePolicyPartNumberOfConfigs = UserLifecycleService.retrieveUserLifecyclePolicyPartNumberOfConfigs();
69        userLifecycleContainer.setUserLifecyclePolicyPartCount(lifecyclePolicyPartNumberOfConfigs);
70  
71        guiResponseJs.addAction(GuiScreenAction.newInnerHtmlFromJsp("#grouperMainContentDivId",
72            "/WEB-INF/grouperUi2/userLifecycle/userLifecycleSummary.jsp"));
73        
74      } finally {
75        GrouperSession.stopQuietly(grouperSession);
76      }
77      
78    }
79    
80    public void viewUserLifecycleEvents(final HttpServletRequest request, final HttpServletResponse response) {
81      
82      final Subject loggedInSubject = GrouperUiFilter.retrieveSubjectLoggedIn();
83      
84      GrouperSession grouperSession = null;
85      
86      final GuiResponseJs guiResponseJs = GuiResponseJs.retrieveGuiResponseJs();
87      
88      try {
89        
90        grouperSession = GrouperSession.start(loggedInSubject);
91        
92        final UserLifecycleContainer userLifecycleContainer = GrouperRequestContainer.retrieveFromRequestOrCreate().getUserLifecycleContainer();
93        
94        if (!userLifecycleContainer.isCanOperateOnUserLifecycleConfigs()) {
95          throw new RuntimeException("Not allowed!!!!!");
96        }
97        
98        List<UserLifecycleEventConfiguration> userLifecycleEventConfigs = UserLifecycleEventConfiguration.retrieveAllUserLifecycleEventsConfigurations();
99        
100       List<GuiUserLifecycleEventConfiguration> guiConfigurations = GuiUserLifecycleEventConfiguration.convertFromUserLifecycleEventConfiguration(userLifecycleEventConfigs);
101       
102       userLifecycleContainer.setGuiUserLifecycleEventConfigurations(guiConfigurations);
103       
104       guiResponseJs.addAction(GuiScreenAction.newInnerHtmlFromJsp("#grouperMainContentDivId",
105           "/WEB-INF/grouperUi2/userLifecycle/userLifecycleEvents.jsp"));
106       
107     } finally {
108       GrouperSession.stopQuietly(grouperSession);
109     }
110     
111   }
112   
113   /**
114    * @param request
115    * @param response
116    */
117   public void addUserLifecycleEventConfiguration(final HttpServletRequest request, final HttpServletResponse response) {
118     
119     final Subject loggedInSubject = GrouperUiFilter.retrieveSubjectLoggedIn();
120     
121     GrouperSession grouperSession = null;
122     
123     final GuiResponseJs guiResponseJs = GuiResponseJs.retrieveGuiResponseJs();
124     
125     try {
126       
127       grouperSession = GrouperSession.start(loggedInSubject);
128       
129       final UserLifecycleContainer userLifecycleContainer = GrouperRequestContainer.retrieveFromRequestOrCreate().getUserLifecycleContainer();
130       
131       if (!userLifecycleContainer.isCanOperateOnUserLifecycleConfigs()) {
132         throw new RuntimeException("Not allowed!!!!!");
133       }
134       
135       String configId = request.getParameter("userLifecycleEventConfigId");
136       
137       String type = request.getParameter("userLifecycleEventType");
138       
139       if (StringUtils.isNotBlank(type)) {
140         
141         Class<UserLifecycleEventConfiguration> klass = (Class<UserLifecycleEventConfiguration>) GrouperUtil.forName(type);
142         UserLifecycleEventConfiguration eventConfiguration = (UserLifecycleEventConfiguration) GrouperUtil.newInstance(klass);
143         
144         if (StringUtils.isBlank(configId)) {
145           guiResponseJs.addAction(GuiScreenAction.newValidationMessage(GuiMessageType.error, 
146               "#userLifecycleEventConfigId",
147               TextContainer.retrieveFromRequest().getText().get("dataFieldCreateErrorConfigIdRequired")));
148           return;
149         }
150         
151         eventConfiguration.setConfigId(configId);
152         eventConfiguration.populateConfigurationValuesFromUi(request);
153         
154         GuiUserLifecycleEventConfiguration guiUserLifecycleEventConfig = GuiUserLifecycleEventConfiguration.convertFromUserLifecycleEventConfiguration(eventConfiguration);
155         userLifecycleContainer.setGuiUserLifecycleEventConfiguration(guiUserLifecycleEventConfig);
156         
157       }
158 
159       guiResponseJs.addAction(GuiScreenAction.newInnerHtmlFromJsp("#grouperMainContentDivId", 
160           "/WEB-INF/grouperUi2/userLifecycle/userLifecycleEventConfigAdd.jsp"));
161       
162     } finally {
163       GrouperSession.stopQuietly(grouperSession);
164     }
165     
166   }
167   
168   public void addUserLifecycleEventConfigSubmit(final HttpServletRequest request, final HttpServletResponse response) {
169     
170     final Subject loggedInSubject = GrouperUiFilter.retrieveSubjectLoggedIn();
171     
172     GrouperSession grouperSession = null;
173     
174     final GuiResponseJs guiResponseJs = GuiResponseJs.retrieveGuiResponseJs();
175     
176     try {
177       
178       grouperSession = GrouperSession.start(loggedInSubject);
179       
180       final UserLifecycleContainer userLifecycleContainer = GrouperRequestContainer.retrieveFromRequestOrCreate().getUserLifecycleContainer();
181       
182       if (!userLifecycleContainer.isCanOperateOnUserLifecycleConfigs()) {
183         throw new RuntimeException("Not allowed!!!!!");
184       }
185       
186       String configId = request.getParameter("userLifecycleEventConfigId");
187       
188       if (StringUtils.isBlank(configId)) {
189         guiResponseJs.addAction(GuiScreenAction.newValidationMessage(GuiMessageType.error, 
190             "#userLifecycleEventConfigId",
191             TextContainer.retrieveFromRequest().getText().get("dataFieldCreateErrorConfigIdRequired")));
192         return;
193       }
194       
195       UserLifecycleEventConfiguration userLifecycleEventConfiguration = new UserLifecycleEventConfiguration();
196       
197       userLifecycleEventConfiguration.setConfigId(configId);
198       userLifecycleEventConfiguration.populateConfigurationValuesFromUi(request);
199       
200       StringBuilder message = new StringBuilder();
201       List<String> errorsToDisplay = new ArrayList<String>();
202       Map<String, String> validationErrorsToDisplay = new HashMap<String, String>();
203       
204       userLifecycleEventConfiguration.insertConfig(true, message, errorsToDisplay, validationErrorsToDisplay, new ArrayList<String>());
205       
206       if (errorsToDisplay.size() > 0 || validationErrorsToDisplay.size() > 0) {
207 
208         for (String errorToDisplay: errorsToDisplay) {
209           guiResponseJs.addAction(GuiScreenAction.newMessageAppend(GuiMessageType.error, errorToDisplay));
210         }
211         for (String validationKey: validationErrorsToDisplay.keySet()) {
212           guiResponseJs.addAction(GuiScreenAction.newValidationMessage(GuiMessageType.error, validationKey, 
213               validationErrorsToDisplay.get(validationKey)));
214         }
215 
216         return;
217 
218       }
219       
220       guiResponseJs.addAction(GuiScreenAction.newScript("guiV2link('operation=UiV2UserLifecycle.viewUserLifecycleEvents')"));
221       
222       guiResponseJs.addAction(GuiScreenAction.newMessage(GuiMessageType.success,
223           TextContainer.retrieveFromRequest().getText().get("userLifecycleEventConfigAddEditSuccess")));
224     } finally {
225       GrouperSession.stopQuietly(grouperSession);
226     }
227   }
228   
229   /**
230    * show edit user lifecycle event config screen
231    * @param request
232    * @param response
233    */
234   public void editUserLifecycleEventConfig(final HttpServletRequest request, final HttpServletResponse response) {
235     
236     final Subject loggedInSubject = GrouperUiFilter.retrieveSubjectLoggedIn();
237     
238     GrouperSession grouperSession = null;
239     
240     final GuiResponseJs guiResponseJs = GuiResponseJs.retrieveGuiResponseJs();
241     
242     try {
243       
244       grouperSession = GrouperSession.start(loggedInSubject);
245       
246       final UserLifecycleContainer userLifecycleContainer = GrouperRequestContainer.retrieveFromRequestOrCreate().getUserLifecycleContainer();
247       
248       if (!userLifecycleContainer.isCanOperateOnUserLifecycleConfigs()) {
249         throw new RuntimeException("Not allowed!!!!!");
250       }
251       
252       String configId = request.getParameter("configId");
253       
254       if (StringUtils.isBlank(configId)) {
255         guiResponseJs.addAction(GuiScreenAction.newValidationMessage(GuiMessageType.error, 
256             "#userLifecycleEventConfigId",
257             TextContainer.retrieveFromRequest().getText().get("dataFieldCreateErrorConfigIdRequired")));
258         return;
259       }
260       
261       UserLifecycleEventConfiguration userLifecycleEventConfiguration = new UserLifecycleEventConfiguration();
262       
263       userLifecycleEventConfiguration.setConfigId(configId);
264       
265       String previousConfigId = request.getParameter("previousConfigId");
266       
267       if (StringUtils.isBlank(previousConfigId)) {
268         // first time loading the screen. let's get values from config files/database
269         GuiUserLifecycleEventConfiguration guiUserLifecycleEventConfig = GuiUserLifecycleEventConfiguration.convertFromUserLifecycleEventConfiguration(userLifecycleEventConfiguration);
270         userLifecycleContainer.setGuiUserLifecycleEventConfiguration(guiUserLifecycleEventConfig);
271       } else {
272         // change was made on the form
273         userLifecycleEventConfiguration.populateConfigurationValuesFromUi(request);
274         
275         GuiUserLifecycleEventConfiguration guiUserLifecycleEventConfig = GuiUserLifecycleEventConfiguration.convertFromUserLifecycleEventConfiguration(userLifecycleEventConfiguration);
276         userLifecycleContainer.setGuiUserLifecycleEventConfiguration(guiUserLifecycleEventConfig);
277         
278       }
279       
280       guiResponseJs.addAction(GuiScreenAction.newInnerHtmlFromJsp("#grouperMainContentDivId",
281           "/WEB-INF/grouperUi2/userLifecycle/editUserLifecycleEventConfigDetails.jsp"));
282       
283     } finally {
284       GrouperSession.stopQuietly(grouperSession);
285     }
286   }
287   
288   /**
289    * save edited user lifecycle config into db
290    * @param request
291    * @param response
292    */
293   public void editUserLifecycleEventConfigSubmit(final HttpServletRequest request, final HttpServletResponse response) {
294     
295     final Subject loggedInSubject = GrouperUiFilter.retrieveSubjectLoggedIn();
296     
297     GrouperSession grouperSession = null;
298     
299     final GuiResponseJs guiResponseJs = GuiResponseJs.retrieveGuiResponseJs();
300     
301     try {
302       
303       grouperSession = GrouperSession.start(loggedInSubject);
304       
305       final UserLifecycleContainer userLifecycleContainer = GrouperRequestContainer.retrieveFromRequestOrCreate().getUserLifecycleContainer();
306       
307       if (!userLifecycleContainer.isCanOperateOnUserLifecycleConfigs()) {
308         throw new RuntimeException("Not allowed!!!!!");
309       }
310       
311       String configId = request.getParameter("configId");
312       
313       if (StringUtils.isBlank(configId)) {
314         guiResponseJs.addAction(GuiScreenAction.newValidationMessage(GuiMessageType.error, 
315             "#userLifecycleEventConfigId",
316             TextContainer.retrieveFromRequest().getText().get("dataFieldCreateErrorConfigIdRequired")));
317         return;
318       }
319       
320       UserLifecycleEventConfiguration userLifecycleEventConfiguration = new UserLifecycleEventConfiguration();
321       
322       userLifecycleEventConfiguration.setConfigId(configId);
323       userLifecycleEventConfiguration.populateConfigurationValuesFromUi(request);
324       
325       StringBuilder message = new StringBuilder();
326       List<String> errorsToDisplay = new ArrayList<String>();
327       Map<String, String> validationErrorsToDisplay = new HashMap<String, String>();
328       List<String> actionsPerformed = new ArrayList<String>();
329 
330       userLifecycleEventConfiguration.editConfig(true, message, errorsToDisplay, validationErrorsToDisplay, actionsPerformed);
331       
332       if (errorsToDisplay.size() > 0 || validationErrorsToDisplay.size() > 0) {
333 
334         for (String errorToDisplay: errorsToDisplay) {
335           guiResponseJs.addAction(GuiScreenAction.newMessage(GuiMessageType.error, errorToDisplay));
336         }
337         for (String validationKey: validationErrorsToDisplay.keySet()) {
338           guiResponseJs.addAction(GuiScreenAction.newValidationMessage(GuiMessageType.error, validationKey, 
339               validationErrorsToDisplay.get(validationKey)));
340         }
341         return;
342       }
343       
344       guiResponseJs.addAction(GuiScreenAction.newScript("guiV2link('operation=UiV2UserLifecycle.viewUserLifecycleEvents')"));
345       
346       guiResponseJs.addAction(GuiScreenAction.newMessage(GuiMessageType.success,
347           TextContainer.retrieveFromRequest().getText().get("userLifecycleEventConfigAddEditSuccess")));
348    
349       if (actionsPerformed.size() > 0) {
350         for (String actionPerformed: actionsPerformed) {
351           guiResponseJs.addAction(GuiScreenAction.newMessageAppend(GuiMessageType.success, actionPerformed));
352         }
353       }      
354     } finally {
355       GrouperSession.stopQuietly(grouperSession);
356     }
357   }
358   
359   /**
360    * delete data field config
361    * @param request
362    * @param response
363    */
364   public void deleteUserLifecycleEventConfig(final HttpServletRequest request, final HttpServletResponse response) {
365     
366     final Subject loggedInSubject = GrouperUiFilter.retrieveSubjectLoggedIn();
367     
368     GrouperSession grouperSession = null;
369     
370     final GuiResponseJs guiResponseJs = GuiResponseJs.retrieveGuiResponseJs();
371     
372     try {
373       
374       grouperSession = GrouperSession.start(loggedInSubject);
375       
376       final UserLifecycleContainer userLifecycleContainer = GrouperRequestContainer.retrieveFromRequestOrCreate().getUserLifecycleContainer();
377       
378       if (!userLifecycleContainer.isCanOperateOnUserLifecycleConfigs()) {
379         throw new RuntimeException("Not allowed!!!!!");
380       }
381       
382       String configId = request.getParameter("configId");
383       
384       if (StringUtils.isBlank(configId)) {
385         guiResponseJs.addAction(GuiScreenAction.newValidationMessage(GuiMessageType.error, 
386             "#userLifecycleEventConfigId",
387             TextContainer.retrieveFromRequest().getText().get("dataFieldCreateErrorConfigIdRequired")));
388         return;
389       }
390       
391       UserLifecycleEventConfiguration userLifecycleEventConfiguration = new UserLifecycleEventConfiguration();
392       
393       userLifecycleEventConfiguration.setConfigId(configId);
394       
395       userLifecycleEventConfiguration.deleteConfig(true);
396       
397       guiResponseJs.addAction(GuiScreenAction.newScript("guiV2link('operation=UiV2UserLifecycle.viewUserLifecycleEvents')"));
398       
399       guiResponseJs.addAction(GuiScreenAction.newMessage(GuiMessageType.success,
400           TextContainer.retrieveFromRequest().getText().get("userLifecycleEventConfigDeleteSuccess")));
401       
402     } finally {
403       GrouperSession.stopQuietly(grouperSession);
404     }
405   }
406   
407   public void viewUserLifecycleActions(final HttpServletRequest request, final HttpServletResponse response) {
408     
409     final Subject loggedInSubject = GrouperUiFilter.retrieveSubjectLoggedIn();
410     
411     GrouperSession grouperSession = null;
412     
413     final GuiResponseJs guiResponseJs = GuiResponseJs.retrieveGuiResponseJs();
414     
415     try {
416       
417       grouperSession = GrouperSession.start(loggedInSubject);
418       
419       final UserLifecycleContainer userLifecycleContainer = GrouperRequestContainer.retrieveFromRequestOrCreate().getUserLifecycleContainer();
420       
421       if (!userLifecycleContainer.isCanOperateOnUserLifecycleConfigs()) {
422         throw new RuntimeException("Not allowed!!!!!");
423       }
424       
425       List<UserLifecycleActionConfiguration> userLifecycleConfigs = UserLifecycleActionConfiguration.retrieveAllUserLifecycleActionConfigurations();
426       
427       List<GuiUserLifecycleActionConfiguration> guiConfigurations = GuiUserLifecycleActionConfiguration.convertFromUserLifecycleActionConfiguration(userLifecycleConfigs);
428       
429       userLifecycleContainer.setGuiUserLifecycleActionConfigurations(guiConfigurations);
430       
431       guiResponseJs.addAction(GuiScreenAction.newInnerHtmlFromJsp("#grouperMainContentDivId",
432           "/WEB-INF/grouperUi2/userLifecycle/userLifecycleActions.jsp"));
433       
434     } finally {
435       GrouperSession.stopQuietly(grouperSession);
436     }
437     
438   }
439   
440   /**
441    * @param request
442    * @param response
443    */
444   public void addUserLifecycleActionConfiguration(final HttpServletRequest request, final HttpServletResponse response) {
445     
446     final Subject loggedInSubject = GrouperUiFilter.retrieveSubjectLoggedIn();
447     
448     GrouperSession grouperSession = null;
449     
450     final GuiResponseJs guiResponseJs = GuiResponseJs.retrieveGuiResponseJs();
451     
452     try {
453       
454       grouperSession = GrouperSession.start(loggedInSubject);
455       
456       final UserLifecycleContainer userLifecycleContainer = GrouperRequestContainer.retrieveFromRequestOrCreate().getUserLifecycleContainer();
457       
458       if (!userLifecycleContainer.isCanOperateOnUserLifecycleConfigs()) {
459         throw new RuntimeException("Not allowed!!!!!");
460       }
461       
462       String configId = request.getParameter("userLifecycleActionConfigId");
463       
464       String type = request.getParameter("userLifecycleActionType");
465       
466       if (StringUtils.isNotBlank(type)) {
467         
468         Class<UserLifecycleActionConfiguration> klass = (Class<UserLifecycleActionConfiguration>) GrouperUtil.forName(type);
469         UserLifecycleActionConfiguration actionConfiguration = (UserLifecycleActionConfiguration) GrouperUtil.newInstance(klass);
470         
471         if (StringUtils.isBlank(configId)) {
472           guiResponseJs.addAction(GuiScreenAction.newValidationMessage(GuiMessageType.error, 
473               "#userLifecycleActionConfigId",
474               TextContainer.retrieveFromRequest().getText().get("dataFieldCreateErrorConfigIdRequired")));
475           return;
476         }
477         
478         actionConfiguration.setConfigId(configId);
479         actionConfiguration.populateConfigurationValuesFromUi(request);
480         
481         GuiUserLifecycleActionConfiguration guiUserLifecycleActionConfig = GuiUserLifecycleActionConfiguration.convertFromUserLifecycleActionConfiguration(actionConfiguration);
482         userLifecycleContainer.setGuiUserLifecycleActionConfiguration(guiUserLifecycleActionConfig);
483         
484       }
485 
486       guiResponseJs.addAction(GuiScreenAction.newInnerHtmlFromJsp("#grouperMainContentDivId", 
487           "/WEB-INF/grouperUi2/userLifecycle/userLifecycleActionConfigAdd.jsp"));
488       
489     } finally {
490       GrouperSession.stopQuietly(grouperSession);
491     }
492     
493   }
494   
495   public void addUserLifecycleActionConfigSubmit(final HttpServletRequest request, final HttpServletResponse response) {
496     
497     final Subject loggedInSubject = GrouperUiFilter.retrieveSubjectLoggedIn();
498     
499     GrouperSession grouperSession = null;
500     
501     final GuiResponseJs guiResponseJs = GuiResponseJs.retrieveGuiResponseJs();
502     
503     try {
504       
505       grouperSession = GrouperSession.start(loggedInSubject);
506       
507       final UserLifecycleContainer userLifecycleContainer = GrouperRequestContainer.retrieveFromRequestOrCreate().getUserLifecycleContainer();
508       
509       if (!userLifecycleContainer.isCanOperateOnUserLifecycleConfigs()) {
510         throw new RuntimeException("Not allowed!!!!!");
511       }
512       
513       String configId = request.getParameter("userLifecycleActionConfigId");
514       
515       if (StringUtils.isBlank(configId)) {
516         guiResponseJs.addAction(GuiScreenAction.newValidationMessage(GuiMessageType.error, 
517             "#userLifecycleActionConfigId",
518             TextContainer.retrieveFromRequest().getText().get("dataFieldCreateErrorConfigIdRequired")));
519         return;
520       }
521       
522       UserLifecycleActionConfiguration userLifecycleActionConfiguration = new UserLifecycleActionConfiguration();
523       
524       userLifecycleActionConfiguration.setConfigId(configId);
525       userLifecycleActionConfiguration.populateConfigurationValuesFromUi(request);
526       
527       StringBuilder message = new StringBuilder();
528       List<String> errorsToDisplay = new ArrayList<String>();
529       Map<String, String> validationErrorsToDisplay = new HashMap<String, String>();
530       
531       userLifecycleActionConfiguration.insertConfig(true, message, errorsToDisplay, validationErrorsToDisplay, new ArrayList<String>());
532       
533       if (errorsToDisplay.size() > 0 || validationErrorsToDisplay.size() > 0) {
534 
535         for (String errorToDisplay: errorsToDisplay) {
536           guiResponseJs.addAction(GuiScreenAction.newMessageAppend(GuiMessageType.error, errorToDisplay));
537         }
538         for (String validationKey: validationErrorsToDisplay.keySet()) {
539           guiResponseJs.addAction(GuiScreenAction.newValidationMessage(GuiMessageType.error, validationKey, 
540               validationErrorsToDisplay.get(validationKey)));
541         }
542 
543         return;
544 
545       }
546       
547       guiResponseJs.addAction(GuiScreenAction.newScript("guiV2link('operation=UiV2UserLifecycle.viewUserLifecycleActions')"));
548       
549       guiResponseJs.addAction(GuiScreenAction.newMessage(GuiMessageType.success,
550           TextContainer.retrieveFromRequest().getText().get("userLifecycleActionConfigAddEditSuccess")));
551     } finally {
552       GrouperSession.stopQuietly(grouperSession);
553     }
554   }
555   
556   /**
557    * show edit user lifecycle action config screen
558    * @param request
559    * @param response
560    */
561   public void editUserLifecycleActionConfig(final HttpServletRequest request, final HttpServletResponse response) {
562     
563     final Subject loggedInSubject = GrouperUiFilter.retrieveSubjectLoggedIn();
564     
565     GrouperSession grouperSession = null;
566     
567     final GuiResponseJs guiResponseJs = GuiResponseJs.retrieveGuiResponseJs();
568     
569     try {
570       
571       grouperSession = GrouperSession.start(loggedInSubject);
572       
573       final UserLifecycleContainer userLifecycleContainer = GrouperRequestContainer.retrieveFromRequestOrCreate().getUserLifecycleContainer();
574       
575       if (!userLifecycleContainer.isCanOperateOnUserLifecycleConfigs()) {
576         throw new RuntimeException("Not allowed!!!!!");
577       }
578       
579       String configId = request.getParameter("configId");
580       
581       if (StringUtils.isBlank(configId)) {
582         guiResponseJs.addAction(GuiScreenAction.newValidationMessage(GuiMessageType.error, 
583             "#userLifecycleActionConfigId",
584             TextContainer.retrieveFromRequest().getText().get("dataFieldCreateErrorConfigIdRequired")));
585         return;
586       }
587       
588       UserLifecycleActionConfiguration userLifecycleActionConfiguration = new UserLifecycleActionConfiguration();
589       
590       userLifecycleActionConfiguration.setConfigId(configId);
591       
592       String previousConfigId = request.getParameter("previousConfigId");
593       
594       if (StringUtils.isBlank(previousConfigId)) {
595         // first time loading the screen. let's get values from config files/database
596         GuiUserLifecycleActionConfiguration guiUserLifecycleActionConfig = GuiUserLifecycleActionConfiguration.convertFromUserLifecycleActionConfiguration(userLifecycleActionConfiguration);
597         userLifecycleContainer.setGuiUserLifecycleActionConfiguration(guiUserLifecycleActionConfig);
598       } else {
599         // change was made on the form
600         userLifecycleActionConfiguration.populateConfigurationValuesFromUi(request);
601         
602         GuiUserLifecycleActionConfiguration guiUserLifecycleActionConfig = GuiUserLifecycleActionConfiguration.convertFromUserLifecycleActionConfiguration(userLifecycleActionConfiguration);
603         userLifecycleContainer.setGuiUserLifecycleActionConfiguration(guiUserLifecycleActionConfig);
604         
605       }
606       
607       guiResponseJs.addAction(GuiScreenAction.newInnerHtmlFromJsp("#grouperMainContentDivId",
608           "/WEB-INF/grouperUi2/userLifecycle/editUserLifecycleActionConfigDetails.jsp"));
609       
610     } finally {
611       GrouperSession.stopQuietly(grouperSession);
612     }
613   }
614   
615   /**
616    * save edited user lifecycle config into db
617    * @param request
618    * @param response
619    */
620   public void editUserLifecycleActionConfigSubmit(final HttpServletRequest request, final HttpServletResponse response) {
621     
622     final Subject loggedInSubject = GrouperUiFilter.retrieveSubjectLoggedIn();
623     
624     GrouperSession grouperSession = null;
625     
626     final GuiResponseJs guiResponseJs = GuiResponseJs.retrieveGuiResponseJs();
627     
628     try {
629       
630       grouperSession = GrouperSession.start(loggedInSubject);
631       
632       final UserLifecycleContainer userLifecycleContainer = GrouperRequestContainer.retrieveFromRequestOrCreate().getUserLifecycleContainer();
633       
634       if (!userLifecycleContainer.isCanOperateOnUserLifecycleConfigs()) {
635         throw new RuntimeException("Not allowed!!!!!");
636       }
637       
638       String configId = request.getParameter("configId");
639       
640       if (StringUtils.isBlank(configId)) {
641         guiResponseJs.addAction(GuiScreenAction.newValidationMessage(GuiMessageType.error, 
642             "#userLifecycleActionConfigId",
643             TextContainer.retrieveFromRequest().getText().get("dataFieldCreateErrorConfigIdRequired")));
644         return;
645       }
646       
647       UserLifecycleActionConfiguration userLifecycleActionConfiguration = new UserLifecycleActionConfiguration();
648       
649       userLifecycleActionConfiguration.setConfigId(configId);
650       userLifecycleActionConfiguration.populateConfigurationValuesFromUi(request);
651       
652       StringBuilder message = new StringBuilder();
653       List<String> errorsToDisplay = new ArrayList<String>();
654       Map<String, String> validationErrorsToDisplay = new HashMap<String, String>();
655       List<String> actionsPerformed = new ArrayList<String>();
656 
657       userLifecycleActionConfiguration.editConfig(true, message, errorsToDisplay, validationErrorsToDisplay, actionsPerformed);
658       
659       if (errorsToDisplay.size() > 0 || validationErrorsToDisplay.size() > 0) {
660 
661         for (String errorToDisplay: errorsToDisplay) {
662           guiResponseJs.addAction(GuiScreenAction.newMessage(GuiMessageType.error, errorToDisplay));
663         }
664         for (String validationKey: validationErrorsToDisplay.keySet()) {
665           guiResponseJs.addAction(GuiScreenAction.newValidationMessage(GuiMessageType.error, validationKey, 
666               validationErrorsToDisplay.get(validationKey)));
667         }
668         return;
669       }
670       
671       guiResponseJs.addAction(GuiScreenAction.newScript("guiV2link('operation=UiV2UserLifecycle.viewUserLifecycleActions')"));
672       
673       guiResponseJs.addAction(GuiScreenAction.newMessage(GuiMessageType.success,
674           TextContainer.retrieveFromRequest().getText().get("userLifecycleActionConfigAddEditSuccess")));
675    
676       if (actionsPerformed.size() > 0) {
677         for (String actionPerformed: actionsPerformed) {
678           guiResponseJs.addAction(GuiScreenAction.newMessageAppend(GuiMessageType.success, actionPerformed));
679         }
680       }      
681     } finally {
682       GrouperSession.stopQuietly(grouperSession);
683     }
684   }
685   
686   /**
687    * delete data field config
688    * @param request
689    * @param response
690    */
691   public void deleteUserLifecycleActionConfig(final HttpServletRequest request, final HttpServletResponse response) {
692     
693     final Subject loggedInSubject = GrouperUiFilter.retrieveSubjectLoggedIn();
694     
695     GrouperSession grouperSession = null;
696     
697     final GuiResponseJs guiResponseJs = GuiResponseJs.retrieveGuiResponseJs();
698     
699     try {
700       
701       grouperSession = GrouperSession.start(loggedInSubject);
702       
703       final UserLifecycleContainer userLifecycleContainer = GrouperRequestContainer.retrieveFromRequestOrCreate().getUserLifecycleContainer();
704       
705       if (!userLifecycleContainer.isCanOperateOnUserLifecycleConfigs()) {
706         throw new RuntimeException("Not allowed!!!!!");
707       }
708       
709       String configId = request.getParameter("configId");
710       
711       if (StringUtils.isBlank(configId)) {
712         guiResponseJs.addAction(GuiScreenAction.newValidationMessage(GuiMessageType.error, 
713             "#userLifecycleActionConfigId",
714             TextContainer.retrieveFromRequest().getText().get("dataFieldCreateErrorConfigIdRequired")));
715         return;
716       }
717       
718       UserLifecycleActionConfiguration userLifecycleActionConfiguration = new UserLifecycleActionConfiguration();
719       
720       userLifecycleActionConfiguration.setConfigId(configId);
721       
722       userLifecycleActionConfiguration.deleteConfig(true);
723       
724       guiResponseJs.addAction(GuiScreenAction.newScript("guiV2link('operation=UiV2UserLifecycle.viewUserLifecycleActions')"));
725       
726       guiResponseJs.addAction(GuiScreenAction.newMessage(GuiMessageType.success,
727           TextContainer.retrieveFromRequest().getText().get("userLifecycleActionConfigDeleteSuccess")));
728       
729     } finally {
730       GrouperSession.stopQuietly(grouperSession);
731     }
732   }
733   
734   public void viewUserLifecyclePolicies(final HttpServletRequest request, final HttpServletResponse response) {
735     
736     final Subject loggedInSubject = GrouperUiFilter.retrieveSubjectLoggedIn();
737     
738     GrouperSession grouperSession = null;
739     
740     final GuiResponseJs guiResponseJs = GuiResponseJs.retrieveGuiResponseJs();
741     
742     try {
743       
744       grouperSession = GrouperSession.start(loggedInSubject);
745       
746       final UserLifecycleContainer userLifecycleContainer = GrouperRequestContainer.retrieveFromRequestOrCreate().getUserLifecycleContainer();
747       
748       if (!userLifecycleContainer.isCanOperateOnUserLifecycleConfigs()) {
749         throw new RuntimeException("Not allowed!!!!!");
750       }
751       
752       List<UserLifecyclePolicyConfiguration> userLifecycleConfigs = UserLifecyclePolicyConfiguration.retrieveAllUserLifecyclePolicyConfigurations();
753       
754       List<GuiUserLifecyclePolicyConfiguration> guiConfigurations = GuiUserLifecyclePolicyConfiguration.convertFromUserLifecyclePolicyConfiguration(userLifecycleConfigs);
755       
756       userLifecycleContainer.setGuiUserLifecyclePolicyConfigurations(guiConfigurations);
757       
758       guiResponseJs.addAction(GuiScreenAction.newInnerHtmlFromJsp("#grouperMainContentDivId",
759           "/WEB-INF/grouperUi2/userLifecycle/userLifecyclePolicies.jsp"));
760       
761     } finally {
762       GrouperSession.stopQuietly(grouperSession);
763     }
764     
765   }
766   
767   /**
768    * @param request
769    * @param response
770    */
771   public void addUserLifecyclePolicyConfiguration(final HttpServletRequest request, final HttpServletResponse response) {
772     
773     final Subject loggedInSubject = GrouperUiFilter.retrieveSubjectLoggedIn();
774     
775     GrouperSession grouperSession = null;
776     
777     final GuiResponseJs guiResponseJs = GuiResponseJs.retrieveGuiResponseJs();
778     
779     try {
780       
781       grouperSession = GrouperSession.start(loggedInSubject);
782       
783       final UserLifecycleContainer userLifecycleContainer = GrouperRequestContainer.retrieveFromRequestOrCreate().getUserLifecycleContainer();
784       
785       if (!userLifecycleContainer.isCanOperateOnUserLifecycleConfigs()) {
786         throw new RuntimeException("Not allowed!!!!!");
787       }
788       
789       String configId = request.getParameter("userLifecyclePolicyConfigId");
790       
791       String type = request.getParameter("userLifecyclePolicyType");
792       
793       if (StringUtils.isNotBlank(type)) {
794         
795         Class<UserLifecyclePolicyConfiguration> klass = (Class<UserLifecyclePolicyConfiguration>) GrouperUtil.forName(type);
796         UserLifecyclePolicyConfiguration policyConfiguration = (UserLifecyclePolicyConfiguration) GrouperUtil.newInstance(klass);
797         
798         if (StringUtils.isBlank(configId)) {
799           guiResponseJs.addAction(GuiScreenAction.newValidationMessage(GuiMessageType.error, 
800               "#userLifecyclePolicyConfigId",
801               TextContainer.retrieveFromRequest().getText().get("dataFieldCreateErrorConfigIdRequired")));
802           return;
803         }
804         
805         policyConfiguration.setConfigId(configId);
806         policyConfiguration.populateConfigurationValuesFromUi(request);
807         
808         GuiUserLifecyclePolicyConfiguration guiUserLifecyclePolicyConfig = GuiUserLifecyclePolicyConfiguration.convertFromUserLifecyclePolicyConfiguration(policyConfiguration);
809         userLifecycleContainer.setGuiUserLifecyclePolicyConfiguration(guiUserLifecyclePolicyConfig);
810         
811       }
812 
813       guiResponseJs.addAction(GuiScreenAction.newInnerHtmlFromJsp("#grouperMainContentDivId", 
814           "/WEB-INF/grouperUi2/userLifecycle/userLifecyclePolicyConfigAdd.jsp"));
815       
816     } finally {
817       GrouperSession.stopQuietly(grouperSession);
818     }
819     
820   }
821   
822   public void addUserLifecyclePolicyConfigSubmit(final HttpServletRequest request, final HttpServletResponse response) {
823     
824     final Subject loggedInSubject = GrouperUiFilter.retrieveSubjectLoggedIn();
825     
826     GrouperSession grouperSession = null;
827     
828     final GuiResponseJs guiResponseJs = GuiResponseJs.retrieveGuiResponseJs();
829     
830     try {
831       
832       grouperSession = GrouperSession.start(loggedInSubject);
833       
834       final UserLifecycleContainer userLifecycleContainer = GrouperRequestContainer.retrieveFromRequestOrCreate().getUserLifecycleContainer();
835       
836       if (!userLifecycleContainer.isCanOperateOnUserLifecycleConfigs()) {
837         throw new RuntimeException("Not allowed!!!!!");
838       }
839       
840       String configId = request.getParameter("userLifecyclePolicyConfigId");
841       
842       if (StringUtils.isBlank(configId)) {
843         guiResponseJs.addAction(GuiScreenAction.newValidationMessage(GuiMessageType.error, 
844             "#userLifecyclePolicyConfigId",
845             TextContainer.retrieveFromRequest().getText().get("dataFieldCreateErrorConfigIdRequired")));
846         return;
847       }
848       
849       UserLifecyclePolicyConfiguration userLifecyclePolicyConfiguration = new UserLifecyclePolicyConfiguration();
850       
851       userLifecyclePolicyConfiguration.setConfigId(configId);
852       userLifecyclePolicyConfiguration.populateConfigurationValuesFromUi(request);
853       
854       StringBuilder message = new StringBuilder();
855       List<String> errorsToDisplay = new ArrayList<String>();
856       Map<String, String> validationErrorsToDisplay = new HashMap<String, String>();
857       
858       userLifecyclePolicyConfiguration.insertConfig(true, message, errorsToDisplay, validationErrorsToDisplay, new ArrayList<String>());
859       
860       if (errorsToDisplay.size() > 0 || validationErrorsToDisplay.size() > 0) {
861 
862         for (String errorToDisplay: errorsToDisplay) {
863           guiResponseJs.addAction(GuiScreenAction.newMessageAppend(GuiMessageType.error, errorToDisplay));
864         }
865         for (String validationKey: validationErrorsToDisplay.keySet()) {
866           guiResponseJs.addAction(GuiScreenAction.newValidationMessage(GuiMessageType.error, validationKey, 
867               validationErrorsToDisplay.get(validationKey)));
868         }
869 
870         return;
871 
872       }
873       
874       guiResponseJs.addAction(GuiScreenAction.newScript("guiV2link('operation=UiV2UserLifecycle.viewUserLifecyclePolicies')"));
875       
876       guiResponseJs.addAction(GuiScreenAction.newMessage(GuiMessageType.success,
877           TextContainer.retrieveFromRequest().getText().get("userLifecyclePolicyConfigAddEditSuccess")));
878     } finally {
879       GrouperSession.stopQuietly(grouperSession);
880     }
881   }
882   
883   /**
884    * show edit user lifecycle policy config screen
885    * @param request
886    * @param response
887    */
888   public void editUserLifecyclePolicyConfig(final HttpServletRequest request, final HttpServletResponse response) {
889     
890     final Subject loggedInSubject = GrouperUiFilter.retrieveSubjectLoggedIn();
891     
892     GrouperSession grouperSession = null;
893     
894     final GuiResponseJs guiResponseJs = GuiResponseJs.retrieveGuiResponseJs();
895     
896     try {
897       
898       grouperSession = GrouperSession.start(loggedInSubject);
899       
900       final UserLifecycleContainer userLifecycleContainer = GrouperRequestContainer.retrieveFromRequestOrCreate().getUserLifecycleContainer();
901       
902       if (!userLifecycleContainer.isCanOperateOnUserLifecycleConfigs()) {
903         throw new RuntimeException("Not allowed!!!!!");
904       }
905       
906       String configId = request.getParameter("configId");
907       
908       if (StringUtils.isBlank(configId)) {
909         guiResponseJs.addAction(GuiScreenAction.newValidationMessage(GuiMessageType.error, 
910             "#userLifecyclePolicyConfigId",
911             TextContainer.retrieveFromRequest().getText().get("dataFieldCreateErrorConfigIdRequired")));
912         return;
913       }
914       
915       UserLifecyclePolicyConfiguration userLifecyclePolicyConfiguration = new UserLifecyclePolicyConfiguration();
916       
917       userLifecyclePolicyConfiguration.setConfigId(configId);
918       
919       String previousConfigId = request.getParameter("previousConfigId");
920       
921       if (StringUtils.isBlank(previousConfigId)) {
922         // first time loading the screen. let's get values from config files/database
923         GuiUserLifecyclePolicyConfiguration guiUserLifecyclePolicyConfig = GuiUserLifecyclePolicyConfiguration.convertFromUserLifecyclePolicyConfiguration(userLifecyclePolicyConfiguration);
924         userLifecycleContainer.setGuiUserLifecyclePolicyConfiguration(guiUserLifecyclePolicyConfig);
925       } else {
926         // change was made on the form
927         userLifecyclePolicyConfiguration.populateConfigurationValuesFromUi(request);
928         
929         GuiUserLifecyclePolicyConfiguration guiUserLifecyclePolicyConfig = GuiUserLifecyclePolicyConfiguration.convertFromUserLifecyclePolicyConfiguration(userLifecyclePolicyConfiguration);
930         userLifecycleContainer.setGuiUserLifecyclePolicyConfiguration(guiUserLifecyclePolicyConfig);
931         
932       }
933       
934       guiResponseJs.addAction(GuiScreenAction.newInnerHtmlFromJsp("#grouperMainContentDivId",
935           "/WEB-INF/grouperUi2/userLifecycle/editUserLifecyclePolicyConfigDetails.jsp"));
936       
937     } finally {
938       GrouperSession.stopQuietly(grouperSession);
939     }
940   }
941   
942   /**
943    * save edited user lifecycle config into db
944    * @param request
945    * @param response
946    */
947   public void editUserLifecyclePolicyConfigSubmit(final HttpServletRequest request, final HttpServletResponse response) {
948     
949     final Subject loggedInSubject = GrouperUiFilter.retrieveSubjectLoggedIn();
950     
951     GrouperSession grouperSession = null;
952     
953     final GuiResponseJs guiResponseJs = GuiResponseJs.retrieveGuiResponseJs();
954     
955     try {
956       
957       grouperSession = GrouperSession.start(loggedInSubject);
958       
959       final UserLifecycleContainer userLifecycleContainer = GrouperRequestContainer.retrieveFromRequestOrCreate().getUserLifecycleContainer();
960       
961       if (!userLifecycleContainer.isCanOperateOnUserLifecycleConfigs()) {
962         throw new RuntimeException("Not allowed!!!!!");
963       }
964       
965       String configId = request.getParameter("configId");
966       
967       if (StringUtils.isBlank(configId)) {
968         guiResponseJs.addAction(GuiScreenAction.newValidationMessage(GuiMessageType.error, 
969             "#userLifecyclePolicyConfigId",
970             TextContainer.retrieveFromRequest().getText().get("dataFieldCreateErrorConfigIdRequired")));
971         return;
972       }
973       
974       UserLifecyclePolicyConfiguration userLifecyclePolicyConfiguration = new UserLifecyclePolicyConfiguration();
975       
976       userLifecyclePolicyConfiguration.setConfigId(configId);
977       userLifecyclePolicyConfiguration.populateConfigurationValuesFromUi(request);
978       
979       StringBuilder message = new StringBuilder();
980       List<String> errorsToDisplay = new ArrayList<String>();
981       Map<String, String> validationErrorsToDisplay = new HashMap<String, String>();
982       List<String> actionsPerformed = new ArrayList<String>();
983 
984       userLifecyclePolicyConfiguration.editConfig(true, message, errorsToDisplay, validationErrorsToDisplay, actionsPerformed);
985       
986       if (errorsToDisplay.size() > 0 || validationErrorsToDisplay.size() > 0) {
987 
988         for (String errorToDisplay: errorsToDisplay) {
989           guiResponseJs.addAction(GuiScreenAction.newMessage(GuiMessageType.error, errorToDisplay));
990         }
991         for (String validationKey: validationErrorsToDisplay.keySet()) {
992           guiResponseJs.addAction(GuiScreenAction.newValidationMessage(GuiMessageType.error, validationKey, 
993               validationErrorsToDisplay.get(validationKey)));
994         }
995         return;
996       }
997       
998       guiResponseJs.addAction(GuiScreenAction.newScript("guiV2link('operation=UiV2UserLifecycle.viewUserLifecyclePolicies')"));
999       
1000       guiResponseJs.addAction(GuiScreenAction.newMessage(GuiMessageType.success,
1001           TextContainer.retrieveFromRequest().getText().get("userLifecyclePolicyConfigAddEditSuccess")));
1002    
1003       if (actionsPerformed.size() > 0) {
1004         for (String actionPerformed: actionsPerformed) {
1005           guiResponseJs.addAction(GuiScreenAction.newMessageAppend(GuiMessageType.success, actionPerformed));
1006         }
1007       }      
1008     } finally {
1009       GrouperSession.stopQuietly(grouperSession);
1010     }
1011   }
1012   
1013   /**
1014    * delete data field config
1015    * @param request
1016    * @param response
1017    */
1018   public void deleteUserLifecyclePolicyConfig(final HttpServletRequest request, final HttpServletResponse response) {
1019     
1020     final Subject loggedInSubject = GrouperUiFilter.retrieveSubjectLoggedIn();
1021     
1022     GrouperSession grouperSession = null;
1023     
1024     final GuiResponseJs guiResponseJs = GuiResponseJs.retrieveGuiResponseJs();
1025     
1026     try {
1027       
1028       grouperSession = GrouperSession.start(loggedInSubject);
1029       
1030       final UserLifecycleContainer userLifecycleContainer = GrouperRequestContainer.retrieveFromRequestOrCreate().getUserLifecycleContainer();
1031       
1032       if (!userLifecycleContainer.isCanOperateOnUserLifecycleConfigs()) {
1033         throw new RuntimeException("Not allowed!!!!!");
1034       }
1035       
1036       String configId = request.getParameter("configId");
1037       
1038       if (StringUtils.isBlank(configId)) {
1039         guiResponseJs.addAction(GuiScreenAction.newValidationMessage(GuiMessageType.error, 
1040             "#userLifecyclePolicyConfigId",
1041             TextContainer.retrieveFromRequest().getText().get("dataFieldCreateErrorConfigIdRequired")));
1042         return;
1043       }
1044       
1045       UserLifecyclePolicyConfiguration userLifecyclePolicyConfiguration = new UserLifecyclePolicyConfiguration();
1046       
1047       userLifecyclePolicyConfiguration.setConfigId(configId);
1048       
1049       userLifecyclePolicyConfiguration.deleteConfig(true);
1050       
1051       guiResponseJs.addAction(GuiScreenAction.newScript("guiV2link('operation=UiV2UserLifecycle.viewUserLifecyclePolicies')"));
1052       
1053       guiResponseJs.addAction(GuiScreenAction.newMessage(GuiMessageType.success,
1054           TextContainer.retrieveFromRequest().getText().get("userLifecyclePolicyConfigDeleteSuccess")));
1055       
1056     } finally {
1057       GrouperSession.stopQuietly(grouperSession);
1058     }
1059   }
1060   
1061   public void viewUserLifecyclePolicyParts(final HttpServletRequest request, final HttpServletResponse response) {
1062     
1063     final Subject loggedInSubject = GrouperUiFilter.retrieveSubjectLoggedIn();
1064     
1065     GrouperSession grouperSession = null;
1066     
1067     final GuiResponseJs guiResponseJs = GuiResponseJs.retrieveGuiResponseJs();
1068     
1069     try {
1070       
1071       grouperSession = GrouperSession.start(loggedInSubject);
1072       
1073       final UserLifecycleContainer userLifecycleContainer = GrouperRequestContainer.retrieveFromRequestOrCreate().getUserLifecycleContainer();
1074       
1075       if (!userLifecycleContainer.isCanOperateOnUserLifecycleConfigs()) {
1076         throw new RuntimeException("Not allowed!!!!!");
1077       }
1078       
1079       List<UserLifecyclePolicyPartConfiguration> userLifecycleConfigs = UserLifecyclePolicyPartConfiguration.retrieveAllUserLifecyclePolicyPartConfigurations();
1080       
1081       List<GuiUserLifecyclePolicyPartConfiguration> guiConfigurations = GuiUserLifecyclePolicyPartConfiguration.convertFromUserLifecyclePolicyPartConfiguration(userLifecycleConfigs);
1082       
1083       userLifecycleContainer.setGuiUserLifecyclePolicyPartConfigurations(guiConfigurations);
1084       
1085       guiResponseJs.addAction(GuiScreenAction.newInnerHtmlFromJsp("#grouperMainContentDivId",
1086           "/WEB-INF/grouperUi2/userLifecycle/userLifecyclePolicyParts.jsp"));
1087       
1088     } finally {
1089       GrouperSession.stopQuietly(grouperSession);
1090     }
1091     
1092   }
1093   
1094   /**
1095    * @param request
1096    * @param response
1097    */
1098   public void addUserLifecyclePolicyPartConfiguration(final HttpServletRequest request, final HttpServletResponse response) {
1099     
1100     final Subject loggedInSubject = GrouperUiFilter.retrieveSubjectLoggedIn();
1101     
1102     GrouperSession grouperSession = null;
1103     
1104     final GuiResponseJs guiResponseJs = GuiResponseJs.retrieveGuiResponseJs();
1105     
1106     try {
1107       
1108       grouperSession = GrouperSession.start(loggedInSubject);
1109       
1110       final UserLifecycleContainer userLifecycleContainer = GrouperRequestContainer.retrieveFromRequestOrCreate().getUserLifecycleContainer();
1111       
1112       if (!userLifecycleContainer.isCanOperateOnUserLifecycleConfigs()) {
1113         throw new RuntimeException("Not allowed!!!!!");
1114       }
1115       
1116       String configId = request.getParameter("userLifecyclePolicyPartConfigId");
1117       
1118       String type = request.getParameter("userLifecyclePolicyPartType");
1119       
1120       if (StringUtils.isNotBlank(type)) {
1121         
1122         Class<UserLifecyclePolicyPartConfiguration> klass = (Class<UserLifecyclePolicyPartConfiguration>) GrouperUtil.forName(type);
1123         UserLifecyclePolicyPartConfiguration policyConfiguration = (UserLifecyclePolicyPartConfiguration) GrouperUtil.newInstance(klass);
1124         
1125         if (StringUtils.isBlank(configId)) {
1126           guiResponseJs.addAction(GuiScreenAction.newValidationMessage(GuiMessageType.error, 
1127               "#userLifecyclePolicyPartConfigId",
1128               TextContainer.retrieveFromRequest().getText().get("dataFieldCreateErrorConfigIdRequired")));
1129           return;
1130         }
1131         
1132         policyConfiguration.setConfigId(configId);
1133         policyConfiguration.populateConfigurationValuesFromUi(request);
1134         
1135         GuiUserLifecyclePolicyPartConfiguration guiUserLifecyclePolicyPartConfig = GuiUserLifecyclePolicyPartConfiguration.convertFromUserLifecyclePolicyPartConfiguration(policyConfiguration);
1136         userLifecycleContainer.setGuiUserLifecyclePolicyPartConfiguration(guiUserLifecyclePolicyPartConfig);
1137         
1138       }
1139 
1140       guiResponseJs.addAction(GuiScreenAction.newInnerHtmlFromJsp("#grouperMainContentDivId", 
1141           "/WEB-INF/grouperUi2/userLifecycle/userLifecyclePolicyPartConfigAdd.jsp"));
1142       
1143     } finally {
1144       GrouperSession.stopQuietly(grouperSession);
1145     }
1146     
1147   }
1148   
1149   public void addUserLifecyclePolicyPartConfigSubmit(final HttpServletRequest request, final HttpServletResponse response) {
1150     
1151     final Subject loggedInSubject = GrouperUiFilter.retrieveSubjectLoggedIn();
1152     
1153     GrouperSession grouperSession = null;
1154     
1155     final GuiResponseJs guiResponseJs = GuiResponseJs.retrieveGuiResponseJs();
1156     
1157     try {
1158       
1159       grouperSession = GrouperSession.start(loggedInSubject);
1160       
1161       final UserLifecycleContainer userLifecycleContainer = GrouperRequestContainer.retrieveFromRequestOrCreate().getUserLifecycleContainer();
1162       
1163       if (!userLifecycleContainer.isCanOperateOnUserLifecycleConfigs()) {
1164         throw new RuntimeException("Not allowed!!!!!");
1165       }
1166       
1167       String configId = request.getParameter("userLifecyclePolicyPartConfigId");
1168       
1169       if (StringUtils.isBlank(configId)) {
1170         guiResponseJs.addAction(GuiScreenAction.newValidationMessage(GuiMessageType.error, 
1171             "#userLifecyclePolicyPartConfigId",
1172             TextContainer.retrieveFromRequest().getText().get("dataFieldCreateErrorConfigIdRequired")));
1173         return;
1174       }
1175       
1176       UserLifecyclePolicyPartConfiguration userLifecyclePolicyPartConfiguration = new UserLifecyclePolicyPartConfiguration();
1177       
1178       userLifecyclePolicyPartConfiguration.setConfigId(configId);
1179       userLifecyclePolicyPartConfiguration.populateConfigurationValuesFromUi(request);
1180       
1181       StringBuilder message = new StringBuilder();
1182       List<String> errorsToDisplay = new ArrayList<String>();
1183       Map<String, String> validationErrorsToDisplay = new HashMap<String, String>();
1184       
1185       userLifecyclePolicyPartConfiguration.insertConfig(true, message, errorsToDisplay, validationErrorsToDisplay, new ArrayList<String>());
1186       
1187       if (errorsToDisplay.size() > 0 || validationErrorsToDisplay.size() > 0) {
1188 
1189         for (String errorToDisplay: errorsToDisplay) {
1190           guiResponseJs.addAction(GuiScreenAction.newMessageAppend(GuiMessageType.error, errorToDisplay));
1191         }
1192         for (String validationKey: validationErrorsToDisplay.keySet()) {
1193           guiResponseJs.addAction(GuiScreenAction.newValidationMessage(GuiMessageType.error, validationKey, 
1194               validationErrorsToDisplay.get(validationKey)));
1195         }
1196 
1197         return;
1198 
1199       }
1200       
1201       guiResponseJs.addAction(GuiScreenAction.newScript("guiV2link('operation=UiV2UserLifecycle.viewUserLifecyclePolicyParts')"));
1202       
1203       guiResponseJs.addAction(GuiScreenAction.newMessage(GuiMessageType.success,
1204           TextContainer.retrieveFromRequest().getText().get("userLifecyclePolicyConfigAddEditSuccess")));
1205     } finally {
1206       GrouperSession.stopQuietly(grouperSession);
1207     }
1208   }
1209   
1210   /**
1211    * show edit user lifecycle policy part config screen
1212    * @param request
1213    * @param response
1214    */
1215   public void editUserLifecyclePolicyPartConfig(final HttpServletRequest request, final HttpServletResponse response) {
1216     
1217     final Subject loggedInSubject = GrouperUiFilter.retrieveSubjectLoggedIn();
1218     
1219     GrouperSession grouperSession = null;
1220     
1221     final GuiResponseJs guiResponseJs = GuiResponseJs.retrieveGuiResponseJs();
1222     
1223     try {
1224       
1225       grouperSession = GrouperSession.start(loggedInSubject);
1226       
1227       final UserLifecycleContainer userLifecycleContainer = GrouperRequestContainer.retrieveFromRequestOrCreate().getUserLifecycleContainer();
1228       
1229       if (!userLifecycleContainer.isCanOperateOnUserLifecycleConfigs()) {
1230         throw new RuntimeException("Not allowed!!!!!");
1231       }
1232       
1233       String configId = request.getParameter("configId");
1234       
1235       if (StringUtils.isBlank(configId)) {
1236         guiResponseJs.addAction(GuiScreenAction.newValidationMessage(GuiMessageType.error, 
1237             "#userLifecyclePolicyPartConfigId",
1238             TextContainer.retrieveFromRequest().getText().get("dataFieldCreateErrorConfigIdRequired")));
1239         return;
1240       }
1241       
1242       UserLifecyclePolicyPartConfiguration userLifecyclePolicyPartConfiguration = new UserLifecyclePolicyPartConfiguration();
1243       
1244       userLifecyclePolicyPartConfiguration.setConfigId(configId);
1245       
1246       String previousConfigId = request.getParameter("previousConfigId");
1247       
1248       if (StringUtils.isBlank(previousConfigId)) {
1249         // first time loading the screen. let's get values from config files/database
1250         GuiUserLifecyclePolicyPartConfiguration guiUserLifecyclePolicyConfig = GuiUserLifecyclePolicyPartConfiguration.convertFromUserLifecyclePolicyPartConfiguration(userLifecyclePolicyPartConfiguration);
1251         userLifecycleContainer.setGuiUserLifecyclePolicyPartConfiguration(guiUserLifecyclePolicyConfig);
1252       } else {
1253         // change was made on the form
1254         userLifecyclePolicyPartConfiguration.populateConfigurationValuesFromUi(request);
1255         
1256         GuiUserLifecyclePolicyPartConfiguration guiUserLifecyclePolicyConfig = GuiUserLifecyclePolicyPartConfiguration.convertFromUserLifecyclePolicyPartConfiguration(userLifecyclePolicyPartConfiguration);
1257         userLifecycleContainer.setGuiUserLifecyclePolicyPartConfiguration(guiUserLifecyclePolicyConfig);
1258         
1259       }
1260       
1261       guiResponseJs.addAction(GuiScreenAction.newInnerHtmlFromJsp("#grouperMainContentDivId",
1262           "/WEB-INF/grouperUi2/userLifecycle/editUserLifecyclePolicyPartConfigDetails.jsp"));
1263       
1264     } finally {
1265       GrouperSession.stopQuietly(grouperSession);
1266     }
1267   }
1268   
1269   /**
1270    * save edited user lifecycle policy part config into db
1271    * @param request
1272    * @param response
1273    */
1274   public void editUserLifecyclePolicyPartConfigSubmit(final HttpServletRequest request, final HttpServletResponse response) {
1275     
1276     final Subject loggedInSubject = GrouperUiFilter.retrieveSubjectLoggedIn();
1277     
1278     GrouperSession grouperSession = null;
1279     
1280     final GuiResponseJs guiResponseJs = GuiResponseJs.retrieveGuiResponseJs();
1281     
1282     try {
1283       
1284       grouperSession = GrouperSession.start(loggedInSubject);
1285       
1286       final UserLifecycleContainer userLifecycleContainer = GrouperRequestContainer.retrieveFromRequestOrCreate().getUserLifecycleContainer();
1287       
1288       if (!userLifecycleContainer.isCanOperateOnUserLifecycleConfigs()) {
1289         throw new RuntimeException("Not allowed!!!!!");
1290       }
1291       
1292       String configId = request.getParameter("configId");
1293       
1294       if (StringUtils.isBlank(configId)) {
1295         guiResponseJs.addAction(GuiScreenAction.newValidationMessage(GuiMessageType.error, 
1296             "#userLifecyclePolicyPartConfigId",
1297             TextContainer.retrieveFromRequest().getText().get("dataFieldCreateErrorConfigIdRequired")));
1298         return;
1299       }
1300       
1301       UserLifecyclePolicyPartConfiguration userLifecyclePolicyPartConfiguration = new UserLifecyclePolicyPartConfiguration();
1302       
1303       userLifecyclePolicyPartConfiguration.setConfigId(configId);
1304       userLifecyclePolicyPartConfiguration.populateConfigurationValuesFromUi(request);
1305       
1306       StringBuilder message = new StringBuilder();
1307       List<String> errorsToDisplay = new ArrayList<String>();
1308       Map<String, String> validationErrorsToDisplay = new HashMap<String, String>();
1309       List<String> actionsPerformed = new ArrayList<String>();
1310 
1311       userLifecyclePolicyPartConfiguration.editConfig(true, message, errorsToDisplay, validationErrorsToDisplay, actionsPerformed);
1312       
1313       if (errorsToDisplay.size() > 0 || validationErrorsToDisplay.size() > 0) {
1314 
1315         for (String errorToDisplay: errorsToDisplay) {
1316           guiResponseJs.addAction(GuiScreenAction.newMessage(GuiMessageType.error, errorToDisplay));
1317         }
1318         for (String validationKey: validationErrorsToDisplay.keySet()) {
1319           guiResponseJs.addAction(GuiScreenAction.newValidationMessage(GuiMessageType.error, validationKey, 
1320               validationErrorsToDisplay.get(validationKey)));
1321         }
1322         return;
1323       }
1324       
1325       guiResponseJs.addAction(GuiScreenAction.newScript("guiV2link('operation=UiV2UserLifecycle.viewUserLifecyclePolicyParts')"));
1326       
1327       guiResponseJs.addAction(GuiScreenAction.newMessage(GuiMessageType.success,
1328           TextContainer.retrieveFromRequest().getText().get("userLifecyclePolicyConfigAddEditSuccess")));
1329    
1330       if (actionsPerformed.size() > 0) {
1331         for (String actionPerformed: actionsPerformed) {
1332           guiResponseJs.addAction(GuiScreenAction.newMessageAppend(GuiMessageType.success, actionPerformed));
1333         }
1334       }      
1335     } finally {
1336       GrouperSession.stopQuietly(grouperSession);
1337     }
1338   }
1339   
1340   /**
1341    * delete policy part config
1342    * @param request
1343    * @param response
1344    */
1345   public void deleteUserLifecyclePolicyPartConfig(final HttpServletRequest request, final HttpServletResponse response) {
1346     
1347     final Subject loggedInSubject = GrouperUiFilter.retrieveSubjectLoggedIn();
1348     
1349     GrouperSession grouperSession = null;
1350     
1351     final GuiResponseJs guiResponseJs = GuiResponseJs.retrieveGuiResponseJs();
1352     
1353     try {
1354       
1355       grouperSession = GrouperSession.start(loggedInSubject);
1356       
1357       final UserLifecycleContainer userLifecycleContainer = GrouperRequestContainer.retrieveFromRequestOrCreate().getUserLifecycleContainer();
1358       
1359       if (!userLifecycleContainer.isCanOperateOnUserLifecycleConfigs()) {
1360         throw new RuntimeException("Not allowed!!!!!");
1361       }
1362       
1363       String configId = request.getParameter("configId");
1364       
1365       if (StringUtils.isBlank(configId)) {
1366         guiResponseJs.addAction(GuiScreenAction.newValidationMessage(GuiMessageType.error, 
1367             "#userLifecyclePolicyPartConfigId",
1368             TextContainer.retrieveFromRequest().getText().get("dataFieldCreateErrorConfigIdRequired")));
1369         return;
1370       }
1371       
1372       UserLifecyclePolicyPartConfiguration userLifecyclePolicyPartConfiguration = new UserLifecyclePolicyPartConfiguration();
1373       
1374       userLifecyclePolicyPartConfiguration.setConfigId(configId);
1375       
1376       userLifecyclePolicyPartConfiguration.deleteConfig(true);
1377       
1378       guiResponseJs.addAction(GuiScreenAction.newScript("guiV2link('operation=UiV2UserLifecycle.viewUserLifecyclePolicyParts')"));
1379       
1380       guiResponseJs.addAction(GuiScreenAction.newMessage(GuiMessageType.success,
1381           TextContainer.retrieveFromRequest().getText().get("userLifecyclePolicyConfigDeleteSuccess")));
1382       
1383     } finally {
1384       GrouperSession.stopQuietly(grouperSession);
1385     }
1386   }
1387 
1388 }