KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > apache > jetspeed > portal > BasePortletSet


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
17 package org.apache.jetspeed.portal;
18
19 // standard java stuff
20
import java.util.Vector JavaDoc;
21 import java.util.Enumeration JavaDoc;
22
23 // Jetspeed stuff
24
import org.apache.jetspeed.om.security.JetspeedUser;
25 import org.apache.jetspeed.services.logging.JetspeedLogFactoryService;
26 import org.apache.jetspeed.services.logging.JetspeedLogger;
27 import org.apache.jetspeed.services.persistence.PersistenceManager;
28 import org.apache.jetspeed.services.persistence.PortalPersistenceException;
29 import org.apache.jetspeed.services.rundata.JetspeedRunData;
30 import org.apache.jetspeed.services.security.PortalResource;
31 import org.apache.jetspeed.services.JetspeedSecurity;
32 import org.apache.jetspeed.util.template.JetspeedLink;
33 import org.apache.jetspeed.util.template.JetspeedLinkFactory;
34 import org.apache.jetspeed.util.MetaData;
35 import org.apache.jetspeed.util.MimeType;
36
37 // turbine stuff
38
import org.apache.turbine.services.localization.Localization;
39 import org.apache.turbine.util.RunData;
40
41 // ECS stuff
42
import org.apache.ecs.ConcreteElement;
43 import org.apache.ecs.StringElement;
44
45 /**
46  * The PortletSet is basically a wrapper around an array of portlets. It provides
47  * runtime context for a set of portlets.
48  * A portlet can get its current set by calling via its PortletConfig
49  *
50  * @author <a HREF="mailto:raphael@apache.org">RaphaŽl Luta</a>
51  * @author <a HREF="mailto:burton@apache.org">Kevin A. Burton</a>
52  * @author <a HREF="mailto:taylor@apache.org">David Sean Taylor</a>
53  * @author <a HREF="mailto:morciuch@apache.org">Mark Orciuch</a>
54  * @version $Id: BasePortletSet.java,v 1.35 2004/03/29 21:38:42 taylor Exp $
55  */

56 public class BasePortletSet implements PortletSet, Portlet, PortletState
57 {
58
59     /**
60      * Static initialization of the logger for this class
61      */

62     private static final JetspeedLogger logger = JetspeedLogFactoryService.getLogger(BasePortletSet.class.getName());
63     
64     /**
65     Is this set sorted
66     */

67     private boolean dirty = false;
68
69     /**
70     The PortletConfig of this set
71     */

72     private PortletConfig pc = null;
73
74     /**
75     Provide a name for this set
76     */

77     private String JavaDoc name = null;
78
79     /**
80     Storage for the portlets assigned to this set
81     */

82     private Vector JavaDoc portlets = null;
83
84     /**
85     Controller which will layout the set
86     */

87     private PortletController controller = null;
88     
89     /**
90     The time this portlet was created.
91     */

92     private long creationTime;
93     
94     /**
95     The name of the portlet displaying info
96     */

97     private String JavaDoc info;
98
99     /**
100     The portletset id
101     */

102     private String JavaDoc id = null;
103
104     /**
105     Builds a new empty set for storing portlets
106     */

107     public BasePortletSet()
108     {
109         portlets = new Vector JavaDoc();
110         try
111         {
112             init();
113         }
114         catch (PortletException e)
115         {
116             logger.error("Exception", e);
117         }
118     }
119
120     /**
121     Builds a new empty set for storing portlets with a default controller
122     */

123     public BasePortletSet(PortletController controller)
124     {
125             portlets = new Vector JavaDoc();
126             setController(controller);
127     }
128
129     /**
130     */

131     public void init() throws PortletException
132     {
133         if (getPortletConfig() == null)
134         {
135             setPortletConfig(new BasePortletConfig());
136         }
137     }
138
139     // Set manipulation methods
140

141     /**
142     Returns the number of portlets currently stored in this set
143     */

144     public int size()
145     {
146         return portlets.size();
147     }
148
149     /**
150     Returns the portlet set as an array.
151     */

152     public Portlet[] toArray()
153     {
154         sortPortletSet();
155         Portlet[] p = new Portlet[portlets.size()];
156         portlets.copyInto(p);
157
158         return p;
159     }
160
161     /**
162     Returns the Portlet at position pos
163     */

164     public Portlet getPortletAt(int pos)
165     {
166         sortPortletSet();
167         return (Portlet) portlets.elementAt(pos);
168     }
169
170     /**
171     Returns the Portlet with the given id
172     */

173     public Portlet getPortletByID(String JavaDoc id)
174     {
175         if (portlets == null)
176         {
177             return null;
178         }
179
180         Portlet portlet = null;
181         for (int ix = 0; ix < portlets.size(); ix++)
182         {
183             portlet = (Portlet) portlets.elementAt(ix);
184             if (portlet.getID().equals(id))
185             {
186                 return portlet;
187             }
188         }
189         return null;
190     }
191
192     /**
193     Returns the Portlet with the given name
194     */

195     public Portlet getPortletByName(String JavaDoc name)
196     {
197         if (portlets == null)
198         {
199             return null;
200         }
201
202         Portlet portlet = null;
203         for (int ix = 0; ix < portlets.size(); ix++)
204         {
205             portlet = (Portlet) portlets.elementAt(ix);
206             if (portlet.getName().equals(name))
207             {
208                 return portlet;
209             }
210         }
211         return null;
212     }
213
214     /**
215     Returns the portlet set as an Enumeration
216     */

217     public Enumeration JavaDoc getPortlets()
218     {
219         sortPortletSet();
220         return portlets.elements();
221     }
222
223
224     // set content manipulation methods
225

226     /**
227     Add a portlet to this set.It updates its config to modify the current set
228     */

229     public void addPortlet(Portlet portlet)
230     {
231         addPortlet(portlet, null, -1);
232     }
233
234     /**
235     Add a portlet to this set.It updates its config to modify the current set
236     */

237     public void addPortlet(Portlet portlet, int position)
238     {
239         addPortlet(portlet, null, position);
240     }
241
242     /**
243     Add a portlet to this set.It updates its config to modify the current set
244     */

245     public void addPortlet(Portlet portlet, PortletSet.Constraints constraints)
246     {
247         addPortlet(portlet, constraints, -1);
248     }
249
250     /**
251     Add a portlet to this set.It updates its config to modify the current set
252     */

253     public void addPortlet(Portlet portlet, PortletSet.Constraints constraints, int position)
254     {
255         synchronized (portlets)
256         {
257             portlets.addElement(portlet);
258             PortletConfig pc = portlet.getPortletConfig();
259             if (pc != null)
260             {
261                 pc.setPortletSet(this);
262                 if (constraints != null)
263                 {
264                     pc.setConstraints(constraints);
265                 }
266                 if (position >= 0)
267                 {
268                     pc.setPosition(position);
269                     if (position < (portlets.size() - 1))
270                     {
271                         this.dirty = true;
272                     }
273                 }
274             }
275         }
276     }
277
278     // set properties setters/getters
279

280     /**
281     Return the current controller for this set
282     */

283     public PortletController getController()
284     {
285         return this.controller;
286     }
287
288     /**
289     Set the controller for this set
290     */

291     public synchronized void setController(PortletController controller)
292     {
293         this.controller = controller;
294         controller.setPortlets(this);
295     }
296
297
298     // portlet interface implementation
299

300     /**
301     */

302     public ConcreteElement getContent(RunData rundata)
303     {
304         ConcreteElement content = null;
305         PortletController controller = getController();
306         PortalResource portalResource = new PortalResource(this);
307
308         try
309         {
310             JetspeedLink jsLink = JetspeedLinkFactory.getInstance(rundata);
311             portalResource.setOwner(jsLink.getUserName());
312             JetspeedLinkFactory.putInstance(jsLink);
313         }
314         catch (Exception JavaDoc e)
315         {
316             logger.warn(e.toString(), e);
317             portalResource.setOwner(null);
318         }
319
320         if (!JetspeedSecurity.checkPermission((JetspeedUser) rundata.getUser(),
321                   portalResource, JetspeedSecurity.PERMISSION_VIEW))
322         {
323             if ( logger.isDebugEnabled() )
324             {
325                 logger.debug("Unauthorized access by user \"" + rundata.getUser().getUserName() + "\"");
326             }
327             // Clear any portlets that exist in this set
328
if (this.portlets != null)
329             {
330                 this.portlets.clear();
331             }
332             return new StringElement(Localization.getString(rundata, "SECURITY_NO_ACCESS"));
333         }
334         else
335         {
336             if ( logger.isDebugEnabled() )
337             {
338                 logger.debug("User \"" + rundata.getUser().getUserName() + "\" is authorized to portlet set " + getID());
339             }
340         }
341             
342         if (controller == null)
343         {
344             Portlet p = getPortletAt(0);
345     
346             if (p != null)
347             {
348                 content = p.getContent(rundata);
349             }
350         }
351         else
352         {
353             content = controller.getContent(rundata);
354         }
355
356         if (content == null)
357         {
358             content = new ConcreteElement();
359         }
360         
361         return content;
362     }
363
364     /**
365     */

366     public String JavaDoc getName()
367     {
368         if (name == null)
369         {
370             return this.getClass().getName();
371         }
372
373         return name;
374     }
375
376     /**
377     */

378     public void setName(String JavaDoc name)
379     {
380         this.name = name;
381     }
382
383     /**
384     */

385     public PortletConfig getPortletConfig()
386     {
387         return this.pc;
388     }
389
390     /**
391     */

392     public void setPortletConfig(PortletConfig pc)
393     {
394         this.pc = pc;
395     }
396
397     /**
398     */

399     public String JavaDoc getDescription()
400     {
401         if (getPortletConfig() != null)
402         {
403             if (getPortletConfig().getMetainfo() != null)
404             {
405                 return getPortletConfig().getMetainfo().getDescription();
406             }
407         }
408
409         return null;
410     }
411
412     /**
413      * Getter for property description.
414      * @return Name of portlet description.
415      */

416     public String JavaDoc getDescription(String JavaDoc instanceDescription)
417     {
418       if (instanceDescription != null)
419       {
420           return instanceDescription;
421       }
422       return getDescription();
423     }
424
425     /**
426     */

427     public void setDescription(String JavaDoc description)
428     {
429         PortletConfig pc = getPortletConfig();
430         if (pc == null)
431         {
432             pc = new BasePortletConfig();
433             setPortletConfig(pc);
434         }
435
436         MetaData meta = pc.getMetainfo();
437         if (meta == null)
438         {
439             meta = new MetaData();
440             pc.setMetainfo(meta);
441         }
442
443         meta.setDescription(description);
444     }
445
446     /**
447      * Setter for property image.
448      */

449     public void setImage(String JavaDoc instanceImage)
450     {
451     }
452      
453     /**
454     */

455     public String JavaDoc getImage()
456     {
457         if (getPortletConfig() != null)
458         {
459             if (getPortletConfig().getMetainfo() != null)
460             {
461                 return getPortletConfig().getMetainfo().getImage();
462             }
463         }
464
465         return null;
466     }
467     
468     /**
469      * Getter for property image.
470      * @return Name of portlet image, icon. The name is expected to be in the form of a URL.
471      */

472     public String JavaDoc getImage(String JavaDoc instanceImage)
473     {
474       if (instanceImage != null)
475       {
476           return instanceImage;
477       }
478       return getImage();
479     }
480
481     /**
482     */

483     public String JavaDoc getTitle()
484     {
485         if (getPortletConfig() != null)
486         {
487             if (getPortletConfig().getMetainfo() != null)
488             {
489                 return getPortletConfig().getMetainfo().getTitle();
490             }
491         }
492
493         return null;
494     }
495     
496
497     /** Get a title for this instance of the portlet. This method is called
498      * from the context variable portlet_instance and from PortletInstance
499      *
500      * If you wish to append to the title, then you code should look like
501      * getTitle( String instanceTitle)
502      * {
503      * return super.getTitle( instanceTitle) + " - Appened title text";
504      * }
505      *
506      * @param instanceTitle Title from PSML
507      */

508     public String JavaDoc getTitle(String JavaDoc instanceTitle)
509     {
510         if (instanceTitle != null)
511         {
512             return instanceTitle;
513         }
514         return getTitle();
515     }
516
517     /**
518     */

519     public void setTitle(String JavaDoc title)
520     {
521
522         PortletConfig pc = getPortletConfig();
523         if (pc == null)
524         {
525             pc = new BasePortletConfig();
526             setPortletConfig(pc);
527         }
528
529         MetaData meta = pc.getMetainfo();
530         if (meta == null)
531         {
532             meta = new MetaData();
533             pc.setMetainfo(meta);
534         }
535
536         meta.setTitle(title);
537     }
538
539     /**
540     */

541     public boolean getAllowEdit(RunData rundata)
542     {
543         return true;
544     }
545
546     /**
547      */

548      public boolean getAllowView(RunData rundata)
549      {
550          return true;
551      }
552     
553     /**
554     */

555     public boolean getAllowMaximize(RunData rundata)
556     {
557         return false;
558     }
559
560     // private util methods
561

562     /**
563      * Sort the portlets according to Layout position
564      */

565     public final void sortPortletSet()
566     {
567         if (!this.dirty)
568         {
569             return;
570         }
571         
572         synchronized (portlets)
573         {
574             for (int i = 0; i < portlets.size(); i++)
575             {
576                 
577                 Portlet p = (Portlet) portlets.elementAt(i);
578                 int pos = p.getPortletConfig().getPosition();
579                 if ((pos >= 0) && (pos != i) && pos < portlets.size())
580                 {
581                     portlets.removeElementAt(i);
582                     portlets.insertElementAt(p, pos);
583                 }
584             }
585                     
586             this.dirty = false;
587         }
588     }
589
590     /**
591     @see Portlet#getCreationTime()
592     */

593     public long getCreationTime()
594     {
595         return this.creationTime;
596     }
597     
598     /**
599     @see Portlet#setCreationTime
600     */

601     public void setCreationTime(long creationTime)
602     {
603         this.creationTime = creationTime;
604     }
605     
606     /**
607      Method retruns true if at least one of the portlets of the portletset
608      fits the requested MimeTyp. Otherwise it retruns false.
609     */

610     public boolean supportsType(MimeType mimeType)
611     {
612         Enumeration JavaDoc portlets = this.getPortlets();
613         while (portlets.hasMoreElements())
614         {
615             Portlet p = (Portlet) portlets.nextElement();
616             if (p.supportsType(mimeType))
617             {
618                 return true;
619             }
620         }
621
622         return false;
623     }
624
625     // PortletState Interface implementation
626

627     /**
628      * Implements the default close behavior: any authenticated user may
629      * remove a portlet from his page
630      *
631      * @param rundata the RunData object for the current request
632      */

633     public boolean allowClose(RunData rundata)
634     {
635         return false;
636     }
637
638     /**
639      * Returns true if this portlet is currently closed
640      */

641     public boolean isClosed(RunData data)
642     {
643         return false;
644     }
645
646     /**
647      * Toggles the portlet state between closed and normal
648      *
649      * @param minimized the new portlet state
650      * @param data the RunData for this request
651      */

652     public void setClosed(boolean close, RunData data)
653     {
654         // empty
655
}
656
657     /**
658      * Implements the default info behavior: any authenticated user may
659      * get information on a portlet
660      *
661      * @param rundata the RunData object for the current request
662      */

663     public boolean allowInfo(RunData rundata)
664     {
665         return false;
666     }
667
668     /**
669      * Implements the default print friendly format behavior: not
670      * available for the portlet set
671      *
672      * @param rundata the RunData object for the current request
673      */

674     public boolean allowPrintFriendly(RunData rundata)
675     {
676         return false;
677     }
678
679     /**
680      * Implements the default customize behavior: any authenticated user may
681      * customize a portlet
682      *
683      * @param rundata the RunData object for the current request
684      */

685     public boolean allowCustomize(RunData rundata)
686     {
687         PortalResource portalResource = new PortalResource(this);
688         try
689         {
690             JetspeedLink jsLink = JetspeedLinkFactory.getInstance(rundata);
691             portalResource.setOwner(jsLink.getUserName());
692             JetspeedLinkFactory.putInstance(jsLink);
693         }
694         catch (Exception JavaDoc e)
695         {
696             logger.warn(e.toString(), e);
697             portalResource.setOwner(null);
698         }
699         JetspeedRunData jdata = (JetspeedRunData) rundata;
700         return JetspeedSecurity.checkPermission((JetspeedUser) jdata.getUser(),
701                                                 portalResource,
702                                                 JetspeedSecurity.PERMISSION_CUSTOMIZE);
703     }
704
705     /**
706      * Implements the default maximize behavior: any authenticated user may
707      * maximize a portlet
708      *
709      * @param rundata the RunData object for the current request
710      */

711     public boolean allowMaximize(RunData rundata)
712     {
713         return false;
714     }
715
716     /**
717      * Implements the default info behavior: any authenticated user may
718      * minimize a portlet
719      *
720      * @param rundata the RunData object for the current request
721      */

722     public boolean allowMinimize(RunData rundata)
723     {
724         return false;
725     }
726
727     /**
728      * Returns true if this portlet is currently minimized
729      */

730     public boolean isMinimized(RunData rundata)
731     {
732         return false;
733     }
734
735     /**
736     Change the portlet visibility state ( minimized <-> normal )
737
738     @param minimize True if the portlet change to minimized
739     @param rundata A RunData object
740     */

741     public void setMinimized(boolean minimize, RunData rundata)
742     {
743         // empty
744
}
745
746     //Portlet interface
747

748    /**
749      * Retrieve a portlet attribute from persistent storage
750      *
751      * @param attrName The attribute to retrieve
752      * @param attrDefValue The value if the attr doesn't exists
753      * @param rundata The RunData object for the current request
754      * @return The attribute value
755      */

756     public String JavaDoc getAttribute(String JavaDoc attrName, String JavaDoc attrDefValue, RunData rundata)
757     {
758         // return attrDefValue;
759

760         String JavaDoc attrValue = null ;
761
762         PortletInstance instance = PersistenceManager.getInstance(this, rundata);
763         attrValue = instance.getAttribute(attrName, attrDefValue);
764
765         return attrValue;
766         
767     }
768
769     /**
770      * Stores a portlet attribute in persistent storage
771      *
772      * @param attrName The attribute to retrieve
773      * @paarm attrValue The value to store
774      * @param rundata The RunData object for the current request
775      */

776     public void setAttribute(String JavaDoc attrName, String JavaDoc attrValue, RunData rundata)
777     {
778         try
779         {
780             PortletInstance instance = PersistenceManager.getInstance(this, rundata);
781             instance.setAttribute(attrName, attrValue);
782             PersistenceManager.store(instance);
783         }
784         catch (PortalPersistenceException e)
785         {
786             logger.error("Exception while setting attribute " + attrName + " for portlet " + getName(), e);
787         }
788     }
789
790     /**
791      * Gets the portlet instance associated with this portlet.
792      *
793      * @return PortletInstance
794      */

795     public PortletInstance getInstance(RunData rundata)
796     {
797        return PersistenceManager.getInstance(this, rundata);
798     }
799
800
801     public String JavaDoc getID()
802     {
803         return id;
804     }
805
806     public void setID(String JavaDoc id)
807     {
808         this.id = id;
809     }
810
811     /**
812     * @return true if the portlet does its own customization
813     */

814     public boolean providesCustomization()
815     {
816         return false;
817     }
818     
819     /** Returns TRUE if the title bar in should be displayed. The title bar includes
820      * the portlet title and action buttons. This
821      *
822      * @param rundata The RunData object for the current request
823      */

824     public boolean isShowTitleBar(RunData rundata)
825     {
826         return true;
827     }
828 }
829
Popular Tags