Java > Open Source Codes > org > apache > jetspeed > modules > actions > portlets > RegistryUpdateAction


1 /*
2  * Copyright 2000-2004 The Apache Software Foundation.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 package org.apache.jetspeed.modules.actions.portlets;
17
18 import java.util.ArrayList ;
19 import java.util.Collection ;
20 import java.util.Iterator ;
21
22 import org.apache.jetspeed.modules.actions.portlets.security.SecurityConstants;
23 import org.apache.jetspeed.om.BaseSecurityReference;
24 import org.apache.jetspeed.om.SecurityReference;
25 import org.apache.jetspeed.om.registry.CapabilityMap;
26 import org.apache.jetspeed.om.registry.ClientEntry;
27 import org.apache.jetspeed.om.registry.MediaTypeEntry;
28 import org.apache.jetspeed.om.registry.Parameter;
29 import org.apache.jetspeed.om.registry.PortletEntry;
30 import org.apache.jetspeed.om.registry.PortletInfoEntry;
31 import org.apache.jetspeed.om.registry.RegistryEntry;
32 import org.apache.jetspeed.om.registry.base.BaseCachedParameter;
33 import org.apache.jetspeed.om.registry.base.BaseParameter;
34 import org.apache.jetspeed.om.registry.base.BaseSecurity;
35 import org.apache.jetspeed.portal.portlets.VelocityPortlet;
36 import org.apache.jetspeed.services.Registry;
37 import org.apache.jetspeed.services.logging.JetspeedLogFactoryService;
38 import org.apache.jetspeed.services.logging.JetspeedLogger;
39 import org.apache.jetspeed.util.template.JetspeedLink;
40 import org.apache.jetspeed.util.template.JetspeedLinkFactory;
41 import org.apache.turbine.util.DynamicURI;
42 import org.apache.turbine.util.RunData;
43 import org.apache.turbine.util.TurbineException;
44 import org.apache.turbine.util.security.EntityExistsException;
45 import org.apache.velocity.context.Context;
46
47 /**
48  * An abstract base class with default actions for many of the common
49  * fields and parameters shared by the registry entries. To add a new registry
50  * update action, simply derive from this class and override the resetForm,
51  * clearUserData, and updateRegistry functions. If you need to provide more
52  * actions that those that are provided, simply create them in your derived class.
53  *
54  * @author <a HREF="mailto:caius1440@hotmail.com">Jeremy Ford</a>
55  * @version $Id: RegistryUpdateAction.java,v 1.10 2004/03/31 04:49:10 morciuch Exp $
56  */
57 public abstract class RegistryUpdateAction extends SecureVelocityPortletAction
58 {
59     protected String registryEntryName = "";
60     protected String registry = "";
61     protected String pane = "";
62
63     private static final String REASON = "reason";
64
65     /**
66      * Static initialization of the logger for this class
67      */
68     private static final JetspeedLogger logger = JetspeedLogFactoryService.getLogger(RegistryUpdateAction.class.getName());
69     
70     protected void buildNormalContext(
71         VelocityPortlet portlet,
72         Context context,
73         RunData rundata)
74         throws Exception
75     {
76         String msgid =
77             rundata.getParameters().getString(SecurityConstants.PARAM_MSGID);
78         if (msgid != null)
79         {
80             int id = Integer.parseInt(msgid);
81             if (id < SecurityConstants.MESSAGES.length)
82                 context.put(
83                     SecurityConstants.PARAM_MSG,
84                     SecurityConstants.MESSAGES[id]);
85         }
86
87         String mode =
88             rundata.getParameters().getString(SecurityConstants.PARAM_MODE);
89         context.put(SecurityConstants.PARAM_MODE, mode);
90
91         String reason = rundata.getParameters().getString(REASON);
92         context.put(REASON, reason);
93     }
94
95     /**
96      * Insert a registry entry into the registry
97      * @param rundata The turbine rundata context for this request.
98      * @param context The velocity context for this request.
99      * @throws Exception
100      */
101     public void doInsert(RunData rundata, Context context) throws Exception
102     {
103         try
104         {
105             String entryName =
106                 rundata.getParameters().getString(registryEntryName);
107
108             if (entryName == null || entryName.length() == 0)
109             {
110                 DynamicURI duri =
111                     redirect(
112                         rundata,
113                         SecurityConstants.PARAM_MODE_INSERT,
114                         SecurityConstants.MID_INVALID_ENTITY_NAME);
115                 rundata.setRedirectURI(duri.toString());
116                 resetForm(rundata);
117             }
118             else
119             {
120                 //check if profile to be created already exists
121 RegistryEntry existingEntry =
122                     Registry.getEntry(registry, entryName);
123                 if (existingEntry != null)
124                 {
125                     throw new EntityExistsException(
126                         "RegistryEntry: " + entryName + " Already Exists!");
127                 }
128
129                 RegistryEntry registryEntry = Registry.createEntry(registry);
130                 registryEntry.setName(entryName);
131
132                 updateRegistryEntry(rundata, registryEntry);
133
134                 Registry.addEntry(registry, registryEntry);
135
136                 clearUserData(rundata);
137                 
138                 rundata.getUser().setTemp(RegistryBrowseAction.PREFIX + registry + ":" + RegistryBrowseAction.REFRESH, Boolean.TRUE);
139             }
140         }
141         catch (EntityExistsException e)
142         {
143             //
144 // dup key found - display error message - bring back to same screen
145 //
146 DynamicURI duri =
147                 redirect(
148                     rundata,
149                     SecurityConstants.PARAM_MODE_INSERT,
150                     SecurityConstants.MID_ENTITY_ALREADY_EXISTS);
151             rundata.setRedirectURI(duri.toString());
152             resetForm(rundata);
153
154             logger.error(
155                 this.getClass().getName()
156                     + ": Trying to create duplicate entry");
157         }
158         catch (Exception e)
159         {
160             DynamicURI duri =
161                 redirect(
162                     rundata,
163                     SecurityConstants.PARAM_MODE_INSERT,
164                     SecurityConstants.MID_UPDATE_FAILED);
165             duri = duri.addQueryData(REASON, e.getMessage());
166             rundata.setRedirectURI(duri.toString());
167             resetForm(rundata);
168
169             logger.error("Exception", e);
170         }
171     }
172
173     /**
174      * Update a registry entry
175      * @param rundata The turbine rundata context for this request.
176      * @param context The velocity context for this request.
177      * @throws Exception
178      */
179     public void doUpdate(RunData rundata, Context context) throws Exception
180     {
181         try
182         {
183             String entryName =
184                 rundata.getParameters().getString(registryEntryName);
185             RegistryEntry registryEntry =
186                 Registry.getEntry(registry, entryName);
187             if (registryEntry != null)
188             {
189                 updateRegistryEntry(rundata, registryEntry);
190
191                 Registry.addEntry(registry, registryEntry);
192                 clearUserData(rundata);
193             }
194             else
195             {
196                 DynamicURI duri =
197                     redirect(
198                         rundata,
199                         SecurityConstants.PARAM_MODE_UPDATE,
200                         SecurityConstants.MID_INVALID_ENTITY_NAME);
201                 rundata.setRedirectURI(duri.toString());
202                 resetForm(rundata);
203
204                 logger.error(
205                     this.getClass().getName()
206                         + ": Failed to find registry entry for updating");
207             }
208         }
209         catch (Exception e)
210         {
211             DynamicURI duri =
212                 redirect(
213                     rundata,
214                     SecurityConstants.PARAM_MODE_UPDATE,
215                     SecurityConstants.MID_UPDATE_FAILED);
216             duri = duri.addQueryData(REASON, e.getMessage());
217             rundata.setRedirectURI(duri.toString());
218             resetForm(rundata);
219
220             logger.error("Exception", e);
221         }
222     }
223
224     /**
225      * Delete a registry entry
226      * @param rundata The turbine rundata context for this request.
227      * @param context The velocity context for this request.
228      * @throws Exception
229      */
230     public void doDelete(RunData rundata, Context context) throws Exception
231     {
232         try
233         {
234             String entryName =
235                 rundata.getParameters().getString(registryEntryName);
236
237             if (entryName == null || entryName.length() == 0)
238             {
239                 DynamicURI duri =
240                     redirect(
241                         rundata,
242                         SecurityConstants.PARAM_MODE_DELETE,
243                         SecurityConstants.MID_INVALID_ENTITY_NAME);
244                 rundata.setRedirectURI(duri.toString());
245                 resetForm(rundata);
246
247                 logger.error(
248                     this.getClass().getName()
249                         + ": Failed to find registry entry for deleting");
250             }
251             else
252             {
253                 Registry.removeEntry(registry, entryName);
254                 clearUserData(rundata);
255                 
256                 rundata.getUser().setTemp(RegistryBrowseAction.PREFIX + registry + ":" + RegistryBrowseAction.REFRESH, Boolean.TRUE);
257             }
258         }
259         catch (Exception e)
260         {
261             DynamicURI duri =
262                 redirect(
263                     rundata,
264                     SecurityConstants.PARAM_MODE_DELETE,
265                     SecurityConstants.MID_DELETE_FAILED);
266             duri = duri.addQueryData(REASON, e.getMessage());
267             rundata.setRedirectURI(duri.toString());
268             resetForm(rundata);
269
270             logger.error("Exception", e);
271         }
272     }
273
274     /**
275      * Cleanup method
276      * @param rundata The turbine rundata context for this request.
277      * @param context The velocity context for this request.
278      * @throws Exception
279      */
280     public void doCancel(RunData rundata, Context context) throws Exception
281     {
282         clearUserData(rundata);
283     }
284
285     /**
286      * Basic implementation of a method to update a registry entry. The fields that
287      * are common to all registry entries can simply be added below.
288      * @param rundata The turbine rundata context for this request.
289      * @param registryEntry The registry entry to update
290      */
291     protected void updateRegistryEntry(
292         RunData rundata,
293         RegistryEntry registryEntry)
294         throws Exception
295     {
296         String description = rundata.getParameters().getString("description");
297         String title = rundata.getParameters().getString("title");
298         Boolean hidden = rundata.getParameters().getBool("hidden");
299         String securityRef = rundata.getParameters().getString("security_ref");
300
301         SecurityReference security = registryEntry.getSecurityRef();
302         String securityParent = null;
303         if (security != null)
304         {
305             securityParent = security.getParent();
306         }
307
308         if (hasChanged(securityParent, securityRef))
309         {
310             if (security == null)
311             {
312                 security = new BaseSecurityReference();
313             }
314             security.setParent(securityRef);
315             registryEntry.setSecurityRef(security);
316         }
317
318         if (hasChanged(registryEntry.getDescription(), description))
319         {
320             registryEntry.setDescription(description);
321         }
322         if (hasChanged(String.valueOf(registryEntry.isHidden()),
323             String.valueOf(hidden)))
324         {
325             registryEntry.setHidden(hidden.booleanValue());
326         }
327         if (hasChanged(registryEntry.getTitle(), title))
328         {
329             registryEntry.setTitle(title);
330         }
331     }
332
333     /**
334      * Determines whether a field has changed value. Used in update methods.
335      *
336      * @param oldValue The original value
337      * @param newValue The new value
338      */
339     protected boolean hasChanged(String oldValue, String newValue)
340     {
341         boolean result = false;
342
343         if (oldValue == null && newValue == null)
344         {
345             result = false;
346         }
347         else if (
348             oldValue == null && (newValue != null && newValue.length() == 0))
349         {
350             result = false;
351         }
352         else if (oldValue == null && (newValue != null))
353         {
354             result = true;
355         }
356         else if (oldValue != null && newValue == null)
357         {
358             result = true;
359         }
360         else if (!oldValue.equals(newValue))
361         {
362             result = true;
363         }
364
365         return result;
366     }
367
368     /**
369      * Add a parameter to a registry entry
370      * @param rundata The turbine rundata context for this request.
371      * @param context The velocity context for this request.
372      * @throws Exception
373      */
374     public void doAddparameter(RunData rundata, Context context)
375         throws Exception
376     {
377         try
378         {
379             String entryName =
380                 rundata.getParameters().getString(registryEntryName);
381             PortletInfoEntry regEntry =
382                 (PortletInfoEntry) Registry.getEntry(registry, entryName);
383             if (regEntry != null)
384             {
385                 String parameterName =
386                     rundata.getParameters().getString("parameter_name");
387                 if (parameterName != null && parameterName.length() > 0)
388                 {
389                     Parameter parameter = null;
390                     if (regEntry instanceof PortletEntry)
391                     {
392                         parameter = new BaseCachedParameter();
393
394                         boolean isCachedOnName =
395                             rundata.getParameters().getBoolean(
396                                 "cached_on_name",
397                                 false);
398                         boolean isCachedOnValue =
399                             rundata.getParameters().getBoolean(
400                                 "cached_on_value",
401                                 false);
402
403                         ((BaseCachedParameter) parameter).setCachedOnName(
404                             isCachedOnName);
405                         ((BaseCachedParameter) parameter).setCachedOnValue(
406                             isCachedOnValue);
407                     }
408                     else
409                     {
410                         parameter = new BaseParameter();
411                     }
412
413                     String parameterValue =
414                         rundata.getParameters().getString("parameter_value");
415                     boolean isHidden =
416                         rundata.getParameters().getBoolean("is_hidden", false);
417                     String description =
418                         rundata.getParameters().getString("description");
419                     String title = rundata.getParameters().getString("title");
420                     String type = rundata.getParameters().getString("type");
421
422                     parameter.setName(parameterName);
423                     parameter.setValue(parameterValue);
424                     parameter.setHidden(isHidden);
425                     parameter.setDescription(description);
426                     parameter.setTitle(title);
427                     parameter.setType(type);
428
429                     String securityRole =
430                         rundata.getParameters().getString("security_role");
431                     String securityRef =
432                         rundata.getParameters().getString("security_ref");
433
434                     if (securityRole != null && securityRole.length() > 0)
435                     {
436                         BaseSecurity paramSecurity = new BaseSecurity();
437                         paramSecurity.setRole(securityRole);
438                         parameter.setSecurity(paramSecurity);
439                     }
440
441                     if (securityRef != null && securityRef.length() > 0)
442                     {
443                         BaseSecurityReference paramSecurityRef =
444                             new BaseSecurityReference();
445                         paramSecurityRef.setParent(securityRef);
446                         parameter.setSecurityRef(paramSecurityRef);
447                     }
448
449                     regEntry.addParameter(parameter);
450
451                     Registry.addEntry(registry, regEntry);
452
453                     clearUserData(rundata);
454                 }
455                 else
456                 {
457                     DynamicURI duri =
458                         redirect(
459                             rundata,
460                             SecurityConstants.PARAM_MODE_UPDATE,
461                             SecurityConstants.MID_MISSING_PARAMETER);
462                     rundata.setRedirectURI(duri.toString());
463
464                     resetForm(rundata);
465                 }
466             }
467             else
468             {
469                 DynamicURI duri =
470                     redirect(
471                         rundata,
472                         SecurityConstants.PARAM_MODE_UPDATE,
473                         SecurityConstants.MID_INVALID_ENTITY_NAME);
474                 rundata.setRedirectURI(duri.toString());
475
476                 resetForm(rundata);
477
478                 logger.error(
479                     this.getClass().getName()
480                         + ": Failed to find registry entry while trying to add a parameter");
481             }
482         }
483         catch (Exception e)
484         {
485             DynamicURI duri =
486                 redirect(
487                     rundata,
488                     SecurityConstants.PARAM_MODE_UPDATE,
489                     SecurityConstants.MID_INVALID_ENTITY_NAME);
490             rundata.setRedirectURI(duri.toString());
491
492             resetForm(rundata);
493
494             logger.error("Exception", e);
495         }
496     }
497
498     /**
499      * Update parameters of a registry entry
500      * @param rundata The turbine rundata context for this request.
501      * @param context The velocity context for this request.
502      * @throws Exception
503      */
504     public void doUpdateparameters(RunData rundata, Context context)
505         throws Exception
506     {
507         try
508         {
509             String entryName =
510                 rundata.getParameters().getString(registryEntryName);
511             PortletInfoEntry regEntry =
512                 (PortletInfoEntry) Registry.getEntry(registry, entryName);
513             if (regEntry != null)
514             {
515                 String [] parameters =
516                     rundata.getParameters().getStrings("update_parameter_name");
517                 if (parameters != null && parameters.length > 0)
518                 {
519                     for (int i = 0; i < parameters.length; i++)
520                     {
521                         String parameterName = parameters[i];
522                         Parameter parameter = regEntry.getParameter(parameterName);
523                         if (regEntry instanceof PortletEntry)
524                         {
525                             if(parameter == null)
526                             {
527                                 parameter = new BaseCachedParameter();
528                                 regEntry.addParameter(parameter);
529                             }
530
531                             boolean isCachedOnName =
532                                 rundata.getParameters().getBoolean(
533                                     parameterName +".cached_on_name",
534                                     false);
535                             boolean isCachedOnValue =
536                                 rundata.getParameters().getBoolean(
537                                     parameterName +".cached_on_value",
538                                     false);
539
540                             ((BaseCachedParameter) parameter).setCachedOnName(
541                                 isCachedOnName);
542                             ((BaseCachedParameter) parameter).setCachedOnValue(
543                                 isCachedOnValue);
544                         }
545                         else if(parameter == null)
546                         {
547                             parameter = new BaseParameter();
548                             regEntry.addParameter(parameter);
549                         }
550                         
551                         String parameterValue =
552                             rundata.getParameters().getString(
553                                 parameterName + ".parameter_value");
554                         String description =
555                             rundata.getParameters().getString(
556                                 parameterName + ".description");
557                         String title =
558                             rundata.getParameters().getString(
559                                 parameterName + ".title");
560                         String securityRole =
561                             rundata.getParameters().getString(
562                                 parameterName + ".security_role");
563                         String securityRef =
564                             rundata.getParameters().getString(
565                                 parameterName + ".security_ref");
566                         String type =
567                             rundata.getParameters().getString(
568                                 parameterName + ".type");
569                         boolean isHidden =
570                             rundata.getParameters().getBoolean(
571                                 parameterName + ".is_hidden",
572                                 false);
573
574                         parameter.setName(parameterName);
575                         parameter.setValue(parameterValue);
576                         parameter.setHidden(isHidden);
577                         parameter.setDescription(description);
578                         parameter.setTitle(title);
579                         parameter.setType(type);
580
581                         if (securityRef != null && securityRef.length() > 0)
582                         {
583                             BaseSecurityReference paramSecurityRef =
584                                 new BaseSecurityReference();
585                             paramSecurityRef.setParent(securityRef);
586                             parameter.setSecurityRef(paramSecurityRef);
587                         }
588                     }
589
590                     Registry.addEntry(registry, regEntry);
591                     clearUserData(rundata);
592                 }
593                 else
594                 {
595                     DynamicURI duri =
596                         redirect(
597                             rundata,
598                             SecurityConstants.PARAM_MODE_UPDATE,
599                             SecurityConstants.MID_MISSING_PARAMETER);
600                     rundata.setRedirectURI(duri.toString());
601
602                     resetForm(rundata);
603                 }
604             }
605             else
606             {
607                 DynamicURI duri =
608                     redirect(
609                         rundata,
610                         SecurityConstants.PARAM_MODE_UPDATE,
611                         SecurityConstants.MID_INVALID_ENTITY_NAME);
612                 rundata.setRedirectURI(duri.toString());
613                 resetForm(rundata);
614
615                 logger.error(
616                     this.getClass().getName()
617                         + ": Failed to find registry entry while trying to update parameters");
618             }
619         }
620         catch (Exception e)
621         {
622             DynamicURI duri =
623                 redirect(
624                     rundata,
625                     SecurityConstants.PARAM_MODE_UPDATE,
626                     SecurityConstants.MID_UPDATE_FAILED);
627             rundata.setRedirectURI(duri.toString());
628
629             resetForm(rundata);
630
631             logger.error("Exception", e);
632         }
633     }
634
635     /**
636      * Update parameter's values of a registry entry
637      * @param rundata The turbine rundata context for this request.
638      * @param context The velocity context for this request.
639      * @throws Exception
640      */
641     public void doUpdateparametervalues(RunData rundata, Context context)
642         throws Exception
643     {
644         try
645         {
646             String entryName =
647                 rundata.getParameters().getString(registryEntryName);
648             PortletInfoEntry regEntry =
649                 (PortletInfoEntry) Registry.getEntry(registry, entryName);
650             if (regEntry != null)
651             {
652                 String [] parameters =
653                     rundata.getParameters().getStrings("update_parameter_name");
654                 if (parameters != null && parameters.length > 0)
655                 {
656                     for (int i = 0; i < parameters.length; i++)
657                     {
658                         String parameterName = parameters[i];
659                         String parameterValue =
660                             rundata.getParameters().getString(
661                                 parameterName + ".parameter_value");
662
663                         Parameter parameter =
664                             regEntry.getParameter(parameterName);
665
666                         if (parameter == null)
667                         {
668                             if (regEntry instanceof PortletEntry)
669                             {
670                                 parameter = new BaseCachedParameter();
671                             }
672                             else
673                             {
674                                 parameter = new BaseParameter();
675                             }
676                             
677                             parameter.setName(parameterName);
678                             regEntry.addParameter(parameter);
679                         }
680
681                         if (parameter != null)
682                         {
683                             parameter.setValue(parameterValue);
684                         }
685                     }
686
687                     Registry.addEntry(registry, regEntry);
688                     clearUserData(rundata);
689                 }
690                 else
691                 {
692
693                     DynamicURI duri =
694                         redirect(
695                             rundata,
696                             SecurityConstants.PARAM_MODE_UPDATE,
697                             SecurityConstants.MID_MISSING_PARAMETER);
698                     rundata.setRedirectURI(duri.toString());
699                     resetForm(rundata);
700                 }
701             }
702             else
703             {
704                 DynamicURI duri =
705                     redirect(
706                         rundata,
707                         SecurityConstants.PARAM_MODE_UPDATE,
708                         SecurityConstants.MID_INVALID_ENTITY_NAME);
709                 rundata.setRedirectURI(duri.toString());
710                 resetForm(rundata);
711
712                 logger.error(
713                     this.getClass().getName()
714                         + ": Failed to find registry entry while trying to update parameters");
715             }
716         }
717         catch (Exception e)
718         {
719             DynamicURI duri =
720                 redirect(
721                     rundata,
722                     SecurityConstants.PARAM_MODE_UPDATE,
723                     SecurityConstants.MID_UPDATE_FAILED);
724             rundata.setRedirectURI(duri.toString());
725             resetForm(rundata);
726
727             logger.error("Exception", e);
728         }
729     }
730
731     /**
732      * Remove parameters from a registry entry
733      * @param rundata The turbine rundata context for this request.
734      * @param context The velocity context for this request.
735      * @throws Exception
736      */
737     public void doRemoveparameters(RunData rundata, Context context)
738         throws Exception
739     {
740         try
741         {
742             String entryName =
743                 rundata.getParameters().getString(registryEntryName);
744             PortletInfoEntry portletEntry =
745                 (PortletInfoEntry) Registry.getEntry(registry, entryName);
746             if (portletEntry != null)
747             {
748                 String [] parameters =
749                     rundata.getParameters().getStrings("parameter_name");
750                 if (parameters != null && parameters.length > 0)
751                 {
752                     for (int i = 0; i < parameters.length; i++)
753                     {
754                         String parameterName = parameters[i];
755                         portletEntry.removeParameter(parameterName);
756                     }
757
758                     Registry.addEntry(registry, portletEntry);
759                     clearUserData(rundata);
760                 }
761                 else
762                 {
763                     DynamicURI duri =
764                         redirect(
765                             rundata,
766                             SecurityConstants.PARAM_MODE_UPDATE,
767                             SecurityConstants.MID_MISSING_PARAMETER);
768                     rundata.setRedirectURI(duri.toString());
769                     resetForm(rundata);
770                 }
771             }
772             else
773             {
774                 DynamicURI duri =
775                     redirect(
776                         rundata,
777                         SecurityConstants.PARAM_MODE_UPDATE,
778                         SecurityConstants.MID_INVALID_ENTITY_NAME);
779                 rundata.setRedirectURI(duri.toString());
780                 resetForm(rundata);
781
782                 logger.error(
783                     this.getClass().getName()
784                         + ": Failed to find registry entry while trying to remove parameters");
785             }
786         }
787         catch (Exception e)
788         {
789             DynamicURI duri =
790                 redirect(
791                     rundata,
792                     SecurityConstants.PARAM_MODE_UPDATE,
793                     SecurityConstants.MID_UPDATE_FAILED);
794             rundata.setRedirectURI(duri.toString());
795             resetForm(rundata);
796
797             logger.error("Exception", e);
798         }
799     }
800
801     /**
802      * Add a media type to a registry entry
803      * @param rundata The turbine rundata context for this request.
804      * @param context The velocity context for this request.
805      * @throws Exception
806      */
807     public void doAddmediatype(RunData rundata, Context context)
808         throws Exception
809     {
810         try
811         {
812             String entryName =
813                 rundata.getParameters().getString(registryEntryName);
814             PortletInfoEntry portletEntry =
815                 (PortletInfoEntry) Registry.getEntry(registry, entryName);
816             if (portletEntry != null)
817             {
818                 String mediaType =
819                     rundata.getParameters().getString("media_type");
820                 if (mediaType != null && mediaType.length() > 0)
821                 {
822                     portletEntry.addMediaType(mediaType);
823                     Registry.addEntry(registry, portletEntry);
824                     clearUserData(rundata);
825                 }
826                 else
827                 {
828                     DynamicURI duri =
829                         redirect(
830                             rundata,
831                             SecurityConstants.PARAM_MODE_UPDATE,
832                             SecurityConstants.MID_MISSING_PARAMETER);
833                     rundata.setRedirectURI(duri.toString());
834                     resetForm(rundata);
835                 }
836             }
837             else
838             {
839                 DynamicURI duri =
840                     redirect(
841                         rundata,
842                         SecurityConstants.PARAM_MODE_UPDATE,
843                         SecurityConstants.MID_INVALID_ENTITY_NAME);
844                 rundata.setRedirectURI(duri.toString());
845                 resetForm(rundata);
846
847                 logger.error(
848                     this.getClass().getName()
849                         + ": Failed to find registry entry while trying to add media type");
850             }
851         }
852         catch (Exception e)
853         {
854             DynamicURI duri =
855                 redirect(
856                     rundata,
857                     SecurityConstants.PARAM_MODE_UPDATE,
858                     SecurityConstants.MID_UPDATE_FAILED);
859             rundata.setRedirectURI(duri.toString());
860             resetForm(rundata);
861
862             logger.error("Exception", e);
863         }
864     }
865
866     /**
867      * Remove media types from a registry entry
868      * @param rundata The turbine rundata context for this request.
869      * @param context The velocity context for this request.
870      * @throws Exception
871      */
872     public void doRemovemediatypes(RunData rundata, Context context)
873         throws Exception
874     {
875         try
876         {
877             String entryName =
878                 rundata.getParameters().getString(registryEntryName);
879             PortletInfoEntry portletEntry =
880                 (PortletInfoEntry) Registry.getEntry(registry, entryName);
881             if (portletEntry != null)
882             {
883                 String [] mediaTypes =
884                     rundata.getParameters().getStrings("media_type");
885                 if (mediaTypes != null && mediaTypes.length > 0)
886                 {
887                     for (int i = 0; i < mediaTypes.length; i++)
888                     {
889                         String mediaType = mediaTypes[i];
890                         portletEntry.removeMediaType(mediaType);
891                     }
892
893                     Registry.addEntry(registry, portletEntry);
894                     clearUserData(rundata);
895                 }
896                 else
897                 {
898                     DynamicURI duri =
899                         redirect(
900                             rundata,
901                             SecurityConstants.PARAM_MODE_UPDATE,
902                             SecurityConstants.MID_MISSING_PARAMETER);
903                     rundata.setRedirectURI(duri.toString());
904                     resetForm(rundata);
905                 }
906
907             }
908             else
909             {
910                 DynamicURI duri =
911                     redirect(
912                         rundata,
913                         SecurityConstants.PARAM_MODE_UPDATE,
914                         SecurityConstants.MID_INVALID_ENTITY_NAME);
915                 rundata.setRedirectURI(duri.toString());
916                 resetForm(rundata);
917
918                 logger.error(
919                     this.getClass().getName()
920                         + ": Failed to find registry entry while trying to remove media types");
921             }
922         }
923         catch (Exception e)
924         {
925             DynamicURI duri =
926                 redirect(
927                     rundata,
928                     SecurityConstants.PARAM_MODE_UPDATE,
929                     SecurityConstants.MID_UPDATE_FAILED);
930             rundata.setRedirectURI(duri.toString());
931             resetForm(rundata);
932
933             logger.error("Exception", e);
934         }
935     }
936
937     /**
938      * Add capabilities to a registry entry
939      * @param rundata The turbine rundata context for this request.
940      * @param context The velocity context for this request.
941      * @throws Exception
942      */
943     public void doAddcapability(RunData rundata, Context context)
944         throws Exception
945     {
946         try
947         {
948             String entryName =
949                 rundata.getParameters().getString(registryEntryName);
950             RegistryEntry regEntry = Registry.getEntry(registry, entryName);
951
952             if (regEntry != null)
953             {
954                 CapabilityMap cm = null;
955                 if (regEntry instanceof MediaTypeEntry)
956                 {
957                     MediaTypeEntry mediaTypeEntry = (MediaTypeEntry) regEntry;
958                     cm = mediaTypeEntry.getCapabilityMap();
959                 }
960                 else if (regEntry instanceof ClientEntry)
961                 {
962                     ClientEntry clientEntry = (ClientEntry) regEntry;
963                     cm = clientEntry.getCapabilityMap();
964                 }
965                 else
966                 {
967                     //TODO: throw error
968 }
969
970                 if (cm != null)
971                 {
972                     String [] capabilities =
973                         rundata.getParameters().getStrings("capability");
974                     if (capabilities != null && capabilities.length > 0)
975                     {
976                         for (int i = 0; i < capabilities.length; i++)
977                         {
978                             String capability = capabilities[i];
979                             if (cm.contains(capability))
980                             {
981                             }
982                             else
983                             {
984                                 if (capability != null
985                                     && capability.length() > 0)
986                                 {
987                                     cm.addCapability(capability);
988                                 }
989                             }
990                         }
991                     }
992
993                     Registry.addEntry(registry, regEntry);
994                     clearUserData(rundata);
995                 }
996                 else
997                 {
998                     DynamicURI duri =
999                         redirect(
1000                            rundata,
1001                            SecurityConstants.PARAM_MODE_UPDATE,
1002                            SecurityConstants.MID_UPDATE_FAILED);
1003                    rundata.setRedirectURI(duri.toString());
1004                    resetForm(rundata);
1005                }
1006            }
1007            else
1008            {
1009                DynamicURI duri =
1010                    redirect(
1011                        rundata,
1012                        SecurityConstants.PARAM_MODE_UPDATE,
1013                        SecurityConstants.MID_INVALID_ENTITY_NAME);
1014                rundata.setRedirectURI(duri.toString());
1015                resetForm(rundata);
1016
1017                logger.error(
1018                    this.getClass().getName()
1019                        + ": Failed to find registry entry while trying to add capabilities");
1020            }
1021        }
1022        catch (Exception e)
1023        {
1024            DynamicURI duri =
1025                redirect(
1026                    rundata,
1027                    SecurityConstants.PARAM_MODE_UPDATE,
1028                    SecurityConstants.MID_UPDATE_FAILED);
1029            rundata.setRedirectURI(duri.toString());
1030            resetForm(rundata);
1031
1032            logger.error("Exception", e);
1033        }
1034    }
1035
1036    /**
1037     * Remove capabilites from a registry entry
1038     * @param rundata The turbine rundata context for this request.
1039     * @param context The velocity context for this request.
1040     * @throws Exception
1041     */
1042    public void doRemovecapability(RunData rundata, Context context)
1043        throws Exception
1044    {
1045        try
1046        {
1047            String entryName =
1048                rundata.getParameters().getString(registryEntryName);
1049            RegistryEntry regEntry = Registry.getEntry(registry, entryName);
1050            if (regEntry != null)
1051            {
1052                CapabilityMap cm = null;
1053                if (regEntry instanceof MediaTypeEntry)
1054                {
1055                    MediaTypeEntry mediaTypeEntry = (MediaTypeEntry) regEntry;
1056                    cm = mediaTypeEntry.getCapabilityMap();
1057                }
1058                else if (regEntry instanceof ClientEntry)
1059                {
1060                    ClientEntry clientEntry = (ClientEntry) regEntry;
1061                    cm = clientEntry.getCapabilityMap();
1062                }
1063                else
1064                {
1065                    //TODO: throw error
1066 }
1067
1068                if (cm != null)
1069                {
1070                    String [] capabilities =
1071                        rundata.getParameters().getStrings("capability");
1072                    if (capabilities != null && capabilities.length > 0)
1073                    {
1074                        for (int i = 0; i < capabilities.length; i++)
1075                        {
1076                            String capability = capabilities[i];
1077
1078                            cm.removeCapability(capability);
1079                        }
1080
1081                        Registry.addEntry(registry, regEntry);
1082                        clearUserData(rundata);
1083                    }
1084
1085                    Registry.addEntry(registry, regEntry);
1086                    clearUserData(rundata);
1087                }
1088                else
1089                {
1090                    DynamicURI duri =
1091                        redirect(
1092                            rundata,
1093                            SecurityConstants.PARAM_MODE_UPDATE,
1094                            SecurityConstants.MID_UPDATE_FAILED);
1095                    rundata.setRedirectURI(duri.toString());
1096                    resetForm(rundata);
1097                }
1098            }
1099            else
1100            {
1101                DynamicURI duri =
1102                    redirect(
1103                        rundata,
1104                        SecurityConstants.PARAM_MODE_UPDATE,
1105                        SecurityConstants.MID_INVALID_ENTITY_NAME);
1106                rundata.setRedirectURI(duri.toString());
1107                resetForm(rundata);
1108
1109                logger.error(
1110                    this.getClass().getName()
1111                        + ": Failed to find registry entry while trying to remove capabilities");
1112            }
1113        }
1114        catch (Exception e)
1115        {
1116            DynamicURI duri =
1117                redirect(
1118                    rundata,
1119                    SecurityConstants.PARAM_MODE_UPDATE,
1120                    SecurityConstants.MID_UPDATE_FAILED);
1121            rundata.setRedirectURI(duri.toString());
1122            resetForm(rundata);
1123
1124            logger.error("Exception", e);
1125        }
1126    }
1127
1128    /**
1129     * Method that sets up a redirect link given the rundata, the mode, and a reason
1130     * @param rundata
1131     * @param mode
1132     * @param reason
1133     * @return
1134     * @throws TurbineException
1135     */
1136    protected DynamicURI redirect(RunData rundata, String mode, int reason)
1137        throws TurbineException
1138    {
1139        JetspeedLink link = JetspeedLinkFactory.getInstance(rundata);
1140        DynamicURI duri =
1141            link
1142                .getPaneByName(pane)
1143                .addPathInfo(SecurityConstants.PARAM_MODE, mode)
1144                .addPathInfo(SecurityConstants.PARAM_MSGID, reason);
1145
1146        String entryName = rundata.getParameters().getString(registryEntryName);
1147        if (entryName != null && entryName.length() > 0)
1148        {
1149            duri.addQueryData(registryEntryName, entryName);
1150        }
1151
1152        JetspeedLinkFactory.putInstance(link);
1153
1154        return duri;
1155    }
1156
1157    /**
1158     * Remove any data that was added to the user's temporary storage
1159     * @param rundata
1160     */
1161    protected void clearUserData(RunData rundata)
1162    {
1163        rundata.getUser().removeTemp(registryEntryName);
1164        rundata.getUser().removeTemp("title");
1165        rundata.getUser().removeTemp("description");
1166    }
1167
1168    /**
1169     * Method to reset data entered into the forms
1170     * @param rundata
1171     */
1172    protected void resetForm(RunData rundata)
1173    {
1174        String entryName = rundata.getParameters().getString(registryEntryName);
1175        String title = rundata.getParameters().getString("title");
1176        String description = rundata.getParameters().getString("description");
1177
1178        rundata.getUser().setTemp(registryEntryName, entryName);
1179        rundata.getUser().setTemp("title", title);
1180        rundata.getUser().setTemp("description", description);
1181    }
1182
1183    /**
1184     * Turns an iterator into a collection
1185     *
1186     * @param iter An iterator
1187     * @return the collection
1188     */
1189    protected Collection iteratorToCollection(Iterator iter)
1190    {
1191        Collection collection = new ArrayList ();
1192        while (iter.hasNext())
1193        {
1194            collection.add(iter.next());
1195        }
1196        return collection;
1197    }
1198}
1199

A to Z: JavaDoc & Examples

---

Daily Java News & Articles

---

Open Source Projects

---

Open Source Codes

---

Free Computer Books

---

Remove Frame

---

Popular Tags