File Source: OldWeblogPageModel.java
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.weblogger.ui.rendering.velocity.deprecated;
20
21 import java.util.ArrayList;
22 import java.util.Calendar;
23 import java.util.Collection;
24 import java.util.Collections;
25 import java.util.Date;
26 import java.util.HashMap;
27 import java.util.HashSet;
28 import java.util.Iterator;
29 import java.util.List;
30 import java.util.Map;
31 import java.util.Set;
32 import java.util.TimeZone;
33 import javax.servlet.http.HttpServletRequest;
34 import org.apache.commons.logging.Log;
35 import org.apache.commons.logging.LogFactory;
36 import org.apache.roller.weblogger.WebloggerException;
37 import org.apache.roller.weblogger.config.WebloggerRuntimeConfig;
38 import org.apache.roller.weblogger.business.BookmarkManager;
39 import org.apache.roller.weblogger.business.referrers.RefererManager;
40 import org.apache.roller.weblogger.business.WebloggerFactory;
41 import org.apache.roller.weblogger.business.UserManager;
42 import org.apache.roller.weblogger.business.WeblogManager;
43 import org.apache.roller.weblogger.pojos.WeblogEntryComment;
44 import org.apache.roller.weblogger.pojos.WeblogBookmarkFolder;
45 import org.apache.roller.weblogger.pojos.WeblogReferrer;
46 import org.apache.roller.weblogger.pojos.WeblogCategory;
47 import org.apache.roller.weblogger.pojos.WeblogEntry;
48 import org.apache.roller.weblogger.pojos.Weblog;
49 import org.apache.roller.weblogger.pojos.wrapper.WeblogEntryCommentWrapper;
50 import org.apache.roller.weblogger.pojos.wrapper.WeblogBookmarkFolderWrapper;
51 import org.apache.roller.weblogger.pojos.wrapper.WeblogReferrerWrapper;
52 import org.apache.roller.weblogger.pojos.wrapper.ThemeTemplateWrapper;
53 import org.apache.roller.weblogger.pojos.wrapper.WeblogCategoryWrapper;
54 import org.apache.roller.weblogger.pojos.wrapper.WeblogEntryWrapper;
55 import org.apache.roller.weblogger.pojos.wrapper.WeblogWrapper;
56 import org.apache.roller.weblogger.ui.core.RollerSession;
57 import org.apache.roller.util.DateUtil;
58 import org.apache.commons.lang.StringUtils;
59 import org.apache.roller.weblogger.business.URLStrategy;
60 import org.apache.roller.weblogger.pojos.WeblogHitCount;
61 import org.apache.roller.weblogger.pojos.ThemeTemplate;
62 import org.apache.roller.weblogger.pojos.WeblogPermission;
63
64
65 /**
66 * Provides Roller page templates with access to Roller domain model objects.
67 */
68 public class OldWeblogPageModel {
69 public final static String VELOCITY_NULL = "nil";
70
/*
P/P * Method: org.apache.roller.weblogger.ui.rendering.velocity.deprecated.OldWeblogPageModel__static_init
*
* Presumptions:
* org.apache.commons.logging.LogFactory:getFactory(...)@71 != null
*
* Postconditions:
* init'ed(mLogger)
*/
71 protected static Log mLogger =
72 LogFactory.getFactory().getInstance(OldWeblogPageModel.class);
73
74 private BookmarkManager mBookmarkMgr = null;
75 private WeblogManager mWeblogMgr = null;
76 private UserManager mUserMgr = null;
77 private RefererManager mRefererMgr = null;
78
79 private Map mCategories = new HashMap();
80 private HashMap mPageMap = new HashMap();
81 private HttpServletRequest mRequest = null;
82 private Weblog mWebsite = null;
83 private WeblogEntry mEntry = null;
84 private WeblogCategory mCategory = null;
85 private Date mDate = null;
86 private boolean mIsDaySpecified = false;
87 private boolean mIsMonthSpecified = false;
88 private String mLocale = null;
89 private WeblogEntryWrapper mNextEntry = null;
90 private WeblogEntryWrapper mPreviousEntry = null;
91 private WeblogEntryWrapper mLastEntry = null;
92 private WeblogEntryWrapper mFirstEntry = null;
93
94 private URLStrategy urlStrategy = null;
95
96 //------------------------------------------------------------------------
97
98 /** init() must be called to complete construction */
/*
P/P * Method: void org.apache.roller.weblogger.ui.rendering.velocity.deprecated.OldWeblogPageModel()
*
* Postconditions:
* this.mBookmarkMgr == null
* this.mCategory == null
* this.mDate == null
* this.mEntry == null
* this.mFirstEntry == null
* this.mLastEntry == null
* this.mLocale == null
* this.mNextEntry == null
* this.mPreviousEntry == null
* this.mRefererMgr == null
* ...
*/
99 public OldWeblogPageModel() {}
100
101 public String getModelName() {
/*
P/P * Method: String getModelName()
*
* Postconditions:
* return_value == &"pageModel"
*/
102 return "pageModel";
103 }
104
105 /**
106 * Initialize PageModel and allow PageModel to initialized VelocityContext.
107 */
108 public void init(URLStrategy strat,
109 HttpServletRequest request,
110 Weblog website,
111 WeblogEntry entry,
112 WeblogCategory category,
113 Date date,
114 boolean isDay,
115 boolean isMonth,
116 String locale) {
117
/*
P/P * Method: void init(URLStrategy, HttpServletRequest, Weblog, WeblogEntry, WeblogCategory, Date, bool, bool, String)
*
* Preconditions:
* (soft) mLogger != null
* (soft) this.mPageMap != null
*
* Presumptions:
* java.util.Collections.EMPTY_LIST != null
* java.util.Iterator:next(...)@150 != null
* org.apache.roller.weblogger.business.WebloggerFactory:getWeblogger(...)@130 != null
* org.apache.roller.weblogger.business.WebloggerFactory:getWeblogger(...)@131 != null
* org.apache.roller.weblogger.business.WebloggerFactory:getWeblogger(...)@132 != null
* ...
*
* Postconditions:
* init'ed(this.mBookmarkMgr)
* this.mCategory == category
* init'ed(this.mCategory)
* this.mDate == date
* init'ed(this.mDate)
* this.mEntry == entry
* init'ed(this.mEntry)
* this.mIsDaySpecified == isDay
* init'ed(this.mIsDaySpecified)
* this.mIsMonthSpecified == isMonth
* ...
*
* Test Vectors:
* website: Addr_Set{null}, Inverse{null}
* java.util.Iterator:hasNext(...)@149: {0}, {1}
*/
118 urlStrategy = strat;
119 mRequest = request;
120
121 // data we'll need in the methods
122 mWebsite = website;
123 mEntry = entry;
124 mCategory = category;
125 mDate = date;
126 mIsDaySpecified = isDay;
127 mIsMonthSpecified = isMonth;
128 mLocale = locale;
129
130 mBookmarkMgr = WebloggerFactory.getWeblogger().getBookmarkManager();
131 mRefererMgr = WebloggerFactory.getWeblogger().getRefererManager();
132 mUserMgr = WebloggerFactory.getWeblogger().getUserManager();
133 mWeblogMgr = WebloggerFactory.getWeblogger().getWeblogManager();
134
135 // Preload what we can for encapsulation. What we cannot preload we
136 // will use the Managers later to fetch.
137
138 // Get the pages, put into context & load map
139 if (mWebsite != null) {
140
141 List pages = Collections.EMPTY_LIST;
142 try {
143 pages = mWebsite.getTheme().getTemplates();
144 } catch (WebloggerException ex) {
145 mLogger.error("error getting weblog pages", ex);
146 }
147
148 Iterator pageIter = pages.iterator();
149 while (pageIter.hasNext()) {
150 ThemeTemplate page = (ThemeTemplate) pageIter.next();
151 mPageMap.put(page.getName(),ThemeTemplateWrapper.wrap(page));
152 }
153 }
154 }
155
156 //------------------------------------------------------------------------
157
158 /** Encapsulates folder.getBookmarks() & sorting */
159 public Collection getBookmarks(WeblogBookmarkFolderWrapper folder) {
/*
P/P * Method: Collection getBookmarks(WeblogBookmarkFolderWrapper)
*
* Preconditions:
* (soft) mLogger != null
*
* Postconditions:
* init'ed(return_value)
*
* Test Vectors:
* folder: Addr_Set{null}, Inverse{null}
*/
160 Collection bookmarks = null;
161 if (folder != null) {
162 mLogger.debug("Getting bookmarks for folder : "+folder.getName());
163
164 // since we already have a wrapped pojo we know the output
165 // will be wrapped as well :)
166 bookmarks = folder.getBookmarks();
167
168 // TODO: need to setup new BookmarkWrapperComparator
169 //List mBookmarks = new ArrayList(bookmarks);
170 //Collections.sort( mBookmarks, new BookmarkComparator() );
171 }
172 return bookmarks;
173 }
174
175 //------------------------------------------------------------------------
176
177 /** Get top level bookmark folders. */
178 public Collection getTopLevelFolders() {
/*
P/P * Method: Collection getTopLevelFolders()
*
* Preconditions:
* (soft) this.mBookmarkMgr != null
* (soft) this.mUserMgr != null
* (soft) this.mWebsite != null
*
* Presumptions:
* org.apache.roller.weblogger.business.BookmarkManager:getRootFolder(...)@181 != null
* org.apache.roller.weblogger.pojos.WeblogBookmarkFolder:getFolders(...)@181 != null
*
* Postconditions:
* return_value == One-of{&new ArrayList(getTopLevelFolders#1), &new ArrayList(getTopLevelFolders#2)}
* return_value in Addr_Set{&new ArrayList(getTopLevelFolders#1),&new ArrayList(getTopLevelFolders#2)}
* new ArrayList(getTopLevelFolders#1) num objects <= 1
* new ArrayList(getTopLevelFolders#2) num objects <= 1
*/
179 List tops = null;
180 try {
181 Collection mTops = mBookmarkMgr.getRootFolder(
182 mUserMgr.getWebsiteByHandle(mWebsite.getHandle())).getFolders();
183
184 // wrap pojos
185 tops = new ArrayList(mTops.size());
186 Iterator it = mTops.iterator();
187 int i=0;
188 while(it.hasNext()) {
189 tops.add(i,WeblogBookmarkFolderWrapper.wrap((WeblogBookmarkFolder) it.next()));
+ 190 i++;
191 }
192 } catch (WebloggerException e) {
193 tops = new ArrayList();
194 }
195 return tops;
196 }
197
198 //------------------------------------------------------------------------
199
200 /** Get number of approved non-spam comments for entry */
201 public int getCommentCount(String entryId) {
/*
P/P * Method: int getCommentCount(String)
*
* Preconditions:
* (soft) this.mWeblogMgr != null
*
* Postconditions:
* init'ed(return_value)
*/
202 return getCommentCount(entryId, true, true);
203 }
204
205 /** Get number of approved non-spam comments for entry */
206 public int getCommentCount(String entryId, boolean noSpam, boolean approvedOnly) {
207 try {
/*
P/P * Method: int getCommentCount(String, bool, bool)
*
* Preconditions:
* (soft) this.mWeblogMgr != null
*
* Presumptions:
* org.apache.roller.weblogger.business.WeblogManager:getWeblogEntry(...)@208 != null
* org.apache.roller.weblogger.pojos.WeblogEntry:getComments(...)@209 != null
*
* Postconditions:
* init'ed(return_value)
*/
208 WeblogEntry entry = mWeblogMgr.getWeblogEntry(entryId);
209 return entry.getComments(noSpam, approvedOnly).size();
210 } catch (WebloggerException alreadyLogged) {}
211 return 0;
212 }
213
214 //------------------------------------------------------------------------
215
216 /** Get comments for weblog entry specified by request */
217 public List getComments(WeblogEntryWrapper entry) {
/*
P/P * Method: List getComments(WeblogEntryWrapper)
*
* Preconditions:
* entry != null
* (soft) init'ed(this.urlStrategy)
*
* Postconditions:
* return_value == &new ArrayList(getComments#2*)
* new ArrayList(getComments#1*) num objects == 1
* new ArrayList(getComments#2*) num objects == 1
*/
218 return getComments(entry, true, true);
219 }
220
221 /** Get comments for weblog entry specified by request */
222 public List getComments(WeblogEntryWrapper wrapper, boolean noSpam, boolean approvedOnly) {
/*
P/P * Method: List getComments(WeblogEntryWrapper, bool, bool)
*
* Preconditions:
* wrapper != null
* (soft) init'ed(this.urlStrategy)
*
* Presumptions:
* org.apache.roller.weblogger.pojos.WeblogEntry:getComments(...)@225 != null
* org.apache.roller.weblogger.pojos.wrapper.WeblogEntryWrapper:getPojo(...)@223 != null
*
* Postconditions:
* return_value == &new ArrayList(getComments#2)
* new ArrayList(getComments#1) num objects == 1
* new ArrayList(getComments#2) num objects == 1
*
* Test Vectors:
* java.util.Iterator:hasNext(...)@228: {0}, {1}
*/
223 WeblogEntry entry = wrapper.getPojo();
+ 224 List comments = new ArrayList();
225 List unwrappped = entry.getComments(noSpam, approvedOnly);
226 comments = new ArrayList(unwrappped.size());
227 Iterator it = unwrappped.iterator();
228 while(it.hasNext()) {
229 comments.add(WeblogEntryCommentWrapper.wrap((WeblogEntryComment)it.next(), urlStrategy));
230 }
231 return comments;
232 }
233
234 //------------------------------------------------------------------------
235
236 /** Encapsulates RefererManager */
237 public int getDayHits() {
238 try {
/*
P/P * Method: int getDayHits()
*
* Preconditions:
* (soft) mLogger != null
* (soft) this.mWeblogMgr != null
* (soft) init'ed(this.mWebsite)
*
* Postconditions:
* init'ed(return_value)
*/
239 WeblogHitCount hitCount = mWeblogMgr.getHitCountByWeblog(mWebsite);
240
241 return (hitCount != null) ? hitCount.getDailyHits() : 0;
242
243 } catch (WebloggerException e) {
244 mLogger.error("PageModel getDayHits()", e);
245 }
246 return 0;
247 }
248
249 //------------------------------------------------------------------------
250
251 /** Encapsulates BookmarkManager.getFolder() */
252 public WeblogBookmarkFolderWrapper getFolder(String folderPath) {
253 try {
/*
P/P * Method: WeblogBookmarkFolderWrapper getFolder(String)
*
* Preconditions:
* (soft) mLogger != null
* (soft) this.mBookmarkMgr != null
* (soft) this.mUserMgr != null
* (soft) this.mWebsite != null
*
* Postconditions:
* init'ed(return_value)
*/
254 return WeblogBookmarkFolderWrapper.wrap(
255 mBookmarkMgr.getFolder(
256 mUserMgr.getWebsiteByHandle(mWebsite.getHandle()), folderPath));
257 } catch (WebloggerException e) {
258 mLogger.error("PageModel getFolder()", e);
259 }
260 return null;
261 }
262
263 //------------------------------------------------------------------------
264
265 /** Encapsulates UserManager.getPageByName() */
266 public ThemeTemplateWrapper getUsersPageByName(WeblogWrapper wrapper, String pageName) {
/*
P/P * Method: ThemeTemplateWrapper getUsersPageByName(WeblogWrapper, String)
*
* Preconditions:
* wrapper != null
* (soft) mLogger != null
* (soft) pageName != null
*
* Presumptions:
* org.apache.roller.weblogger.pojos.Weblog:getTheme(...)@276 != null
* org.apache.roller.weblogger.pojos.wrapper.WeblogWrapper:getPojo(...)@267 != null
*
* Postconditions:
* init'ed(return_value)
*/
267 Weblog website = wrapper.getPojo();
268 ThemeTemplateWrapper page = null;
269 try {
270 if (website == null)
271 throw new NullPointerException("website is null");
272
273 if (pageName == null)
274 throw new NullPointerException("pageName is null");
275
276 page = ThemeTemplateWrapper.wrap(website.getTheme().getTemplateByName(pageName));
277 } catch (NullPointerException npe) {
278 mLogger.warn(npe.getMessage());
279 } catch (WebloggerException e) {
280 mLogger.error("ERROR getting user's page by name: " + e.getMessage(),e);
281 }
282 return page;
283 }
284
285 //------------------------------------------------------------------------
286
287 /** Encapsulates UserManager.getPageByName() */
288 public ThemeTemplateWrapper getPageByName(String pageName) {
/*
P/P * Method: ThemeTemplateWrapper getPageByName(String)
*
* Preconditions:
* this.mPageMap != null
*
* Postconditions:
* init'ed(return_value)
*/
289 return (ThemeTemplateWrapper) mPageMap.get(pageName);
290 }
291
292 //------------------------------------------------------------------------
293
294 /** Encapsulates UserManager.getPageByName() */
295 public String getPageIdByName(String pageName) {
/*
P/P * Method: String getPageIdByName(String)
*
* Preconditions:
* mLogger != null
* (soft) this.mWebsite != null
*
* Presumptions:
* org.apache.roller.weblogger.pojos.Weblog:getTheme(...)@301 != null
*
* Postconditions:
* init'ed(return_value)
*
* Test Vectors:
* org.apache.roller.weblogger.pojos.WeblogTheme:getTemplateByName(...)@301: Addr_Set{null}, Inverse{null}
*/
296 mLogger.debug("looking up page ["+pageName+"]");
297
298 String template_id = null;
299
300 try {
301 ThemeTemplate pd = mWebsite.getTheme().getTemplateByName(pageName);
302 if(pd != null) {
303 template_id = pd.getId();
304 }
305 } catch(Exception e) {
306 mLogger.error(e);
307 }
308
309 mLogger.debug("returning template id ["+template_id+"]");
310
311 return template_id;
312 }
313
314 //------------------------------------------------------------------------
315
316 /**
317 * Get collection of user pages.
318 * @return
319 */
320 public Object getPages() {
/*
P/P * Method: Object getPages()
*
* Preconditions:
* this.mPageMap != null
*
* Postconditions:
* init'ed(return_value)
*/
321 return mPageMap.values();
322 }
323
324 //------------------------------------------------------------------------
325
326 /**
327 * Returns a map of up to 100 recent weblog entries for the user and day
328 * specified in the request, filtered by the category specified by the
329 * request, limited by the 'maxEntries' argument, and sorted by reverse
330 * chronological order.
331 *
332 * <p>This method will look for a category name in the following places
333 * and in the following order:</p>
334 * <ul>
335 * <li>The request via RollerRequest.getWeblogCategory().</li>
336 * <li>The categoryName argument to this method.</li>
337 * <li>The default category for the website specified by the request via
338 * RollerRequest.getWebsite().getDefaultCategory().</li>
339 * <li></li>
340 * </ul>
341 *
342 * @param maxEntries Maximum number of entries to be returned (only applies
343 * if specific day not specified).
344 * @param catName Only return entries from this category and it's
345 * subcategories. If null, returns all categories of entry
346 * @return Map of Lists of WeblogEntryData, keyed by 8-char date
347 * strings.
348 */
349 public Map getRecentWeblogEntries(int maxEntries, String catName) {
/*
P/P * Method: Map getRecentWeblogEntries(int, String)
*
* Preconditions:
* (soft) mLogger != null
* (soft) init'ed(this.mCategory)
* (soft) init'ed(this.mDate)
* (soft) init'ed(this.mIsDaySpecified)
* (soft) init'ed(this.mIsMonthSpecified)
* (soft) init'ed(this.mLocale)
* (soft) init'ed(this.mWebsite)
* (soft) init'ed(this.urlStrategy)
*
* Presumptions:
* java.util.Map:get(...)@406 != null
* java.util.Map:keySet(...)@400 != null
* org.apache.roller.weblogger.business.WeblogManager:getWeblogEntryObjectMap(...)@389 != null
* org.apache.roller.weblogger.business.Weblogger:getWeblogManager(...)@389 != null
* org.apache.roller.weblogger.business.WebloggerFactory:getWeblogger(...)@389 != null
* ...
*
* Postconditions:
* (soft) return_value != null
* possibly_updated(this.mFirstEntry)
* possibly_updated(this.mLastEntry)
* new HashMap(getRecentWeblogEntries#1) num objects == 1
*
* Test Vectors:
* this.mCategory: Addr_Set{null}, Inverse{null}
* this.mDate: Inverse{null}, Addr_Set{null}
* this.mIsDaySpecified: {0}, {1}
* this.mIsMonthSpecified: {0}, {1}
* this.mWebsite: Addr_Set{null}, Inverse{null}
* java.lang.String:equals(...)@350: {0}, {1}
* java.lang.String:equals(...)@363: {0}, {1}
* java.util.Iterator:hasNext(...)@401: {0}, {1}
*/
350 if (VELOCITY_NULL.equals(catName)) catName = null;
351 Map ret = new HashMap();
352 try {
353 // If request specifies a category, then use that
354 String catParam = null;
355 if (mCategory != null) {
356 catParam = mCategory.getPath();
357 } else if (catName != null) {
358 // use category argument instead
359 catParam = catName;
360 } else if (mWebsite != null) // MAIN
361 {
362 catParam = mWebsite.getDefaultCategory().getPath();
363 if (catParam.equals("/")) {
364 catParam = null;
365 }
366 }
367
368 Calendar cal = null;
369 if (mWebsite != null) {
370 TimeZone tz = mWebsite.getTimeZoneInstance();
371 cal = Calendar.getInstance(tz);
372 } else {
373 cal = Calendar.getInstance();
374 }
+ 375 int limit = mWebsite.getEntryDisplayCount();
376 Date startDate = null;
377 Date endDate = mDate;
378 if (endDate == null) endDate = new Date();
379 if (mIsDaySpecified) {
380 // URL specified a specific day
381 // so get entries for that day
382 endDate = DateUtil.getEndOfDay(endDate, cal);
383 startDate = DateUtil.getStartOfDay(endDate, cal);
384 // and get them ALL, no limit
385 limit = -1;
386 } else if (mIsMonthSpecified) {
387 endDate = DateUtil.getEndOfMonth(endDate, cal);
388 }
389 Map mRet = WebloggerFactory.getWeblogger().getWeblogManager().getWeblogEntryObjectMap(
390
391 mWebsite,
392 startDate, // startDate
393 endDate, // endDate
394 catParam, // catName
395 null,WeblogEntry.PUBLISHED, // status
396 mLocale, 0, limit);
397
398 // need to wrap pojos
399 java.util.Date key = null;
400 Iterator days = mRet.keySet().iterator();
401 while(days.hasNext()) {
402 key = (java.util.Date)days.next();
403
404 // now we need to go through each entry in a day and wrap
405 List wrappedEntries = new ArrayList();
406 List entries = (List) mRet.get(key);
407 for(int i=0; i < entries.size(); i++) {
408 wrappedEntries.add(i,WeblogEntryWrapper.wrap((WeblogEntry)entries.get(i), urlStrategy));
409 }
410 mRet.put(key, wrappedEntries);
411 }
412
413 ret = mRet;
414
415 setFirstAndLastEntries( ret );
416 } catch (Exception e) {
417 mLogger.error("PageModel getRecentWeblogEntries()", e);
418 }
419 return ret;
420 }
421
422 //------------------------------------------------------------------------
423
424 /**
425 * Pull the last WeblogEntryData out of the Map.
426 * @param ret
427 */
428 private void setFirstAndLastEntries(Map days) {
/*
P/P * Method: void setFirstAndLastEntries(Map)
*
* Preconditions:
* days != null
*
* Presumptions:
* java.util.Map:get(...)@434 != null
* java.util.Map:get(...)@441 != null
* java.util.Map:keySet(...)@429 != null
* java.util.Map:keySet(...)@433 != null
* java.util.Set:toArray(...)@433 != null
* ...
*
* Postconditions:
* possibly_updated(this.mFirstEntry)
* possibly_updated(this.mLastEntry)
*
* Test Vectors:
* java.util.List:size(...)@435: {-231..0}, {1..232-1}
* java.util.List:size(...)@442: {-231..0}, {1..232-1}
* java.util.Set:size(...)@429: {-231..0}, {1..232-1}
*/
429 int numDays = days.keySet().size();
430 if (numDays > 0) // there is at least one day
431 {
432 // get first entry in map
433 Object[] keys = days.keySet().toArray(new Object[numDays]);
434 List vals = (List)days.get( keys[0] );
435 int valSize = vals.size();
436 if (valSize > 0) {
437 mFirstEntry = (WeblogEntryWrapper)vals.get(0);
438 }
439
440 // get last entry in map
441 vals = (List)days.get( keys[--numDays] );
442 valSize = vals.size();
443 if (valSize > 0) {
444 mLastEntry = (WeblogEntryWrapper)vals.get(--valSize);
445 }
446 }
447 }
448
449 //------------------------------------------------------------------------
450
451 /**
452 * Returns list of recent weblog entries for the user and day specified in
453 * the request, filtered by the category specified by the request, limited
454 * by the 'maxEntries' argument, and sorted by reverse chronological order.
455 *
456 * <p>This method will look for a category name in the same places and
457 * same order as does the getRecentWeblogEntries() method.</p>
458 *
459 * @param maxEntries Maximum number of entries to be returned.
460 * @param categoryName Only return entries from this category and it's
461 * subcategories. If null, returns all categories of entry.
462 * @return List of WeblogEntryData objects in revese chronological order.
463 */
464 public List getRecentWeblogEntriesArray(int maxEntries, String categoryName) {
/*
P/P * Method: List getRecentWeblogEntriesArray(int, String)
*
* Preconditions:
* (soft) mLogger != null
* (soft) init'ed(this.mCategory)
* (soft) init'ed(this.mDate)
* (soft) init'ed(this.mLocale)
* (soft) init'ed(this.mWebsite)
* (soft) init'ed(this.urlStrategy)
*
* Presumptions:
* org.apache.roller.weblogger.business.WeblogManager:getWeblogEntries(...)@490 != null
* org.apache.roller.weblogger.business.Weblogger:getWeblogManager(...)@485 != null
* org.apache.roller.weblogger.business.WebloggerFactory:getWeblogger(...)@485 != null
* org.apache.roller.weblogger.pojos.Weblog:getDefaultCategory(...)@480 != null
* org.apache.roller.weblogger.pojos.WeblogCategory:getPath(...)@480 != null
*
* Postconditions:
* return_value == One-of{&new ArrayList(getRecentWeblogEntriesArray#3), &new ArrayList(getRecentWeblogEntriesArray#1)}
* return_value in Addr_Set{&new ArrayList(getRecentWeblogEntriesArray#1),&new ArrayList(getRecentWeblogEntriesArray#3)}
* new ArrayList(getRecentWeblogEntriesArray#1) num objects == 1
* new ArrayList(getRecentWeblogEntriesArray#3) num objects <= 1
*
* Test Vectors:
* this.mCategory: Addr_Set{null}, Inverse{null}
* this.mDate: Inverse{null}, Addr_Set{null}
* this.mWebsite: Addr_Set{null}, Inverse{null}
* java.lang.String:equals(...)@465: {0}, {1}
* java.lang.String:equals(...)@481: {0}, {1}
*/
465 if (VELOCITY_NULL.equals(categoryName)) categoryName = null;
466 List ret = new ArrayList();
467 try {
468 Date day = mDate;
469 if (day == null) day = new Date();
470
471 // If request specifies a category, then use that
472 String catParam = null;
473 if (mCategory != null) {
474 catParam = mCategory.getPath();
475 } else if (categoryName != null) {
476 // use category argument instead
477 catParam = categoryName;
478 } else if (mWebsite != null) // MAIN
479 {
480 catParam = mWebsite.getDefaultCategory().getPath();
481 if (catParam.equals("/")) {
482 catParam = null;
483 }
484 }
485 WeblogManager mgr = WebloggerFactory.getWeblogger().getWeblogManager();
486
487 //ret = mgr.getRecentWeblogEntriesArray(
488 //name, day, catParam, maxEntries, true );
489
+ 490 List mEntries = mgr.getWeblogEntries(
491
492 mWebsite,
493 null,
494 null, // startDate
495 day, // endDate
496 catParam, // catName
497 null,WeblogEntry.PUBLISHED, // status
498 null, // text
499 null, // sortby (null for pubTime)
500 null,
501 mLocale, 0, mWebsite.getEntryDisplayCount());
502
503 // wrap pojos
504 ret = new ArrayList(mEntries.size());
505 Iterator it = mEntries.iterator();
506 int i=0;
507 while(it.hasNext()) {
508 ret.add(i,WeblogEntryWrapper.wrap((WeblogEntry) it.next(), urlStrategy));
+ 509 i++;
510 }
511 } catch (Exception e) {
512 mLogger.error("PageModel getRecentWeblogEntries()", e);
513 }
514 return ret;
515 }
516
517 //------------------------------------------------------------------------
518
519 /** Encapsulates RefererManager **/
520 public List getReferers(String date) {
/*
P/P * Method: List getReferers(String)
*
* Preconditions:
* date != null
* (soft) mLogger != null
* (soft) this.mRefererMgr != null
* (soft) this.mRequest != null
* (soft) init'ed(this.mWebsite)
* (soft) init'ed(this.urlStrategy)
*
* Presumptions:
* java.util.Iterator:next(...)@530 != null
* org.apache.roller.weblogger.business.referrers.RefererManager:getReferersToDate(...)@524 != null
* init'ed(org.apache.roller.weblogger.pojos.WeblogPermission.ADMIN)
* org.apache.roller.weblogger.pojos.WeblogReferrer:getVisible(...)@535 != null
* org.apache.roller.weblogger.pojos.WeblogReferrer:getWebsite(...)@535 != null
* ...
*
* Postconditions:
* return_value == &new ArrayList(getReferers#1)
* new ArrayList(getReferers#1) num objects == 1
*
* Test Vectors:
* java.lang.Boolean:booleanValue(...)@535: {1}, {0}
* org.apache.commons.lang.StringUtils:isNotEmpty(...)@533: {0}, {1}
* org.apache.roller.weblogger.pojos.Weblog:hasUserPermissions(...)@535: {0}, {1}
*/
521 date = date.trim();
522 ArrayList referers = new ArrayList();
523 try {
524 List refs =
525 mRefererMgr.getReferersToDate(mWebsite, date);
526 RollerSession rses =
527 RollerSession.getRollerSession(mRequest);
528
529 for (Iterator rdItr = refs.iterator(); rdItr.hasNext();) {
530 WeblogReferrer referer = (WeblogReferrer) rdItr.next();
531 String title =referer.getTitle();
532 String excerpt = referer.getExcerpt();
533 if ( StringUtils.isNotEmpty(title)
534 && StringUtils.isNotEmpty(excerpt) ) {
535 if (referer.getVisible().booleanValue()
536 || referer.getWebsite().hasUserPermissions(rses.getAuthenticatedUser(), WeblogPermission.ADMIN) ) {
537 referers.add(WeblogReferrerWrapper.wrap(referer, urlStrategy));
538 }
539 }
540 }
541
542 } catch (Exception e) {
543 mLogger.error("PageModel getReferersToDate() fails with URL"
544 + mRequest.getRequestURL(), e);
545 }
546 return referers;
547 }
548
549 /** Encapsulates RefererManager **/
550 public List getEntryReferers(WeblogEntryWrapper entry) {
/*
P/P * Method: List getEntryReferers(WeblogEntryWrapper)
*
* Preconditions:
* (soft) entry != null
* (soft) mLogger != null
* (soft) this.mRefererMgr != null
* (soft) this.mRequest != null
* (soft) init'ed(this.urlStrategy)
*
* Presumptions:
* java.util.Iterator:next(...)@558 != null
* org.apache.roller.weblogger.business.referrers.RefererManager:getReferersToEntry(...)@553 != null
* init'ed(org.apache.roller.weblogger.pojos.WeblogPermission.ADMIN)
* org.apache.roller.weblogger.pojos.WeblogReferrer:getVisible(...)@563 != null
* org.apache.roller.weblogger.pojos.WeblogReferrer:getWebsite(...)@563 != null
* ...
*
* Postconditions:
* return_value == &new ArrayList(getEntryReferers#1)
* new ArrayList(getEntryReferers#1) num objects == 1
*
* Test Vectors:
* java.lang.Boolean:booleanValue(...)@563: {1}, {0}
* org.apache.commons.lang.StringUtils:isNotEmpty(...)@561: {0}, {1}
* org.apache.roller.weblogger.pojos.Weblog:hasUserPermissions(...)@563: {0}, {1}
*/
551 ArrayList referers = new ArrayList();
552 try {
553 List refs = mRefererMgr.getReferersToEntry(entry.getId());
554 RollerSession rses =
555 RollerSession.getRollerSession(mRequest);
556
557 for (Iterator rdItr = refs.iterator(); rdItr.hasNext();) {
558 WeblogReferrer referer = (WeblogReferrer) rdItr.next();
559 String title =referer.getTitle();
560 String excerpt = referer.getExcerpt();
561 if ( StringUtils.isNotEmpty(title)
562 && StringUtils.isNotEmpty(excerpt) ) {
563 if (referer.getVisible().booleanValue()
564 || referer.getWebsite().hasUserPermissions(rses.getAuthenticatedUser(), WeblogPermission.ADMIN) ) {
565 referers.add(WeblogReferrerWrapper.wrap(referer, urlStrategy));
566 }
567 }
568 }
569
570 } catch (Exception e) {
571 mLogger.error("PageModel getReferersToDate() fails with URL"
572 + mRequest.getRequestURL(), e);
573 }
574 return referers;
575 }
576
577 //------------------------------------------------------------------------
578
579 /** Encapsulates RefererManager */
580 public List getTodaysReferers() {
/*
P/P * Method: List getTodaysReferers()
*
* Preconditions:
* this.mWebsite != null
*
* Postconditions:
* init'ed(return_value)
*/
581 return mWebsite.getTodaysReferrers();
582 }
583
584 //------------------------------------------------------------------------
585
586 /** Encapsulates RefererManager */
587 public int getTotalHits() {
/*
P/P * Method: int getTotalHits()
*
* Preconditions:
* this.mWebsite != null
*
* Postconditions:
* init'ed(return_value)
*/
588 return mWebsite.getTodaysHits();
589 }
590
591 //------------------------------------------------------------------------
592 /**
593 * Returns most recent update time of collection of weblog entries.
594 * @param weblogEntries Collection of weblog entries.
595 * @return Most recent update time.
596 */
597 public static Date getUpdateTime( ArrayList weblogEntries ) {
/*
P/P * Method: Date getUpdateTime(ArrayList)
*
* Preconditions:
* weblogEntries != null
*
* Presumptions:
* java.util.ArrayList:iterator(...)@599 != null
* java.util.Iterator:next(...)@602 != null
*
* Postconditions:
* init'ed(return_value)
*
* Test Vectors:
* java.util.Date:before(...)@607: {0}, {1}
* java.util.Iterator:hasNext(...)@600: {0}, {1}
*/
598 Date updateTime = null;
599 Iterator iter = weblogEntries.iterator();
600 while (iter.hasNext()) {
601 // NOTE: this will need to be WeblogEntryDataWrapper
602 WeblogEntry wd = (WeblogEntry)iter.next();
603 if ( updateTime == null ) {
604 updateTime = wd.getUpdateTime();
605 }
606 //else if ( updateTime.compareTo(wd.getUpdateTime()) < 0 )
607 else if (updateTime.before( wd.getUpdateTime() )) {
608 updateTime = wd.getUpdateTime();
609 }
610 }
611 return updateTime;
612 }
613
614 //------------------------------------------------------------------------
615
616 /** Encapsulates WeblogManager.getWeblogCategories() */
617 public Set getWeblogCategories(String categoryName) {
/*
P/P * Method: Set getWeblogCategories(String)
*
* Preconditions:
* this.mCategories != null
* (soft) mLogger != null
* (soft) this.mWeblogMgr != null
* (soft) this.mWebsite != null
* (soft) init'ed(this.urlStrategy)
*
* Presumptions:
* org.apache.roller.weblogger.business.WeblogManager:getWeblogCategoryByPath(...)@632 != null
* org.apache.roller.weblogger.pojos.Weblog:getDefaultCategory(...)@635 != null
* org.apache.roller.weblogger.pojos.WeblogCategory:getWeblogCategories(...)@638 != null
*
* Postconditions:
* init'ed(return_value)
* new HashSet(getWeblogCategories#1) num objects <= 1
*
* Test Vectors:
* java.lang.String:equals(...)@619: {0}, {1}
* java.util.Iterator:hasNext(...)@644: {0}, {1}
*/
618 Set ret = null;
619 if (VELOCITY_NULL.equals(categoryName)) categoryName = null;
620
621 // Make sure we have not already fetched this category.
622 if (categoryName != null) {
623 ret = (Set)mCategories.get(categoryName);
624 } else {
625 ret = (Set)mCategories.get("zzz_null_zzz");
626 }
627
628 if (null == ret) {
629 try {
630 WeblogCategory category = null;
631 if (categoryName != null) {
632 category = mWeblogMgr.getWeblogCategoryByPath(
633 mWebsite, categoryName);
634 } else {
635 category = mWebsite.getDefaultCategory();
636 }
637
638 Set mRet = category.getWeblogCategories();
639
640 // wrap pojos
641 ret = new HashSet(mRet.size());
642 Iterator it = mRet.iterator();
643 int i=0;
644 while(it.hasNext()) {
645 ret.add(WeblogCategoryWrapper.wrap((WeblogCategory)it.next(), urlStrategy));
+ 646 i++;
647 }
648 if (categoryName != null) {
649 mCategories.put(categoryName, ret);
650 } else {
651 mCategories.put("zzz_null_zzz", ret);
652 }
653 } catch (WebloggerException e) {
654 mLogger.error(e);
655 }
656 }
657 return ret;
658 }
659
660 //------------------------------------------------------------------------
661
662 /** Encapsulates RollerRequest.getWeblogEntry() */
663 public WeblogEntryWrapper getWeblogEntry() {
664
/*
P/P * Method: WeblogEntryWrapper getWeblogEntry()
*
* Preconditions:
* init'ed(this.mEntry)
* (soft) init'ed(this.urlStrategy)
*
* Presumptions:
* org.apache.roller.weblogger.pojos.WeblogEntry:getStatus(...)@665 != null
*
* Postconditions:
* init'ed(return_value)
*
* Test Vectors:
* this.mEntry: Addr_Set{null}, Inverse{null}
* java.lang.String:equals(...)@665: {0}, {1}
*/
665 if(mEntry != null && mEntry.getStatus().equals(WeblogEntry.PUBLISHED))
666 return WeblogEntryWrapper.wrap(mEntry, urlStrategy);
667 else
668 return null;
669 }
670
671 //------------------------------------------------------------------------
672
673 /**
674 * Get the next occurring Entry.
675 */
676 public WeblogEntryWrapper getNextEntry() {
/*
P/P * Method: WeblogEntryWrapper getNextEntry()
*
* Preconditions:
* init'ed(this.mNextEntry)
* init'ed(this.mEntry)
* init'ed(this.mFirstEntry)
* (soft) mLogger != null
* (soft) init'ed(this.mCategory)
* (soft) init'ed(this.mLocale)
* (soft) this.mWeblogMgr != null
* (soft) init'ed(this.urlStrategy)
*
* Presumptions:
* org.apache.roller.weblogger.pojos.wrapper.WeblogEntryWrapper:getPubTime(...)@692 != null
*
* Postconditions:
* init'ed(return_value)
* this.mNextEntry == return_value
*
* Test Vectors:
* this.mNextEntry: Inverse{null}, Addr_Set{null}
* this.mCategory: Addr_Set{null}, Inverse{null}
* this.mFirstEntry: Addr_Set{null}, Inverse{null}
* java.sql.Timestamp:after(...)@692: {0}, {1}
* org.apache.roller.weblogger.business.WeblogManager:getNextEntry(...)@685: Addr_Set{null}, Inverse{null}
*/
677 WeblogEntryWrapper currentEntry = getWeblogEntry();
678 if (mFirstEntry != null) currentEntry = mFirstEntry;
679 if (mNextEntry == null && currentEntry != null) {
680 String catName = null;
681 if (mCategory != null) {
682 catName = mCategory.getName();
683 }
684 try {
685 WeblogEntry nextEntry =
686 mWeblogMgr.getNextEntry(currentEntry.getPojo(), catName, mLocale);
687
688 if(nextEntry != null)
689 mNextEntry = WeblogEntryWrapper.wrap(nextEntry, urlStrategy);
690
691 // make sure that mNextEntry is not published to future
692 if (mNextEntry != null &&
693 mNextEntry.getPubTime().after( new Date() )) {
694 mNextEntry = null;
695 }
696 } catch (WebloggerException e) {
697 mLogger.error("PageModel.getNextEntry)", e);
698 }
699 }
700 return mNextEntry;
701 }
702
703 //------------------------------------------------------------------------
704
705 /**
706 * Get the previous occurring Entry.
707 */
708 public WeblogEntryWrapper getPreviousEntry() {
/*
P/P * Method: WeblogEntryWrapper getPreviousEntry()
*
* Preconditions:
* init'ed(this.mPreviousEntry)
* init'ed(this.mEntry)
* init'ed(this.mLastEntry)
* (soft) mLogger != null
* (soft) init'ed(this.mCategory)
* (soft) init'ed(this.mLocale)
* (soft) this.mWeblogMgr != null
* (soft) init'ed(this.urlStrategy)
*
* Postconditions:
* init'ed(return_value)
* this.mPreviousEntry == return_value
*
* Test Vectors:
* this.mPreviousEntry: Inverse{null}, Addr_Set{null}
* this.mCategory: Addr_Set{null}, Inverse{null}
* this.mLastEntry: Addr_Set{null}, Inverse{null}
* org.apache.roller.weblogger.business.WeblogManager:getPreviousEntry(...)@717: Addr_Set{null}, Inverse{null}
*/
709 WeblogEntryWrapper currentEntry = getWeblogEntry();
710 if (mLastEntry != null) currentEntry = mLastEntry;
711 if (mPreviousEntry == null && currentEntry != null ) {
712 String catName = null;
713 if (mCategory != null) {
714 catName = mCategory.getName();
715 }
716 try {
717 WeblogEntry prevEntry =
718 mWeblogMgr.getPreviousEntry(currentEntry.getPojo(), catName, mLocale);
719
720 if(prevEntry != null)
721 mPreviousEntry = WeblogEntryWrapper.wrap(prevEntry, urlStrategy);
722 } catch (WebloggerException e) {
723 mLogger.error("PageModel.getPreviousEntry)", e);
724 }
725 }
726 return mPreviousEntry;
727 }
728
729 //------------------------------------------------------------------------
730
731 public boolean isUserAuthorizedToEdit() {
732 try {
/*
P/P * Method: bool isUserAuthorizedToEdit()
*
* Preconditions:
* (soft) mLogger != null
* (soft) init'ed(this.mRequest)
* (soft) init'ed(this.mWebsite)
*
* Presumptions:
* init'ed(org.apache.roller.weblogger.pojos.WeblogPermission.AUTHOR)
*
* Postconditions:
* init'ed(return_value)
*/
733 RollerSession rses =
734 RollerSession.getRollerSession(mRequest);
735 if (rses != null && rses.getAuthenticatedUser() != null && mWebsite != null) {
736 return mWebsite.hasUserPermissions(rses.getAuthenticatedUser(), WeblogPermission.AUTHOR);
737 }
738 } catch (Exception e) {
739 mLogger.warn("PageModel.isUserAuthorizedToEdit()", e);
740 }
741 return false;
742 }
743
744 //------------------------------------------------------------------------
745
746 public boolean isUserAuthorizedToAdmin() {
747 try {
/*
P/P * Method: bool isUserAuthorizedToAdmin()
*
* Preconditions:
* (soft) mLogger != null
* (soft) init'ed(this.mRequest)
* (soft) init'ed(this.mWebsite)
*
* Presumptions:
* init'ed(org.apache.roller.weblogger.pojos.WeblogPermission.ADMIN)
*
* Postconditions:
* init'ed(return_value)
*/
748 RollerSession rses =
749 RollerSession.getRollerSession(mRequest);
750 if (rses != null && rses.getAuthenticatedUser() != null && mWebsite != null) {
751 return mWebsite.hasUserPermissions(rses.getAuthenticatedUser(), WeblogPermission.ADMIN);
752 }
753 } catch (Exception e) {
754 mLogger.warn("PageModel.isUserAuthorizedToAdmin()", e);
755 }
756 return false;
757 }
758
759 //------------------------------------------------------------------------
760
761 public boolean isUserAuthenticated() {
/*
P/P * Method: bool isUserAuthenticated()
*
* Preconditions:
* this.mRequest != null
*
* Postconditions:
* init'ed(return_value)
*/
762 return (mRequest.getUserPrincipal() != null);
763 }
764
765 //------------------------------------------------------------------------
766
767 public String getRequestParameter(String key) {
/*
P/P * Method: String getRequestParameter(String)
*
* Preconditions:
* this.mRequest != null
*
* Postconditions:
* init'ed(return_value)
*/
768 return mRequest.getParameter(key);
769 }
770
771 public int getIntRequestParameter(String key) {
/*
P/P * Method: int getIntRequestParameter(String)
*
* Preconditions:
* this.mRequest != null
*
* Postconditions:
* init'ed(return_value)
*/
772 return Integer.parseInt(mRequest.getParameter(key));
773 }
774
775 //------------------------------------------------------------------------
776
777 public WeblogBookmarkFolderWrapper getFolderByPath(String path) {
778 try {
/*
P/P * Method: WeblogBookmarkFolderWrapper getFolderByPath(String)
*
* Preconditions:
* (soft) mLogger != null
* (soft) this.mBookmarkMgr != null
* (soft) init'ed(this.mWebsite)
*
* Postconditions:
* init'ed(return_value)
*/
779 WeblogBookmarkFolder folder = mBookmarkMgr.getFolder(mWebsite, path);
780
781 if(folder != null)
782 return WeblogBookmarkFolderWrapper.wrap(folder);
783 } catch (WebloggerException e) {
784 mLogger.error(e);
785 }
786
787 return null;
788 }
789
790 /**
791 * Facade for WeblogManager.getRecentComments().
792 * Get the most recent (chronologically) posted Comments
793 * for this website, limited to maxCount.
794 * @return List of Comments.
795 */
796 public List getRecentComments(int maxCount) {
/*
P/P * Method: List getRecentComments(int)
*
* Preconditions:
* (soft) mLogger != null
* (soft) init'ed(this.mWebsite)
* (soft) init'ed(this.urlStrategy)
*
* Presumptions:
* org.apache.roller.weblogger.business.WeblogManager:getComments(...)@800 != null
* org.apache.roller.weblogger.business.Weblogger:getWeblogManager(...)@799 != null
* org.apache.roller.weblogger.business.WebloggerFactory:getWeblogger(...)@799 != null
*
* Postconditions:
* return_value == One-of{&new ArrayList(getRecentComments#2), &new ArrayList(getRecentComments#1)}
* return_value in Addr_Set{&new ArrayList(getRecentComments#1),&new ArrayList(getRecentComments#2)}
* new ArrayList(getRecentComments#1) num objects == 1
* new ArrayList(getRecentComments#2) num objects <= 1
*/
797 List recentComments = new ArrayList();
798 try {
799 WeblogManager wmgr = WebloggerFactory.getWeblogger().getWeblogManager();
800 List recent = wmgr.getComments(
801
802 mWebsite,
803 null, // weblog entry
804 null, // search String
805 null, // startDate
806 null,WeblogEntryComment.APPROVED, // approved comments only
807 true, // we want reverse chrono order
808 0, // offset
809 maxCount); // no limit
810
811 // wrap pojos
812 recentComments = new ArrayList(recent.size());
813 Iterator it = recent.iterator();
814 while(it.hasNext()) {
815 recentComments.add(WeblogEntryCommentWrapper.wrap((WeblogEntryComment) it.next(), urlStrategy));
816 }
817 } catch (WebloggerException e) {
818 mLogger.error(e);
819 }
820 return recentComments;
821 }
822
823 public boolean getEmailComments() {
/*
P/P * Method: bool getEmailComments()
*
* Preconditions:
* init'ed(this.mWebsite)
*
* Presumptions:
* org.apache.roller.weblogger.pojos.Weblog:getEmailComments(...)@826 != null
*
* Postconditions:
* init'ed(return_value)
*
* Test Vectors:
* this.mWebsite: Addr_Set{null}, Inverse{null}
*/
824 if (mWebsite != null) {
825 boolean emailComments = WebloggerRuntimeConfig.getBooleanProperty("users.comments.emailnotify");
826 return (mWebsite.getEmailComments().booleanValue() && emailComments);
827 }
828 return false;
829 }
830 }
SofCheck Inspector Build Version : 2.18479
| OldWeblogPageModel.java |
2009-Jan-02 14:24:58 |
| OldWeblogPageModel.class |
2009-Sep-04 03:12:45 |