KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > apache > roller > ui > rendering > velocity > deprecated > OldWeblogPageModel


1 /*
2  * Licensed to the Apache Software Foundation (ASF) under one or more
3  * contributor license agreements. The ASF licenses this file to You
4  * under the Apache License, Version 2.0 (the "License"); you may not
5  * 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. For additional information regarding
15  * copyright in this work, please see the NOTICE file in the top level
16  * directory of this distribution.
17  */

18
19 package org.apache.roller.ui.rendering.velocity.deprecated;
20
21 import java.util.ArrayList JavaDoc;
22 import java.util.Calendar JavaDoc;
23 import java.util.Collection JavaDoc;
24 import java.util.Collections JavaDoc;
25 import java.util.Date JavaDoc;
26 import java.util.HashMap JavaDoc;
27 import java.util.Iterator JavaDoc;
28 import java.util.List JavaDoc;
29 import java.util.Map JavaDoc;
30 import java.util.TimeZone JavaDoc;
31 import javax.servlet.http.HttpServletRequest JavaDoc;
32 import org.apache.commons.logging.Log;
33 import org.apache.commons.logging.LogFactory;
34 import org.apache.roller.RollerException;
35 import org.apache.roller.config.RollerRuntimeConfig;
36 import org.apache.roller.model.BookmarkManager;
37 import org.apache.roller.model.RefererManager;
38 import org.apache.roller.model.RollerFactory;
39 import org.apache.roller.pojos.Template;
40 import org.apache.roller.model.UserManager;
41 import org.apache.roller.model.WeblogManager;
42 import org.apache.roller.pojos.CommentData;
43 import org.apache.roller.pojos.FolderData;
44 import org.apache.roller.pojos.RefererData;
45 import org.apache.roller.pojos.WeblogCategoryData;
46 import org.apache.roller.pojos.WeblogEntryData;
47 import org.apache.roller.pojos.WebsiteData;
48 import org.apache.roller.pojos.wrapper.CommentDataWrapper;
49 import org.apache.roller.pojos.wrapper.FolderDataWrapper;
50 import org.apache.roller.pojos.wrapper.RefererDataWrapper;
51 import org.apache.roller.pojos.wrapper.TemplateWrapper;
52 import org.apache.roller.pojos.wrapper.WeblogCategoryDataWrapper;
53 import org.apache.roller.pojos.wrapper.WeblogEntryDataWrapper;
54 import org.apache.roller.pojos.wrapper.WebsiteDataWrapper;
55 import org.apache.roller.ui.core.RollerSession;
56 import org.apache.roller.util.DateUtil;
57 import org.apache.commons.lang.StringUtils;
58
59
60 /**
61  * Provides Roller page templates with access to Roller domain model objects.
62  */

63 public class OldWeblogPageModel {
64     public final static String JavaDoc VELOCITY_NULL = "nil";
65     
66     protected static Log mLogger =
67             LogFactory.getFactory().getInstance(OldWeblogPageModel.class);
68     
69     private BookmarkManager mBookmarkMgr = null;
70     private WeblogManager mWeblogMgr = null;
71     private UserManager mUserMgr = null;
72     private RefererManager mRefererMgr = null;
73     
74     private Map JavaDoc mCategories = new HashMap JavaDoc();
75     private HashMap JavaDoc mPageMap = new HashMap JavaDoc();
76     private HttpServletRequest JavaDoc mRequest = null;
77     private WebsiteData mWebsite = null;
78     private WeblogEntryData mEntry = null;
79     private WeblogCategoryData mCategory = null;
80     private Date JavaDoc mDate = null;
81     private boolean mIsDaySpecified = false;
82     private boolean mIsMonthSpecified = false;
83     private String JavaDoc mLocale = null;
84     private WeblogEntryDataWrapper mNextEntry = null;
85     private WeblogEntryDataWrapper mPreviousEntry = null;
86     private WeblogEntryDataWrapper mLastEntry = null;
87     private WeblogEntryDataWrapper mFirstEntry = null;
88     
89     //------------------------------------------------------------------------
90

91     /** init() must be called to complete construction */
92     public OldWeblogPageModel() {}
93     
94     public String JavaDoc getModelName() {
95         return "pageModel";
96     }
97     
98     /**
99      * Initialize PageModel and allow PageModel to initialized VelocityContext.
100      */

101     public void init(HttpServletRequest JavaDoc request,
102             WebsiteData website,
103             WeblogEntryData entry,
104             WeblogCategoryData category,
105             Date JavaDoc date,
106             boolean isDay,
107             boolean isMonth,
108             String JavaDoc locale) {
109         
110         mRequest = request;
111         
112         // data we'll need in the methods
113
mWebsite = website;
114         mEntry = entry;
115         mCategory = category;
116         mDate = date;
117         mIsDaySpecified = isDay;
118         mIsMonthSpecified = isMonth;
119         mLocale = locale;
120         
121         try {
122             mBookmarkMgr = RollerFactory.getRoller().getBookmarkManager();
123             mRefererMgr = RollerFactory.getRoller().getRefererManager();
124             mUserMgr = RollerFactory.getRoller().getUserManager();
125             mWeblogMgr = RollerFactory.getRoller().getWeblogManager();
126             
127             // Preload what we can for encapsulation. What we cannot preload we
128
// will use the Managers later to fetch.
129

130             // Get the pages, put into context & load map
131
if (mWebsite != null) {
132                 
133                 // Get the pages, put into context & load map
134
List JavaDoc pages = mWebsite.getPages();
135                 Iterator JavaDoc pageIter = pages.iterator();
136                 while (pageIter.hasNext()) {
137                     Template page = (Template) pageIter.next();
138                     mPageMap.put(page.getName(), TemplateWrapper.wrap(page));
139                 }
140             }
141             
142         } catch (RollerException e) {
143             mLogger.error("PageModel Roller get*Manager Exception", e);
144         }
145     }
146     
147     //------------------------------------------------------------------------
148

149     /** Encapsulates folder.getBookmarks() & sorting */
150     public Collection JavaDoc getBookmarks(FolderDataWrapper folder) {
151         Collection JavaDoc bookmarks = null;
152         if (folder != null) {
153             mLogger.debug("Getting bookmarks for folder : "+folder.getName());
154
155             // since we already have a wrapped pojo we know the output
156
// will be wrapped as well :)
157
bookmarks = folder.getBookmarks();
158
159             // TODO: need to setup new BookmarkWrapperComparator
160
//List mBookmarks = new ArrayList(bookmarks);
161
//Collections.sort( mBookmarks, new BookmarkComparator() );
162
}
163         return bookmarks;
164     }
165     
166     //------------------------------------------------------------------------
167

168     /** Get top level bookmark folders. */
169     public Collection JavaDoc getTopLevelFolders() {
170         List JavaDoc tops = null;
171         try {
172             Collection JavaDoc mTops = mBookmarkMgr.getRootFolder(
173                     mUserMgr.getWebsiteByHandle(mWebsite.getHandle())).getFolders();
174             
175             // wrap pojos
176
tops = new ArrayList JavaDoc(mTops.size());
177             Iterator JavaDoc it = mTops.iterator();
178             int i=0;
179             while(it.hasNext()) {
180                 tops.add(i, FolderDataWrapper.wrap((FolderData) it.next()));
181                 i++;
182             }
183         } catch (RollerException e) {
184             tops = new ArrayList JavaDoc();
185         }
186         return tops;
187     }
188     
189     //------------------------------------------------------------------------
190

191     /** Get number of approved non-spam comments for entry */
192     public int getCommentCount(String JavaDoc entryId) {
193         return getCommentCount(entryId, true, true);
194     }
195     
196     /** Get number of approved non-spam comments for entry */
197     public int getCommentCount(String JavaDoc entryId, boolean noSpam, boolean approvedOnly) {
198         try {
199             WeblogEntryData entry = mWeblogMgr.getWeblogEntry(entryId);
200             return entry.getComments(noSpam, approvedOnly).size();
201         } catch (RollerException alreadyLogged) {}
202         return 0;
203     }
204     
205     //------------------------------------------------------------------------
206

207     /** Get comments for weblog entry specified by request */
208     public List JavaDoc getComments(WeblogEntryDataWrapper entry) {
209         return getComments(entry, true, true);
210     }
211     
212     /** Get comments for weblog entry specified by request */
213     public List JavaDoc getComments(WeblogEntryDataWrapper wrapper, boolean noSpam, boolean approvedOnly) {
214         WeblogEntryData entry = wrapper.getPojo();
215         List JavaDoc comments = new ArrayList JavaDoc();
216         List JavaDoc unwrappped = entry.getComments(noSpam, approvedOnly);
217         comments = new ArrayList JavaDoc(unwrappped.size());
218         Iterator JavaDoc it = unwrappped.iterator();
219         while(it.hasNext()) {
220             comments.add(CommentDataWrapper.wrap((CommentData)it.next()));
221         }
222         return comments;
223     }
224     
225     //------------------------------------------------------------------------
226

227     /** Encapsulates RefererManager */
228     public int getDayHits() {
229         try {
230             return mRefererMgr.getDayHits(mWebsite);
231         } catch (RollerException e) {
232             mLogger.error("PageModel getDayHits()", e);
233         }
234         return 0;
235     }
236     
237     //------------------------------------------------------------------------
238

239     /** Encapsulates BookmarkManager.getFolder() */
240     public FolderDataWrapper getFolder(String JavaDoc folderPath) {
241         try {
242             return FolderDataWrapper.wrap(
243                     mBookmarkMgr.getFolder(
244                     mUserMgr.getWebsiteByHandle(mWebsite.getHandle()), folderPath));
245         } catch (RollerException e) {
246             mLogger.error("PageModel getFolder()", e);
247         }
248         return null;
249     }
250     
251     //------------------------------------------------------------------------
252

253     /** Encapsulates UserManager.getPageByName() */
254     public TemplateWrapper getUsersPageByName(WebsiteDataWrapper wrapper, String JavaDoc pageName) {
255         WebsiteData website = wrapper.getPojo();
256         TemplateWrapper page = null;
257         try {
258             if (website == null)
259                 throw new NullPointerException JavaDoc("website is null");
260             
261             if (pageName == null)
262                 throw new NullPointerException JavaDoc("pageName is null");
263             
264             page = TemplateWrapper.wrap(website.getPageByName(pageName));
265         } catch (NullPointerException JavaDoc npe) {
266             mLogger.warn(npe.getMessage());
267         } catch (RollerException e) {
268             mLogger.error("ERROR getting user's page by name: " + e.getMessage(),e);
269         }
270         return page;
271     }
272     
273     //------------------------------------------------------------------------
274

275     /** Encapsulates UserManager.getPageByName() */
276     public TemplateWrapper getPageByName(String JavaDoc pageName) {
277         return (TemplateWrapper) mPageMap.get(pageName);
278     }
279     
280     //------------------------------------------------------------------------
281

282     /** Encapsulates UserManager.getPageByName() */
283     public String JavaDoc getPageIdByName(String JavaDoc pageName) {
284         mLogger.debug("looking up page ["+pageName+"]");
285         
286         String JavaDoc template_id = null;
287         
288         try {
289             Template pd = mWebsite.getPageByName(pageName);
290             if(pd != null) {
291                 template_id = pd.getId();
292             }
293         } catch(Exception JavaDoc e) {
294             mLogger.error(e);
295         }
296         
297         mLogger.debug("returning template id ["+template_id+"]");
298         
299         return template_id;
300     }
301     
302     //------------------------------------------------------------------------
303

304     /**
305      * Get collection of user pages.
306      * @return
307      */

308     public Object JavaDoc getPages() {
309         return mPageMap.values();
310     }
311     
312     //------------------------------------------------------------------------
313

314     /**
315      * Returns a map of up to 100 recent weblog entries for the user and day
316      * specified in the request, filtered by the category specified by the
317      * request, limited by the 'maxEntries' argument, and sorted by reverse
318      * chronological order.
319      *
320      * <p>This method will look for a category name in the following places
321      * and in the following order:</p>
322      * <ul>
323      * <li>The request via RollerRequest.getWeblogCategory().</li>
324      * <li>The categoryName argument to this method.</li>
325      * <li>The default category for the website specified by the request via
326      * RollerRequest.getWebsite().getDefaultCategory().</li>
327      * <li></li>
328      * </ul>
329      *
330      * @param maxEntries Maximum number of entries to be returned (only applies
331      * if specific day not specified).
332      * @param catName Only return entries from this category and it's
333      * subcategories. If null, returns all categories of entry
334      * @return Map of Lists of WeblogEntryData, keyed by 8-char date
335      * strings.
336      */

337     public Map JavaDoc getRecentWeblogEntries(int maxEntries, String JavaDoc catName) {
338         if (VELOCITY_NULL.equals(catName)) catName = null;
339         Map JavaDoc ret = new HashMap JavaDoc();
340         try {
341             // If request specifies a category, then use that
342
String JavaDoc catParam = null;
343             if (mCategory != null) {
344                 catParam = mCategory.getPath();
345             } else if (catName != null) {
346                 // use category argument instead
347
catParam = catName;
348             } else if (mWebsite != null) // MAIN
349
{
350                 catParam = mWebsite.getDefaultCategory().getPath();
351                 if (catParam.equals("/")) {
352                     catParam = null;
353                 }
354             }
355             
356             Calendar JavaDoc cal = null;
357             if (mWebsite != null) {
358                 TimeZone JavaDoc tz = mWebsite.getTimeZoneInstance();
359                 cal = Calendar.getInstance(tz);
360             } else {
361                 cal = Calendar.getInstance();
362             }
363             int limit = mWebsite.getEntryDisplayCount();
364             Date JavaDoc startDate = null;
365             Date JavaDoc endDate = mDate;
366             if (endDate == null) endDate = new Date JavaDoc();
367             if (mIsDaySpecified) {
368                 // URL specified a specific day
369
// so get entries for that day
370
endDate = DateUtil.getEndOfDay(endDate, cal);
371                 startDate = DateUtil.getStartOfDay(endDate, cal);
372                 // and get them ALL, no limit
373
limit = -1;
374             } else if (mIsMonthSpecified) {
375                 endDate = DateUtil.getEndOfMonth(endDate, cal);
376             }
377             Map JavaDoc mRet = RollerFactory.getRoller().getWeblogManager().getWeblogEntryObjectMap(
378                     mWebsite,
379                     startDate, // startDate
380
endDate, // endDate
381
catParam, // catName
382
WeblogEntryData.PUBLISHED, // status
383
mLocale, 0, limit);
384             
385             // need to wrap pojos
386
java.util.Date JavaDoc key = null;
387             Iterator JavaDoc days = mRet.keySet().iterator();
388             while(days.hasNext()) {
389                 key = (java.util.Date JavaDoc)days.next();
390                 
391                 // now we need to go through each entry in a day and wrap
392
List JavaDoc wrappedEntries = new ArrayList JavaDoc();
393                 List JavaDoc entries = (List JavaDoc) mRet.get(key);
394                 for(int i=0; i < entries.size(); i++) {
395                     wrappedEntries.add(i,
396                          WeblogEntryDataWrapper.wrap((WeblogEntryData)entries.get(i)));
397                 }
398                 mRet.put(key, wrappedEntries);
399             }
400             
401             ret = mRet;
402             
403             setFirstAndLastEntries( ret );
404         } catch (Exception JavaDoc e) {
405             mLogger.error("PageModel getRecentWeblogEntries()", e);
406         }
407         return ret;
408     }
409     
410     //------------------------------------------------------------------------
411

412     /**
413      * Pull the last WeblogEntryData out of the Map.
414      * @param ret
415      */

416     private void setFirstAndLastEntries(Map JavaDoc days) {
417         int numDays = days.keySet().size();
418         if (numDays > 0) // there is at least one day
419
{
420             // get first entry in map
421
Object JavaDoc[] keys = days.keySet().toArray(new Object JavaDoc[numDays]);
422             List JavaDoc vals = (List JavaDoc)days.get( keys[0] );
423             int valSize = vals.size();
424             if (valSize > 0) {
425                 mFirstEntry = (WeblogEntryDataWrapper)vals.get(0);
426             }
427             
428             // get last entry in map
429
vals = (List JavaDoc)days.get( keys[--numDays] );
430             valSize = vals.size();
431             if (valSize > 0) {
432                 mLastEntry = (WeblogEntryDataWrapper)vals.get(--valSize);
433             }
434         }
435     }
436     
437     //------------------------------------------------------------------------
438

439     /**
440      * Returns list of recent weblog entries for the user and day specified in
441      * the request, filtered by the category specified by the request, limited
442      * by the 'maxEntries' argument, and sorted by reverse chronological order.
443      *
444      * <p>This method will look for a category name in the same places and
445      * same order as does the getRecentWeblogEntries() method.</p>
446      *
447      * @param maxEntries Maximum number of entries to be returned.
448      * @param categoryName Only return entries from this category and it's
449      * subcategories. If null, returns all categories of entry.
450      * @return List of WeblogEntryData objects in revese chronological order.
451      */

452     public List JavaDoc getRecentWeblogEntriesArray(int maxEntries, String JavaDoc categoryName) {
453         if (VELOCITY_NULL.equals(categoryName)) categoryName = null;
454         List JavaDoc ret = new ArrayList JavaDoc();
455         try {
456             Date JavaDoc day = mDate;
457             if (day == null) day = new Date JavaDoc();
458             
459             // If request specifies a category, then use that
460
String JavaDoc catParam = null;
461             if (mCategory != null) {
462                 catParam = mCategory.getPath();
463             } else if (categoryName != null) {
464                 // use category argument instead
465
catParam = categoryName;
466             } else if (mWebsite != null) // MAIN
467
{
468                 catParam = mWebsite.getDefaultCategory().getPath();
469                 if (catParam.equals("/")) {
470                     catParam = null;
471                 }
472             }
473             WeblogManager mgr = RollerFactory.getRoller().getWeblogManager();
474             
475             //ret = mgr.getRecentWeblogEntriesArray(
476
//name, day, catParam, maxEntries, true );
477

478             List JavaDoc mEntries = mgr.getWeblogEntries(
479                     mWebsite,
480                     null,
481                     null, // startDate
482
day, // endDate
483
catParam, // catName
484
WeblogEntryData.PUBLISHED, // status
485
null, // sortby (null for pubTime)
486
mLocale, 0, mWebsite.getEntryDisplayCount());
487             
488             // wrap pojos
489
ret = new ArrayList JavaDoc(mEntries.size());
490             Iterator JavaDoc it = mEntries.iterator();
491             int i=0;
492             while(it.hasNext()) {
493                 ret.add(i, WeblogEntryDataWrapper.wrap((WeblogEntryData) it.next()));
494                 i++;
495             }
496         } catch (Exception JavaDoc e) {
497             mLogger.error("PageModel getRecentWeblogEntries()", e);
498         }
499         return ret;
500     }
501     
502     //------------------------------------------------------------------------
503

504     /** Encapsulates RefererManager **/
505     public List JavaDoc getReferers(String JavaDoc date) {
506         date = date.trim();
507         ArrayList JavaDoc referers = new ArrayList JavaDoc();
508         try {
509             List JavaDoc refs =
510                     mRefererMgr.getReferersToDate(mWebsite, date);
511             RollerSession rses =
512                     RollerSession.getRollerSession(mRequest);
513             
514             for (Iterator JavaDoc rdItr = refs.iterator(); rdItr.hasNext();) {
515                 RefererData referer = (RefererData) rdItr.next();
516                 String JavaDoc title =referer.getTitle();
517                 String JavaDoc excerpt = referer.getExcerpt();
518                 if ( StringUtils.isNotEmpty(title)
519                 && StringUtils.isNotEmpty(excerpt) ) {
520                     if ( referer.getVisible().booleanValue()
521                     || rses.isUserAuthorizedToAdmin(referer.getWebsite()) ) {
522                         referers.add(RefererDataWrapper.wrap(referer));
523                     }
524                 }
525             }
526             
527         } catch (Exception JavaDoc e) {
528             mLogger.error("PageModel getReferersToDate() fails with URL"
529                     + mRequest.getRequestURL(), e);
530         }
531         return referers;
532     }
533     
534     /** Encapsulates RefererManager **/
535     public List JavaDoc getEntryReferers(WeblogEntryDataWrapper entry) {
536         ArrayList JavaDoc referers = new ArrayList JavaDoc();
537         try {
538             List JavaDoc refs = mRefererMgr.getReferersToEntry(entry.getId());
539             RollerSession rses =
540                RollerSession.getRollerSession(mRequest);
541             
542             for (Iterator JavaDoc rdItr = refs.iterator(); rdItr.hasNext();) {
543                 RefererData referer = (RefererData) rdItr.next();
544                 String JavaDoc title =referer.getTitle();
545                 String JavaDoc excerpt = referer.getExcerpt();
546                 if ( StringUtils.isNotEmpty(title)
547                 && StringUtils.isNotEmpty(excerpt) ) {
548                     if (referer.getVisible().booleanValue()
549                     || rses.isUserAuthorizedToAdmin(referer.getWebsite()) ) {
550                         referers.add(RefererDataWrapper.wrap(referer));
551                     }
552                 }
553             }
554             
555         } catch (Exception JavaDoc e) {
556             mLogger.error("PageModel getReferersToDate() fails with URL"
557                     + mRequest.getRequestURL(), e);
558         }
559         return referers;
560     }
561     
562     //------------------------------------------------------------------------
563

564     /** Encapsulates RefererManager */
565     public List JavaDoc getTodaysReferers() {
566          return mWebsite.getTodaysReferrers();
567     }
568     
569     //------------------------------------------------------------------------
570

571     /** Encapsulates RefererManager */
572     public int getTotalHits() {
573         return mWebsite.getTodaysHits();
574     }
575     
576     //------------------------------------------------------------------------
577
/**
578      * Returns most recent update time of collection of weblog entries.
579      * @param weblogEntries Collection of weblog entries.
580      * @return Most recent update time.
581      */

582     public static Date JavaDoc getUpdateTime( ArrayList JavaDoc weblogEntries ) {
583         Date JavaDoc updateTime = null;
584         Iterator JavaDoc iter = weblogEntries.iterator();
585         while (iter.hasNext()) {
586             // NOTE: this will need to be WeblogEntryDataWrapper
587
WeblogEntryData wd = (WeblogEntryData)iter.next();
588             if ( updateTime == null ) {
589                 updateTime = wd.getUpdateTime();
590             }
591             //else if ( updateTime.compareTo(wd.getUpdateTime()) < 0 )
592
else if (updateTime.before( wd.getUpdateTime() )) {
593                 updateTime = wd.getUpdateTime();
594             }
595         }
596         return updateTime;
597     }
598     
599     //------------------------------------------------------------------------
600

601     /** Encapsulates WeblogManager.getWeblogCategories() */
602     public List JavaDoc getWeblogCategories(String JavaDoc categoryName) {
603         List JavaDoc ret = null;
604         if (VELOCITY_NULL.equals(categoryName)) categoryName = null;
605         
606         // Make sure we have not already fetched this category.
607
if (categoryName != null) {
608             ret = (List JavaDoc)mCategories.get(categoryName);
609         } else {
610             ret = (List JavaDoc)mCategories.get("zzz_null_zzz");
611         }
612         
613         if (null == ret) {
614             try {
615                 WeblogCategoryData category = null;
616                 if (categoryName != null) {
617                     category = mWeblogMgr.getWeblogCategoryByPath(
618                             mWebsite, null, categoryName);
619                 } else {
620                     category = mWebsite.getDefaultCategory();
621                 }
622                 
623                 List JavaDoc mRet = category.getWeblogCategories();
624                 
625                 // wrap pojos
626
ret = new ArrayList JavaDoc(mRet.size());
627                 Iterator JavaDoc it = mRet.iterator();
628                 int i=0;
629                 while(it.hasNext()) {
630                     ret.add(i, WeblogCategoryDataWrapper.wrap((WeblogCategoryData)it.next()));
631                     i++;
632                 }
633                 if (categoryName != null) {
634                     mCategories.put(categoryName, ret);
635                 } else {
636                     mCategories.put("zzz_null_zzz", ret);
637                 }
638             } catch (RollerException e) {
639                 mLogger.error(e);
640             }
641         }
642         return ret;
643     }
644     
645     //------------------------------------------------------------------------
646

647     /** Encapsulates RollerRequest.getWeblogEntry() */
648     public WeblogEntryDataWrapper getWeblogEntry() {
649         
650         if(mEntry != null && mEntry.getStatus().equals(WeblogEntryData.PUBLISHED))
651             return WeblogEntryDataWrapper.wrap(mEntry);
652         else
653             return null;
654     }
655     
656     //------------------------------------------------------------------------
657

658     /**
659      * Get the next occurring Entry.
660      */

661     public WeblogEntryDataWrapper getNextEntry() {
662         WeblogEntryDataWrapper currentEntry = getWeblogEntry();
663         if (mFirstEntry != null) currentEntry = mFirstEntry;
664         if (mNextEntry == null && currentEntry != null) {
665             String JavaDoc catName = null;
666             if (mCategory != null) {
667                 catName = mCategory.getName();
668             }
669             try {
670                 WeblogEntryData nextEntry =
671                         mWeblogMgr.getNextEntry(currentEntry.getPojo(), catName, mLocale);
672                 
673                 if(nextEntry != null)
674                     mNextEntry = WeblogEntryDataWrapper.wrap(nextEntry);
675                 
676                 // make sure that mNextEntry is not published to future
677
if (mNextEntry != null &&
678                         mNextEntry.getPubTime().after( new Date JavaDoc() )) {
679                     mNextEntry = null;
680                 }
681             } catch (RollerException e) {
682                 mLogger.error("PageModel.getNextEntry)", e);
683             }
684         }
685         return mNextEntry;
686     }
687     
688     //------------------------------------------------------------------------
689

690     /**
691      * Get the previous occurring Entry.
692      */

693     public WeblogEntryDataWrapper getPreviousEntry() {
694         WeblogEntryDataWrapper currentEntry = getWeblogEntry();
695         if (mLastEntry != null) currentEntry = mLastEntry;
696         if (mPreviousEntry == null && currentEntry != null ) {
697             String JavaDoc catName = null;
698             if (mCategory != null) {
699                 catName = mCategory.getName();
700             }
701             try {
702                 WeblogEntryData prevEntry =
703                         mWeblogMgr.getPreviousEntry(currentEntry.getPojo(), catName, mLocale);
704                 
705                 if(prevEntry != null)
706                     mPreviousEntry = WeblogEntryDataWrapper.wrap(prevEntry);
707             } catch (RollerException e) {
708                 mLogger.error("PageModel.getPreviousEntry)", e);
709             }
710         }
711         return mPreviousEntry;
712     }
713     
714     //------------------------------------------------------------------------
715

716     public boolean isUserAuthorizedToEdit() {
717         try {
718             RollerSession rses =
719                     RollerSession.getRollerSession(mRequest);
720             if (rses.getAuthenticatedUser() != null && mWebsite != null) {
721                 return rses.isUserAuthorizedToAuthor(mWebsite);
722             }
723         } catch (Exception JavaDoc e) {
724             mLogger.warn("PageModel.isUserAuthorizedToEdit()", e);
725         }
726         return false;
727     }
728     
729     //------------------------------------------------------------------------
730

731     public boolean isUserAuthorizedToAdmin() {
732         try {
733             RollerSession rses =
734                     RollerSession.getRollerSession(mRequest);
735             if (rses.getAuthenticatedUser() != null && mWebsite != null) {
736                 return rses.isUserAuthorizedToAdmin(mWebsite);
737             }
738         } catch (Exception JavaDoc e) {
739             mLogger.warn("PageModel.isUserAuthorizedToAdmin()", e);
740         }
741         return false;
742     }
743     
744     //------------------------------------------------------------------------
745

746     public boolean isUserAuthenticated() {
747         return (mRequest.getUserPrincipal() != null);
748     }
749     
750     //------------------------------------------------------------------------
751

752     public String JavaDoc getRequestParameter(String JavaDoc key) {
753         return mRequest.getParameter(key);
754     }
755     
756     public int getIntRequestParameter(String JavaDoc key) {
757         return Integer.parseInt(mRequest.getParameter(key));
758     }
759     
760     //------------------------------------------------------------------------
761

762     public FolderDataWrapper getFolderByPath(String JavaDoc path) {
763         try {
764             FolderData folder = mBookmarkMgr.getFolderByPath(
765                     mWebsite, null, path);
766             
767             if(folder != null)
768                 return FolderDataWrapper.wrap(folder);
769         } catch (RollerException e) {
770             mLogger.error(e);
771         }
772         
773         return null;
774     }
775     
776     /**
777      * Facade for WeblogManager.getRecentComments().
778      * Get the most recent (chronologically) posted Comments
779      * for this website, limited to maxCount.
780      * @return List of Comments.
781      */

782     public List JavaDoc getRecentComments(int maxCount) {
783         List JavaDoc recentComments = new ArrayList JavaDoc();
784         try {
785             WeblogManager wmgr = RollerFactory.getRoller().getWeblogManager();
786             List JavaDoc recent = wmgr.getComments(
787                     mWebsite,
788                     null, // weblog entry
789
null, // search String
790
null, // startDate
791
null, // endDate
792
null, // pending
793
Boolean.TRUE, // approved only
794
Boolean.FALSE, // no spam
795
true, // we want reverse chrono order
796
0, // offset
797
maxCount); // no limit
798

799             // wrap pojos
800
recentComments = new ArrayList JavaDoc(recent.size());
801             Iterator JavaDoc it = recent.iterator();
802             while(it.hasNext()) {
803                 recentComments.add(CommentDataWrapper.wrap((CommentData) it.next()));
804             }
805         } catch (RollerException e) {
806             mLogger.error(e);
807         }
808         return recentComments;
809     }
810     
811     public boolean getEmailComments() {
812         if (mWebsite != null) {
813             boolean emailComments = RollerRuntimeConfig.getBooleanProperty("users.comments.emailnotify");
814             return (mWebsite.getEmailComments().booleanValue() && emailComments);
815         }
816         return false;
817     }
818 }
819
Popular Tags