File Source: JPAUserManagerImpl.java
1
2 /*
3 * Licensed to the Apache Software Foundation (ASF) under one or more
4 * contributor license agreements. The ASF licenses this file to You
5 * under the Apache License, Version 2.0 (the "License"); you may not
6 * use this file except in compliance with the License.
7 * You may obtain a copy of the License at
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License. For additional information regarding
16 * copyright in this work, please see the NOTICE file in the top level
17 * directory of this distribution.
18 */
19 package org.apache.roller.weblogger.business.jpa;
20
21 import java.sql.Timestamp;
22 import javax.persistence.NoResultException;
23 import org.apache.commons.logging.Log;
24 import org.apache.commons.logging.LogFactory;
25
26 import org.apache.roller.weblogger.WebloggerException;
27 import org.apache.roller.weblogger.business.BookmarkManager;
28 import org.apache.roller.weblogger.business.UserManager;
29 import org.apache.roller.weblogger.business.WeblogManager;
30 import org.apache.roller.weblogger.business.pings.AutoPingManager;
31 import org.apache.roller.weblogger.business.pings.PingTargetManager;
32 import org.apache.roller.weblogger.config.WebloggerConfig;
33 import org.apache.roller.weblogger.pojos.*;
34
35 import java.util.ArrayList;
36 import java.util.Collections;
37 import java.util.Date;
38 import java.util.Hashtable;
39 import java.util.Iterator;
40 import java.util.List;
41 import java.util.Map;
42 import java.util.TreeMap;
43 import java.util.Collection;
44 import java.util.Comparator;
45 import javax.persistence.Query;
46 import org.apache.roller.weblogger.business.FileManager;
47 import org.apache.roller.weblogger.business.Weblogger;
48 import org.apache.roller.weblogger.business.WebloggerFactory;
49
50 /*
51 * JPAUserManagerImpl.java
52 *
53 * Created on May 29, 2006, 3:15 PM
54 *
55 */
56 @com.google.inject.Singleton
57 public class JPAUserManagerImpl implements UserManager {
58
59 /** The logger instance for this class. */
/*
P/P * Method: org.apache.roller.weblogger.business.jpa.JPAUserManagerImpl__static_init
*
* Postconditions:
* init'ed(log)
* init'ed(statCountCountReverseComparator)
*/
60 private static Log log = LogFactory.getLog(JPAUserManagerImpl.class);
61
62 private static final Comparator statCountCountReverseComparator =
63 Collections.reverseOrder(StatCountCountComparator.getInstance());
64
65 private final Weblogger roller;
66 private final JPAPersistenceStrategy strategy;
67
68 // cached mapping of weblogHandles -> weblogIds
69 private Map weblogHandleToIdMap = new Hashtable();
70
71 // cached mapping of userNames -> userIds
72 private Map userNameToIdMap = new Hashtable();
73
74
75 @com.google.inject.Inject
/*
P/P * Method: void org.apache.roller.weblogger.business.jpa.JPAUserManagerImpl(Weblogger, JPAPersistenceStrategy)
*
* Preconditions:
* log != null
*
* Postconditions:
* this.roller == roller
* init'ed(this.roller)
* this.strategy == strat
* init'ed(this.strategy)
* this.userNameToIdMap == &new Hashtable(JPAUserManagerImpl#2)
* this.weblogHandleToIdMap == &new Hashtable(JPAUserManagerImpl#1)
* new Hashtable(JPAUserManagerImpl#1) num objects == 1
* new Hashtable(JPAUserManagerImpl#2) num objects == 1
*/
76 protected JPAUserManagerImpl(Weblogger roller, JPAPersistenceStrategy strat) {
77 log.debug("Instantiating JPA User Manager");
78 this.roller = roller;
79 this.strategy = strat;
80 }
81
82 /**
83 * Update existing website.
84 */
85 public void saveWebsite(Weblog website) throws WebloggerException {
86
/*
P/P * Method: void saveWebsite(Weblog)
*
* Preconditions:
* this.strategy != null
* this.strategy.threadLocalEntityManager != null
* website != null
* (soft) this.strategy.emf != null
*/
87 website.setLastModified(new java.util.Date());
88 strategy.store(website);
89 }
90
91 public void removeWebsite(Weblog weblog) throws WebloggerException {
92
93 // remove contents first, then remove website
/*
P/P * Method: void removeWebsite(Weblog)
*
* Preconditions:
* this.strategy != null
* this.strategy.threadLocalEntityManager != null
* this.weblogHandleToIdMap != null
* weblog != null
* (soft) this.strategy.emf != null
*/
94 this.removeWebsiteContents(weblog);
95 this.strategy.remove(weblog);
96
97 // remove entry from cache mapping
98 this.weblogHandleToIdMap.remove(weblog.getHandle());
99 }
100
101 /**
102 * convenience method for removing contents of a weblog.
103 * TODO BACKEND: use manager methods instead of queries here
104 */
105 private void removeWebsiteContents(Weblog website)
106 throws WebloggerException {
107
/*
P/P * Method: void removeWebsiteContents(Weblog)
*
* Preconditions:
* org/apache/roller/weblogger/business/WebloggerFactory.webloggerProvider != null
* org/apache/roller/weblogger/business/WebloggerFactory.webloggerProvider.webloggerInstance != null
* this.roller != null
* this.roller.autoPingManager != null
* this.roller.autoPingManager.strategy != null
* this.roller.autoPingManager.strategy.threadLocalEntityManager != null
* this.roller.bookmarkManager != null
* this.roller.bookmarkManager.strategy != null
* this.roller.bookmarkManager.strategy.threadLocalEntityManager != null
* this.roller.pingTargetManager != null
* ...
*
* Presumptions:
* autoPingMgr.strategy.emf@139 != null
* bmgr.strategy.emf@174 != null
* getWeblogManager(...)@109.roller.userManager != wmgr.roller.userManager
* getWeblogManager(...)@109.roller.userManager.strategy != wmgr.roller.userManager.strategy
* getWeblogger(...).fileManager != null
* ...
*
* Test Vectors:
* java.util.Iterator:hasNext(...)@116: {0}, {1}
* java.util.Iterator:hasNext(...)@143: {0}, {1}
* java.util.Iterator:hasNext(...)@152: {0}, {1}
* java.util.Iterator:hasNext(...)@160: {0}, {1}
* java.util.Iterator:hasNext(...)@168: {0}, {1}
* java.util.Iterator:hasNext(...)@177: {0}, {1}
* java.util.Iterator:hasNext(...)@194: {0}, {1}
* java.util.Iterator:hasNext(...)@207: {0}, {1}
*/
108 BookmarkManager bmgr = roller.getBookmarkManager();
109 WeblogManager wmgr = roller.getWeblogManager();
110
111 // remove tags
112 Query tagQuery = strategy.getNamedQuery("WeblogEntryTag.getByWeblog");
113 tagQuery.setParameter(1, website);
114 List results = tagQuery.getResultList();
115
116 for(Iterator iter = results.iterator(); iter.hasNext();) {
117 WeblogEntryTag tagData = (WeblogEntryTag) iter.next();
118 this.strategy.remove(tagData);
119 }
120
121 // remove site tag aggregates
122 List tags = wmgr.getTags(website, null, null, -1);
123 updateTagAggregates(tags);
124
125 // delete all weblog tag aggregates
126 Query removeAggs= strategy.getNamedUpdate(
127 "WeblogEntryTagAggregate.removeByWeblog");
128 removeAggs.setParameter(1, website);
129 removeAggs.executeUpdate();
130
131 // delete all bad counts
132 Query removeCounts = strategy.getNamedUpdate(
133 "WeblogEntryTagAggregate.removeByTotalLessEqual");
134 removeCounts.setParameter(1, new Integer(0));
135 removeCounts.executeUpdate();
136
137
138 // Remove the website's ping queue entries
139 Query q = strategy.getNamedQuery("PingQueueEntry.getByWebsite");
140 q.setParameter(1, website);
141 List queueEntries = q.getResultList();
142 Iterator it = queueEntries.iterator();
143 while(it.hasNext()) {
144 this.strategy.remove((PingQueueEntry) it.next());
145 }
146
147 // Remove the website's auto ping configurations
148 AutoPingManager autoPingMgr = roller
149 .getAutopingManager();
150 List autopings = autoPingMgr.getAutoPingsByWebsite(website);
151 it = autopings.iterator();
152 while(it.hasNext()) {
153 this.strategy.remove((AutoPing) it.next());
154 }
155
156 // Remove the website's custom ping targets
157 PingTargetManager pingTargetMgr = roller.getPingTargetManager();
158 List pingtargets = pingTargetMgr.getCustomPingTargets(website);
159 it = pingtargets.iterator();
160 while(it.hasNext()) {
161 this.strategy.remove((PingTarget) it.next());
162 }
163
164 // remove associated referers
165 Query refQuery2 = strategy.getNamedQuery("WeblogReferrer.getByWebsite");
166 refQuery2.setParameter(1, website);
167 List referers = refQuery2.getResultList();
168 for (Iterator iter = referers.iterator(); iter.hasNext();) {
169 WeblogReferrer referer = (WeblogReferrer) iter.next();
170 this.strategy.remove(referer);
171 }
172
173 // remove associated pages
174 Query pageQuery = strategy.getNamedQuery("WeblogTemplate.getByWebsite");
175 pageQuery.setParameter(1, website);
176 List pages = pageQuery.getResultList();
177 for (Iterator iter = pages.iterator(); iter.hasNext();) {
178 WeblogTemplate page = (WeblogTemplate) iter.next();
179 this.strategy.remove(page);
180 }
181
182 // remove folders (including bookmarks)
183 WeblogBookmarkFolder rootFolder = bmgr.getRootFolder(website);
184 if (null != rootFolder) {
185 this.strategy.remove(rootFolder);
186 }
187
188 this.strategy.flush();
189
190 // remove entries
191 Query refQuery = strategy.getNamedQuery("WeblogEntry.getByWebsite");
192 refQuery.setParameter(1, website);
193 List entries = refQuery.getResultList();
194 for (Iterator iter = entries.iterator(); iter.hasNext();) {
195 WeblogEntry entry = (WeblogEntry) iter.next();
196 wmgr.removeWeblogEntry(entry);
197 }
198
199 // remove categories
200 WeblogCategory rootCat = wmgr.getRootWeblogCategory(website);
201 if (null != rootCat) {
202 this.strategy.remove(rootCat);
203 }
204
205 // remove permissions
206 // make sure that both sides of the relationship are maintained
207 for (Iterator iterator = website.getPermissions().iterator(); iterator.hasNext();) {
208 WeblogPermission perms = (WeblogPermission) iterator.next();
209
210 //Remove it from website
211 iterator.remove();
212
213 //Remove it from corresponding user
214 User user = perms.getUser();
215 user.getPermissions().remove(perms);
216
217 //Remove it from database
218 this.strategy.remove(perms);
219 }
220
221 // flush the changes before returning. This is required as there is a
222 // circular dependency between WeblogCategory and Weblog
223 this.strategy.flush();
224
225 // remove uploaded files
226 FileManager fmgr = WebloggerFactory.getWeblogger().getFileManager();
227 fmgr.deleteAllFiles(website);
228 }
229
230 protected void updateTagAggregates(List tags) throws WebloggerException {
/*
P/P * Method: void updateTagAggregates(List)
*
* Preconditions:
* tags != null
* (soft) this.strategy != null
* (soft) this.strategy.emf != null
* (soft) this.strategy.threadLocalEntityManager != null
*
* Presumptions:
* java.util.Iterator:next(...)@232 != null
* javax.persistence.EntityManager:createNamedQuery(...)@301 != null
* javax.persistence.Query:getSingleResult(...)@237 != null
*
* Test Vectors:
* java.util.Iterator:hasNext(...)@231: {0}, {1}
*/
231 for(Iterator iter = tags.iterator(); iter.hasNext();) {
232 TagStat stat = (TagStat) iter.next();
233 Query query = strategy.getNamedUpdate(
234 "WeblogEntryTagAggregate.getByName&WebsiteNullOrderByLastUsedDesc");
235 query.setParameter(1, stat.getName());
236 try {
237 WeblogEntryTagAggregate agg = (WeblogEntryTagAggregate)query.getSingleResult();
238 agg.setTotal(agg.getTotal() - stat.getCount());
239 } catch (NoResultException ignored) {} // no agg to be updated
240 }
241 }
242
243 public void saveUser(User data) throws WebloggerException {
/*
P/P * Method: void saveUser(User)
*
* Preconditions:
* this.strategy != null
* this.strategy.threadLocalEntityManager != null
* (soft) this.strategy.emf != null
*/
244 this.strategy.store(data);
245 }
246
247 public void removeUser(User user) throws WebloggerException {
248 //remove permissions
249 // make sure that both sides of the relationship are maintained
/*
P/P * Method: void removeUser(User)
*
* Preconditions:
* this.strategy != null
* this.strategy.threadLocalEntityManager != null
* this.userNameToIdMap != null
* user != null
* (soft) this.strategy.emf != null
*
* Presumptions:
* java.util.Iterator:next(...)@251 != null
* org.apache.roller.weblogger.pojos.User:getPermissions(...)@250 != null
* org.apache.roller.weblogger.pojos.Weblog:getPermissions(...)@258 != null
* org.apache.roller.weblogger.pojos.WeblogPermission:getWebsite(...)@257 != null
*
* Test Vectors:
* java.util.Iterator:hasNext(...)@250: {0}, {1}
*/
250 for (Iterator iterator = user.getPermissions().iterator(); iterator.hasNext();) {
251 WeblogPermission perms = (WeblogPermission) iterator.next();
252 //Remove it from database
253 this.strategy.remove(perms);
254 //Remove it from website
255 iterator.remove();
256 //Remove it from corresponding user
257 Weblog website = perms.getWebsite();
258 website.getPermissions().remove(perms);
259 }
260
261 this.strategy.remove(user);
262
263 // remove entry from cache mapping
264 this.userNameToIdMap.remove(user.getUserName());
265 }
266
267 public void savePermissions(WeblogPermission perms)
268 throws WebloggerException {
269 //if (getPermissions(perms.getWebsite(), perms.getUser()) != null) {
270 //throw new WebloggerException("ERROR: user already has permission in weblog");
271 //}
/*
P/P * Method: void savePermissions(WeblogPermission)
*
* Preconditions:
* perms != null
* this.strategy != null
* this.strategy.threadLocalEntityManager != null
* (soft) this.strategy.emf != null
*
* Presumptions:
* org.apache.roller.weblogger.pojos.User:getPermissions(...)@279 != null
* org.apache.roller.weblogger.pojos.Weblog:getPermissions(...)@276 != null
* org.apache.roller.weblogger.pojos.WeblogPermission:getUser(...)@278 != null
* org.apache.roller.weblogger.pojos.WeblogPermission:getWebsite(...)@275 != null
*
* Test Vectors:
* javax.persistence.EntityManager:find(...)@216: Inverse{null}, Addr_Set{null}
*/
272 if (getPermissions(perms.getId()) == null) {
273 // This is a new object make sure that relationship is set on managed
274 // copy of other side
275 Weblog website = perms.getWebsite(); //(Weblog) getManagedObject(perms.getWebsite());
276 website.getPermissions().add(perms);
277
278 User user = perms.getUser(); //(User) getManagedObject(perms.getUser());
279 user.getPermissions().add(perms);
280 }
281 this.strategy.store(perms);
282 }
283
284 public void removePermissions(WeblogPermission perms)
285 throws WebloggerException {
/*
P/P * Method: void removePermissions(WeblogPermission)
*
* Preconditions:
* perms != null
* this.strategy != null
* this.strategy.threadLocalEntityManager != null
* (soft) this.strategy.emf != null
*
* Presumptions:
* org.apache.roller.weblogger.pojos.User:getPermissions(...)@293 != null
* org.apache.roller.weblogger.pojos.Weblog:getPermissions(...)@290 != null
* org.apache.roller.weblogger.pojos.WeblogPermission:getUser(...)@292 != null
* org.apache.roller.weblogger.pojos.WeblogPermission:getWebsite(...)@289 != null
*/
286 this.strategy.remove(perms);
287 // make sure that relationship is set on managed
288 // copy of other side
289 Weblog website = perms.getWebsite(); //Weblog) getManagedObject(perms.getWebsite());
290 website.getPermissions().remove(perms);
291
292 User user = perms.getUser(); //(User) getManagedObject(perms.getUser());
293 user.getPermissions().remove(perms);
294 }
295
296 /**
297 * @see org.apache.roller.weblogger.model.UserManager#storePage(org.apache.roller.weblogger.pojos.WeblogTemplate)
298 */
299 public void savePage(WeblogTemplate page) throws WebloggerException {
/*
P/P * Method: void savePage(WeblogTemplate)
*
* Preconditions:
* page != null
* this.roller != null
* this.roller.userManager != null
* this.roller.userManager.strategy != null
* this.roller.userManager.strategy.threadLocalEntityManager != null
* this.strategy != null
* this.strategy.threadLocalEntityManager != null
* (soft) this.strategy.emf != null
*
* Presumptions:
* getUserManager(...).strategy.emf@300 != null
* org.apache.roller.weblogger.pojos.WeblogTemplate:getWebsite(...)@303 != null
*/
300 this.strategy.store(page);
301
302 // update weblog last modified date. date updated by saveWebsite()
303 roller.getUserManager()
304 .saveWebsite(page.getWebsite());
305 }
306
307 public void removePage(WeblogTemplate page) throws WebloggerException {
/*
P/P * Method: void removePage(WeblogTemplate)
*
* Preconditions:
* page != null
* this.roller != null
* this.roller.userManager != null
* this.roller.userManager.strategy != null
* this.roller.userManager.strategy.threadLocalEntityManager != null
* this.strategy != null
* this.strategy.threadLocalEntityManager != null
* (soft) this.strategy.emf != null
*
* Presumptions:
* getUserManager(...).strategy.emf@308 != null
* org.apache.roller.weblogger.pojos.WeblogTemplate:getWebsite(...)@311 != null
*/
308 this.strategy.remove(page);
309
310 // update weblog last modified date. date updated by saveWebsite()
311 roller.getUserManager().saveWebsite(page.getWebsite());
312 }
313
314 public void addUser(User newUser) throws WebloggerException {
315
/*
P/P * Method: void addUser(User)
*
* Preconditions:
* newUser != null
* this.strategy != null
* this.strategy.threadLocalEntityManager != null
* this.userNameToIdMap != null
* (soft) log != null
* (soft) this.strategy.emf != null
*
* Presumptions:
* init'ed(java.lang.Boolean.TRUE)
* javax.persistence.Query:getResultList(...)@753 != null
* org.apache.roller.weblogger.pojos.User:getUserName(...)@332 != null
*
* Test Vectors:
* java.util.List:size(...)@322: {-231..-1, 1..232-1}, {0}
*/
316 if(newUser == null)
317 throw new WebloggerException("cannot add null user");
318
319 // TODO BACKEND: we must do this in a better fashion, like getUserCnt()?
320 boolean adminUser = false;
321 List existingUsers = this.getUsers(null, Boolean.TRUE, null, null, 0, 1);
322 if(existingUsers.size() == 0) {
323 // Make first user an admin
324 adminUser = true;
325
326 //if user was disabled (because of activation user
327 // account with e-mail property), enable it for admin user
328 newUser.setEnabled(Boolean.TRUE);
329 newUser.setActivationCode(null);
330 }
331
+ 332 if(getUserByUserName(newUser.getUserName()) != null ||
333 getUserByUserName(newUser.getUserName().toLowerCase()) != null) {
334 throw new WebloggerException("error.add.user.userNameInUse");
335 }
336
337 newUser.grantRole("editor");
338 if(adminUser) {
339 newUser.grantRole("admin");
340 }
341
342 this.strategy.store(newUser);
343 }
344
345 public void addWebsite(Weblog newWeblog) throws WebloggerException {
346
/*
P/P * Method: void addWebsite(Weblog)
*
* Preconditions:
* newWeblog != null
* org/apache/roller/weblogger/config/WebloggerConfig.config != null
* org/apache/roller/weblogger/config/WebloggerConfig.log != null
* this.roller != null
* this.roller.pingTargetManager != null
* this.roller.pingTargetManager.strategy != null
* this.roller.pingTargetManager.strategy.threadLocalEntityManager != null
* this.strategy != null
* this.strategy.threadLocalEntityManager != null
* (soft) this.roller.autoPingManager != null
* ...
*/
347 this.strategy.store(newWeblog);
348 this.strategy.flush();
349 this.addWeblogContents(newWeblog);
350 }
351
352 private void addWeblogContents(Weblog newWeblog)
353 throws WebloggerException {
354
355 // grant weblog creator ADMIN permissions
/*
P/P * Method: void addWeblogContents(Weblog)
*
* Preconditions:
* newWeblog != null
* org/apache/roller/weblogger/config/WebloggerConfig.config != null
* org/apache/roller/weblogger/config/WebloggerConfig.log != null
* this.roller != null
* this.roller.pingTargetManager != null
* this.roller.pingTargetManager.strategy != null
* this.roller.pingTargetManager.strategy.threadLocalEntityManager != null
* this.strategy != null
* this.strategy.threadLocalEntityManager != null
* (soft) this.roller.autoPingManager != null
* ...
*
* Presumptions:
* autoPingMgr.strategy.emf@428 != null
* java.util.Iterator:next(...)@431 != null
* javax.persistence.Query:getResultList(...)@177 != null
* init'ed(org.apache.roller.weblogger.pojos.WeblogPermission.ADMIN)
* pingTargetMgr.strategy.emf@399 != null
*
* Test Vectors:
* java.lang.String:length(...)@374: {0}, {1..232-1}
* java.util.Iterator:hasNext(...)@430: {0}, {1}
* org.apache.roller.weblogger.pojos.PingTarget:isAutoEnabled(...)@433: {0}, {1}
*/
356 WeblogPermission perms = new WeblogPermission();
357 perms.setUser(newWeblog.getCreator());
358 perms.setWebsite(newWeblog);
359 perms.setPending(false);
360 perms.setPermissionMask(WeblogPermission.ADMIN);
361 savePermissions(perms);
362
363 // add default category
364 WeblogCategory rootCat = new WeblogCategory(
365 newWeblog, // newWeblog
366 null, // parent
367 "root", // name
368 "root", // description
369 null ); // image
370 this.strategy.store(rootCat);
371
372 String cats = WebloggerConfig.getProperty("newuser.categories");
373 WeblogCategory firstCat = rootCat;
374 if (cats != null && cats.trim().length() > 0) {
375 String[] splitcats = cats.split(",");
+ 376 for (int i=0; i<splitcats.length; i++) {
+ 377 WeblogCategory c = new WeblogCategory(
378 newWeblog, // newWeblog
379 rootCat, // parent
380 splitcats[i], // name
381 splitcats[i], // description
382 null ); // image
383 if (i == 0) firstCat = c;
384 this.strategy.store(c);
385 }
386 }
387
388 // Use first category as default for Blogger API
389 newWeblog.setBloggerCategory(firstCat);
390
391 // But default category for weblog itself should be root
392 newWeblog.setDefaultCategory(rootCat);
393
394 this.strategy.store(newWeblog);
395
396 // add default bookmarks
397 WeblogBookmarkFolder root = new WeblogBookmarkFolder(
398 null, "root", "root", newWeblog);
399 this.strategy.store(root);
400
401 Integer zero = new Integer(0);
402 String blogroll = WebloggerConfig.getProperty("newuser.blogroll");
403 if (blogroll != null) {
404 String[] splitroll = blogroll.split(",");
+ 405 for (int i=0; i<splitroll.length; i++) {
+ 406 String[] rollitems = splitroll[i].split("\\|");
407 if (rollitems != null && rollitems.length > 1) {
408 WeblogBookmark b = new WeblogBookmark(
409 root, // parent
410 rollitems[0], // name
411 "", // description
412 rollitems[1].trim(), // url
413 null, // feedurl
414 zero, // weight
415 zero, // priority
416 null); // image
417 this.strategy.store(b);
418 }
419 }
420 }
421
422 // add any auto enabled ping targets
423 PingTargetManager pingTargetMgr = roller
424 .getPingTargetManager();
425 AutoPingManager autoPingMgr = roller
426 .getAutopingManager();
427
428 Iterator pingTargets = pingTargetMgr.getCommonPingTargets().iterator();
429 PingTarget pingTarget = null;
430 while(pingTargets.hasNext()) {
431 pingTarget = (PingTarget) pingTargets.next();
432
433 if(pingTarget.isAutoEnabled()) {
434 AutoPing autoPing = new AutoPing(
435 null, pingTarget, newWeblog);
436 autoPingMgr.saveAutoPing(autoPing);
437 }
438 }
439 }
440
441 /**
442 * Creates and stores a pending WeblogPermission for user and website specified.
443 * TODO BACKEND: do we really need this? can't we just use storePermissions()?
444 */
445 public WeblogPermission inviteUser(Weblog website,
446 User user, short mask) throws WebloggerException {
447
/*
P/P * Method: WeblogPermission inviteUser(Weblog, User, short)
*
* Preconditions:
* this.strategy != null
* this.strategy.threadLocalEntityManager != null
* user != null
* website != null
* (soft) this.strategy.emf != null
*
* Postconditions:
* return_value == &new WeblogPermission(inviteUser#1)
* new WeblogPermission(inviteUser#1) num objects == 1
*/
448 if (website == null) throw new WebloggerException("Website cannot be null");
449 if (user == null) throw new WebloggerException("User cannot be null");
450
451 WeblogPermission perms = new WeblogPermission();
452 perms.setWebsite(website);
453 perms.setUser(user);
454 perms.setPermissionMask(mask);
455 savePermissions(perms);
456
457 return perms;
458 }
459
460 /**
461 * Remove user permissions from a website.
462 *
463 * TODO: replace this with a domain model method like weblog.retireUser(user)
464 */
465 public void retireUser(Weblog website, User user) throws WebloggerException {
466
/*
P/P * Method: void retireUser(Weblog, User)
*
* Preconditions:
* user != null
* website != null
* (soft) this.strategy != null
* (soft) this.strategy.emf != null
* (soft) this.strategy.threadLocalEntityManager != null
*
* Presumptions:
* java.util.Iterator:next(...)@473 != null
* org.apache.roller.weblogger.pojos.User:getId(...)@474 != null
* org.apache.roller.weblogger.pojos.Weblog:getPermissions(...)@470 != null
* org.apache.roller.weblogger.pojos.WeblogPermission:getUser(...)@474 != null
*
* Test Vectors:
* java.lang.String:equals(...)@474: {0}, {1}
* java.util.Iterator:hasNext(...)@472: {0}, {1}
*/
467 if (website == null) throw new WebloggerException("Website cannot be null");
468 if (user == null) throw new WebloggerException("User cannot be null");
469
470 Iterator perms = website.getPermissions().iterator();
471 WeblogPermission target = null;
472 while (perms.hasNext()) {
473 WeblogPermission pd = (WeblogPermission)perms.next();
474 if (pd.getUser().getId().equals(user.getId())) {
475 target = pd;
476 break;
477 }
478 }
+ 479 if (target == null) throw new WebloggerException("User not member of website");
480
481 website.removePermission(target);
482 this.strategy.remove(target);
483 }
484
485 public void revokeRole(String roleName, User user) throws WebloggerException {
/*
P/P * Method: void revokeRole(String, User)
*
* Preconditions:
* user != null
* (soft) this.strategy != null
* (soft) this.strategy.emf != null
* (soft) this.strategy.threadLocalEntityManager != null
*
* Presumptions:
* java.util.Iterator:next(...)@489 != null
* org.apache.roller.weblogger.pojos.User:getRoles(...)@486 != null
* org.apache.roller.weblogger.pojos.UserRole:getRole(...)@490 != null
*
* Test Vectors:
* java.lang.String:equals(...)@490: {0}, {1}
* java.util.Iterator:hasNext(...)@488: {0}, {1}
*/
486 Collection roles = user.getRoles();
487 Iterator iter = roles.iterator();
488 while (iter.hasNext()) {
489 UserRole role = (UserRole) iter.next();
490 if (role.getRole().equals(roleName)) {
491 this.strategy.remove(role);
492 iter.remove();
493 }
494 }
495 }
496
497 public Weblog getWebsite(String id) throws WebloggerException {
/*
P/P * Method: Weblog getWebsite(String)
*
* Preconditions:
* this.strategy != null
* this.strategy.threadLocalEntityManager != null
* (soft) this.strategy.emf != null
*
* Postconditions:
* init'ed(return_value)
*/
498 return (Weblog) this.strategy.load(Weblog.class, id);
499 }
500
501 public Weblog getWebsiteByHandle(String handle) throws WebloggerException {
/*
P/P * Method: Weblog getWebsiteByHandle(String)
*
* Preconditions:
* handle != null
* this.strategy != null
* this.strategy.threadLocalEntityManager != null
* this.weblogHandleToIdMap != null
* (soft) log != null
* (soft) this.strategy.emf != null
*
* Presumptions:
* init'ed(java.lang.Boolean.TRUE)
*
* Postconditions:
* init'ed(return_value)
*/
502 return getWebsiteByHandle(handle, Boolean.TRUE);
503 }
504
505 /**
506 * Return website specified by handle.
507 */
508 public Weblog getWebsiteByHandle(String handle, Boolean enabled)
509 throws WebloggerException {
510
/*
P/P * Method: Weblog getWebsiteByHandle(String, Boolean)
*
* Preconditions:
* handle != null
* this.strategy != null
* this.strategy.threadLocalEntityManager != null
* this.weblogHandleToIdMap != null
* (soft) log != null
* (soft) this.strategy.emf != null
*
* Postconditions:
* init'ed(return_value)
*
* Test Vectors:
* enabled: Addr_Set{null}, Inverse{null}
* java.lang.Boolean:equals(...)@522: {0}, {1}
* java.lang.Boolean:equals(...)@547: {0}, {1}
* java.util.Map:containsKey(...)@516: {0}, {1}
* javax.persistence.EntityManager:find(...)@216: Addr_Set{null}, Inverse{null}
*/
511 if (handle==null )
512 throw new WebloggerException("Handle cannot be null");
513
514 // check cache first
515 // NOTE: if we ever allow changing handles then this needs updating
516 if(this.weblogHandleToIdMap.containsKey(handle)) {
517
518 Weblog weblog = this.getWebsite(
519 (String) this.weblogHandleToIdMap.get(handle));
520 if(weblog != null) {
521 // only return weblog if enabled status matches
522 if(enabled == null || enabled.equals(weblog.getEnabled())) {
523 log.debug("weblogHandleToId CACHE HIT - "+handle);
524 return weblog;
525 }
526 } else {
527 // mapping hit with lookup miss? mapping must be old, remove it
528 this.weblogHandleToIdMap.remove(handle);
529 }
530 }
531
532 Query query = strategy.getNamedQuery("Weblog.getByHandle");
533 query.setParameter(1, handle);
534 Weblog website = null;
535 try {
536 website = (Weblog)query.getSingleResult();
537 } catch (NoResultException e) {
538 website = null;
539 }
540
541 // add mapping to cache
542 if(website != null) {
543 log.debug("weblogHandleToId CACHE MISS - "+handle);
544 this.weblogHandleToIdMap.put(website.getHandle(), website.getId());
545 }
546
547 if(website != null &&
548 (enabled == null || enabled.equals(website.getEnabled()))) {
549 return website;
550 } else {
551 return null;
552 }
553 }
554
555 /**
556 * Get websites of a user
557 */
558 public List getWebsites(
559 User user, Boolean enabled, Boolean active,
560 Date startDate, Date endDate, int offset, int length) throws WebloggerException {
561
562 //if (endDate == null) endDate = new Date();
563
/*
P/P * Method: List getWebsites(User, Boolean, Boolean, Date, Date, int, int)
*
* Preconditions:
* this.strategy != null
* this.strategy.threadLocalEntityManager != null
* (soft) this.strategy.emf != null
*
* Presumptions:
* init'ed(java.lang.Boolean.FALSE)
*
* Postconditions:
* init'ed(return_value)
*
* Test Vectors:
* active: Addr_Set{null}, Inverse{null}
* enabled: Addr_Set{null}, Inverse{null}
* endDate: Addr_Set{null}, Inverse{null}
* length: {-1}, {-231..-2, 0..232-1}
* offset: {0}, {-231..-1, 1..232-1}
* startDate: Addr_Set{null}, Inverse{null}
* user: Inverse{null}, Addr_Set{null}
* java.lang.StringBuffer:length(...)@581: {-231..0}, {1..232-1}
* java.lang.StringBuffer:length(...)@587: {-231..0}, {1..232-1}
* java.lang.StringBuffer:length(...)@592: {-231..0}, {1..232-1}
* ...
*/
564 List params = new ArrayList();
565 int size = 0;
566 StringBuffer queryString = new StringBuffer();
567 StringBuffer whereClause = new StringBuffer();
568
569 //queryString.append("SELECT w FROM Weblog w WHERE ");
570 if (user == null) { // OpenJPA likes JOINs
571 queryString.append("SELECT w FROM Weblog w WHERE ");
572 } else {
573 queryString.append("SELECT w FROM Weblog w JOIN w.permissions p WHERE ");
574 params.add(size++, user);
575 whereClause.append(" p.user = ?" + size);
576 params.add(size++, Boolean.FALSE);
577 whereClause.append(" AND p.pending = ?" + size);
578 }
579 if (startDate != null) {
580 Timestamp start = new Timestamp(startDate.getTime());
581 if (whereClause.length() > 0) whereClause.append(" AND ");
582 params.add(size++, start);
583 whereClause.append(" w.dateCreated > ?" + size);
584 }
585 if (endDate != null) {
586 Timestamp end = new Timestamp(endDate.getTime());
587 if (whereClause.length() > 0) whereClause.append(" AND ");
588 params.add(size++, end);
589 whereClause.append(" w.dateCreated < ?" + size);
590 }
591 if (enabled != null) {
592 if (whereClause.length() > 0) whereClause.append(" AND ");
593 params.add(size++, enabled);
594 whereClause.append(" w.enabled = ?" + size);
595 }
596 if (active != null) {
597 if (whereClause.length() > 0) whereClause.append(" AND ");
598 params.add(size++, active);
599 whereClause.append(" w.active = ?" + size);
600 }
601 /*if (user != null) { // Toplink likes sub-selects
602 if (whereClause.length() > 0) whereClause.append(" AND ");
603 whereClause.append(" EXISTS (SELECT p from WeblogPermission p WHERE p.website = w ");
604 params.add(size++, user);
605 whereClause.append(" AND p.user = ?" + size);
606 params.add(size++, Boolean.FALSE);
607 whereClause.append(" AND p.pending = ?" + size + ")");
608 }*/
609
610 whereClause.append(" ORDER BY w.dateCreated DESC");
611
612 Query query = strategy.getDynamicQuery(queryString.toString() + whereClause.toString());
613 if (offset != 0) {
614 query.setFirstResult(offset);
615 }
616 if (length != -1) {
617 query.setMaxResults(length);
618 }
619 for (int i=0; i<params.size(); i++) {
620 query.setParameter(i+1, params.get(i));
621 }
622
623 return query.getResultList();
624 }
625
626 public User getUser(String id) throws WebloggerException {
/*
P/P * Method: User getUser(String)
*
* Preconditions:
* this.strategy != null
* this.strategy.threadLocalEntityManager != null
* (soft) this.strategy.emf != null
*
* Postconditions:
* init'ed(return_value)
*/
627 return (User)this.strategy.load(User.class, id);
628 }
629
630 public User getUserByUserName(String userName) throws WebloggerException {
/*
P/P * Method: User getUserByUserName(String)
*
* Preconditions:
* this.strategy != null
* this.strategy.threadLocalEntityManager != null
* this.userNameToIdMap != null
* userName != null
* (soft) log != null
* (soft) this.strategy.emf != null
*
* Presumptions:
* init'ed(java.lang.Boolean.TRUE)
*
* Postconditions:
* init'ed(return_value)
*/
631 return getUserByUserName(userName, Boolean.TRUE);
632 }
633
634 public User getUserByUserName(String userName, Boolean enabled)
635 throws WebloggerException {
636
/*
P/P * Method: User getUserByUserName(String, Boolean)
*
* Preconditions:
* this.strategy != null
* this.strategy.threadLocalEntityManager != null
* this.userNameToIdMap != null
* userName != null
* (soft) log != null
* (soft) this.strategy.emf != null
*
* Postconditions:
* init'ed(return_value)
*
* Test Vectors:
* enabled: Addr_Set{null}, Inverse{null}
* java.lang.Boolean:equals(...)@648: {0}, {1}
* java.util.Map:containsKey(...)@642: {0}, {1}
* javax.persistence.EntityManager:find(...)@216: Addr_Set{null}, Inverse{null}
*/
637 if (userName==null )
638 throw new WebloggerException("userName cannot be null");
639
640 // check cache first
641 // NOTE: if we ever allow changing usernames then this needs updating
642 if(this.userNameToIdMap.containsKey(userName)) {
643
644 User user = this.getUser(
645 (String) this.userNameToIdMap.get(userName));
646 if(user != null) {
647 // only return the user if the enabled status matches
648 if(enabled == null || enabled.equals(user.getEnabled())) {
649 log.debug("userNameToIdMap CACHE HIT - "+userName);
650 return user;
651 }
652 } else {
653 // mapping hit with lookup miss? mapping must be old, remove it
654 this.userNameToIdMap.remove(userName);
655 }
656 }
657
658 // cache failed, do lookup
659 Query query;
660 Object[] params;
661 if (enabled != null) {
662 query = strategy.getNamedQuery(
663 "User.getByUserName&Enabled");
664 params = new Object[] {userName, enabled};
665 } else {
666 query = strategy.getNamedQuery(
667 "User.getByUserName");
668 params = new Object[] {userName};
669 }
670 for (int i=0; i<params.length; i++) {
671 query.setParameter(i+1, params[i]);
672 }
673 User user = null;
674 try {
675 user = (User)query.getSingleResult();
676 } catch (NoResultException e) {
677 user = null;
678 }
679
680 // add mapping to cache
681 if(user != null) {
682 log.debug("userNameToIdMap CACHE MISS - "+userName);
683 this.userNameToIdMap.put(user.getUserName(), user.getId());
684 }
685
686 return user;
687 }
688
689 public List getUsers(Weblog weblog, Boolean enabled, Date startDate,
690 Date endDate, int offset, int length)
691 throws WebloggerException {
/*
P/P * Method: List getUsers(Weblog, Boolean, Date, Date, int, int)
*
* Preconditions:
* this.strategy != null
* this.strategy.threadLocalEntityManager != null
* (soft) this.strategy.emf != null
*
* Postconditions:
* init'ed(return_value)
*
* Test Vectors:
* enabled: Addr_Set{null}, Inverse{null}
* endDate: Inverse{null}, Addr_Set{null}
* length: {-1}, {-231..-2, 0..232-1}
* offset: {0}, {-231..-1, 1..232-1}
* startDate: Addr_Set{null}, Inverse{null}
* weblog: Addr_Set{null}, Inverse{null}
* java.lang.StringBuffer:length(...)@714: {-231..-1, 1..232-1}, {0}
* java.lang.StringBuffer:length(...)@724: {-231..-1, 1..232-1}, {0}
*/
692 Query query = null;
693 List results = null;
694
695 // if we are doing date range then we must have an end date
696 if (startDate != null && endDate == null) {
697 endDate = new Date();
698 }
699
700 List params = new ArrayList();
701 int size = 0;
702 StringBuffer queryString = new StringBuffer();
703 StringBuffer whereClause = new StringBuffer();
704
705 if (weblog != null) {
706 queryString.append("SELECT u FROM User u JOIN u.permissions p ");
707 params.add(size++, weblog);
708 whereClause.append(" WHERE p.website = ?" + size);
709 } else {
710 queryString.append("SELECT u FROM User u ");
711 }
712
713 if (enabled != null) {
714 if (whereClause.length() == 0) {
715 whereClause.append(" WHERE ");
716 } else {
717 whereClause.append(" AND ");
718 }
719 params.add(size++, enabled);
720 whereClause.append("u.enabled = ?" + size);
721 }
722
723 if (startDate != null) {
724 if (whereClause.length() == 0) {
725 whereClause.append(" WHERE ");
726 } else {
727 whereClause.append(" AND ");
728 }
729
730 // if we are doing date range then we must have an end date
+ 731 if(endDate == null) {
+ 732 endDate = new Date();
733 }
734 Timestamp start = new Timestamp(startDate.getTime());
735 Timestamp end = new Timestamp(endDate.getTime());
736 params.add(size++, start);
737 whereClause.append("u.dateCreated > ?" + size);
738 params.add(size++, end);
739 whereClause.append(" AND u.dateCreated < ?" + size);
740 }
741 whereClause.append(" ORDER BY u.dateCreated DESC");
742 query = strategy.getDynamicQuery(queryString.toString() + whereClause.toString());
743
744 if (offset != 0) {
745 query.setFirstResult(offset);
746 }
747 if (length != -1) {
748 query.setMaxResults(length);
749 }
750 for (int i=0; i<params.size(); i++) {
751 query.setParameter(i+1, params.get(i));
752 }
753 return query.getResultList();
754 }
755
756 public List getUsers(int offset, int length) throws WebloggerException {
/*
P/P * Method: List getUsers(int, int)
*
* Preconditions:
* this.strategy != null
* this.strategy.threadLocalEntityManager != null
* (soft) this.strategy.emf != null
*
* Presumptions:
* init'ed(java.lang.Boolean.TRUE)
*
* Postconditions:
* init'ed(return_value)
*/
757 return getUsers(Boolean.TRUE, null, null, offset, length);
758 }
759
760 public List getUsers(Boolean enabled, Date startDate, Date endDate,
761 int offset, int length)
762 throws WebloggerException {
/*
P/P * Method: List getUsers(Boolean, Date, Date, int, int)
*
* Preconditions:
* this.strategy != null
* this.strategy.threadLocalEntityManager != null
* (soft) this.strategy.emf != null
*
* Postconditions:
* init'ed(return_value)
*
* Test Vectors:
* enabled: Addr_Set{null}, Inverse{null}
* endDate: Inverse{null}, Addr_Set{null}
* length: {-1}, {-231..-2, 0..232-1}
* offset: {0}, {-231..-1, 1..232-1}
* startDate: Addr_Set{null}, Inverse{null}
*/
763 Query query = null;
764 List results = null;
+ 765 boolean setRange = offset != 0 || length != -1;
766
767 if (endDate == null) endDate = new Date();
768
769 if (enabled != null) {
770 if (startDate != null) {
771 Timestamp start = new Timestamp(startDate.getTime());
772 Timestamp end = new Timestamp(endDate.getTime());
773 query = strategy.getNamedQuery(
774 "User.getByEnabled&EndDate&StartDateOrderByStartDateDesc");
775 query.setParameter(1, enabled);
776 query.setParameter(2, end);
777 query.setParameter(3, start);
778 } else {
779 Timestamp end = new Timestamp(endDate.getTime());
780 query = strategy.getNamedQuery(
781 "User.getByEnabled&EndDateOrderByStartDateDesc");
782 query.setParameter(1, enabled);
783 query.setParameter(2, end);
784 }
785 } else {
786 if (startDate != null) {
787 Timestamp start = new Timestamp(startDate.getTime());
788 Timestamp end = new Timestamp(endDate.getTime());
789 query = strategy.getNamedQuery(
790 "User.getByEndDate&StartDateOrderByStartDateDesc");
791 query.setParameter(1, end);
792 query.setParameter(2, start);
793 } else {
794 Timestamp end = new Timestamp(endDate.getTime());
795 query = strategy.getNamedQuery(
796 "User.getByEndDateOrderByStartDateDesc");
797 query.setParameter(1, end);
798 }
799 }
800 if (offset != 0) {
801 query.setFirstResult(offset);
802 }
803 if (length != -1) {
804 query.setMaxResults(length);
805 }
806 return query.getResultList();
807 }
808
809 /**
810 * Get users of a website
811 */
812 public List getUsers(Weblog website, Boolean enabled, int offset, int length) throws WebloggerException {
/*
P/P * Method: List getUsers(Weblog, Boolean, int, int)
*
* Preconditions:
* this.strategy != null
* this.strategy.threadLocalEntityManager != null
* (soft) this.strategy.emf != null
*
* Postconditions:
* init'ed(return_value)
*
* Test Vectors:
* enabled: Addr_Set{null}, Inverse{null}
* length: {-231..-2, 0..232-1}, {-1}
* offset: {0}, {-231..-1, 1..232-1}
* website: Addr_Set{null}, Inverse{null}
*/
813 Query query = null;
814 List results = null;
+ 815 boolean setRange = offset != 0 || length != -1;
816
817 if (length == -1) {
818 length = Integer.MAX_VALUE - offset;
819 }
820
821 if (enabled != null) {
822 if (website != null) {
823 query = strategy.getNamedQuery("User.getByEnabled&Permissions.website");
824 query.setParameter(1, enabled);
825 query.setParameter(2, website);
826 } else {
827 query = strategy.getNamedQuery("User.getByEnabled");
828 query.setParameter(1, enabled);
829 }
830 } else {
831 if (website != null) {
832 query = strategy.getNamedQuery("User.getByPermissions.website");
833 query.setParameter(1, website);
834 } else {
835 query = strategy.getNamedQuery("User.getAll");
836 }
837 }
838 if (offset != 0) {
839 query.setFirstResult(offset);
840 }
841 if (length != -1) {
842 query.setMaxResults(length);
843 }
844 return query.getResultList();
845 }
846
847 public List getUsersStartingWith(String startsWith, Boolean enabled,
848 int offset, int length) throws WebloggerException {
/*
P/P * Method: List getUsersStartingWith(String, Boolean, int, int)
*
* Preconditions:
* this.strategy != null
* this.strategy.threadLocalEntityManager != null
* (soft) this.strategy.emf != null
*
* Postconditions:
* init'ed(return_value)
*
* Test Vectors:
* enabled: Addr_Set{null}, Inverse{null}
* length: {-1}, {-231..-2, 0..232-1}
* offset: {0}, {-231..-1, 1..232-1}
* startsWith: Addr_Set{null}, Inverse{null}
*/
849 Query query = null;
850
851 if (enabled != null) {
852 if (startsWith != null) {
853 query = strategy.getNamedQuery(
854 "User.getByEnabled&UserNameOrEmailAddressStartsWith");
855 query.setParameter(1, enabled);
856 query.setParameter(2, startsWith + '%');
857 query.setParameter(3, startsWith + '%');
858 } else {
859 query = strategy.getNamedQuery(
860 "User.getByEnabled");
861 query.setParameter(1, enabled);
862 }
863 } else {
864 if (startsWith != null) {
865 query = strategy.getNamedQuery(
866 "User.getByUserNameOrEmailAddressStartsWith");
867 query.setParameter(1, startsWith + '%');
868 } else {
869 query = strategy.getNamedQuery("User.getAll");
870 }
871 }
872 if (offset != 0) {
873 query.setFirstResult(offset);
874 }
875 if (length != -1) {
876 query.setMaxResults(length);
877 }
878 return query.getResultList();
879 }
880
881 public WeblogTemplate getPage(String id) throws WebloggerException {
882 // Don't hit database for templates stored on disk
/*
P/P * Method: WeblogTemplate getPage(String)
*
* Preconditions:
* (soft) this.strategy != null
* (soft) this.strategy.emf != null
* (soft) this.strategy.threadLocalEntityManager != null
*
* Postconditions:
* init'ed(return_value)
*
* Test Vectors:
* id: Addr_Set{null}, Inverse{null}
* java.lang.String:endsWith(...)@883: {0}, {1}
*/
883 if (id != null && id.endsWith(".vm")) return null;
884
885 return (WeblogTemplate)this.strategy.load(WeblogTemplate.class,id);
886 }
887
888 /**
889 * Use JPA directly because Weblogger's Query API does too much allocation.
890 */
891 public WeblogTemplate getPageByLink(Weblog website, String pagelink)
892 throws WebloggerException {
893
/*
P/P * Method: WeblogTemplate getPageByLink(Weblog, String)
*
* Preconditions:
* pagelink != null
* this.strategy != null
* this.strategy.threadLocalEntityManager != null
* website != null
* (soft) this.strategy.emf != null
*
* Postconditions:
* init'ed(return_value)
*/
894 if (website == null)
895 throw new WebloggerException("userName is null");
896
897 if (pagelink == null)
898 throw new WebloggerException("Pagelink is null");
899
900 Query query = strategy.getNamedQuery("WeblogTemplate.getByWebsite&Link");
901 query.setParameter(1, website);
902 query.setParameter(2, pagelink);
903 try {
904 return (WeblogTemplate)query.getSingleResult();
905 } catch (NoResultException e) {
906 return null;
907 }
908 }
909
910 /**
911 * @see org.apache.roller.weblogger.model.UserManager#getPageByAction(Weblog, java.lang.String)
912 */
913 public WeblogTemplate getPageByAction(Weblog website, String action)
914 throws WebloggerException {
915
/*
P/P * Method: WeblogTemplate getPageByAction(Weblog, String)
*
* Preconditions:
* action != null
* this.strategy != null
* this.strategy.threadLocalEntityManager != null
* website != null
* (soft) this.strategy.emf != null
*
* Postconditions:
* init'ed(return_value)
*/
916 if (website == null)
917 throw new WebloggerException("website is null");
918
919 if (action == null)
920 throw new WebloggerException("Action name is null");
921
922
923 Query query = strategy.getNamedQuery("WeblogTemplate.getByAction");
924 query.setParameter(1, website);
925 query.setParameter(2, action);
926 try {
927 return (WeblogTemplate)query.getSingleResult();
928 } catch (NoResultException e) {
929 return null;
930 }
931 }
932
933 /**
934 * @see org.apache.roller.weblogger.model.UserManager#getPageByName(Weblog, java.lang.String)
935 */
936 public WeblogTemplate getPageByName(Weblog website, String pagename)
937 throws WebloggerException {
938
/*
P/P * Method: WeblogTemplate getPageByName(Weblog, String)
*
* Preconditions:
* pagename != null
* this.strategy != null
* this.strategy.threadLocalEntityManager != null
* website != null
* (soft) this.strategy.emf != null
*
* Postconditions:
* init'ed(return_value)
*/
939 if (website == null)
940 throw new WebloggerException("website is null");
941
942 if (pagename == null)
943 throw new WebloggerException("Page name is null");
944
945 Query query = strategy.getNamedQuery("WeblogTemplate.getByWebsite&Name");
946 query.setParameter(1, website);
947 query.setParameter(2, pagename);
948 try {
949 return (WeblogTemplate)query.getSingleResult();
950 } catch (NoResultException e) {
951 return null;
952 }
953 }
954
955 /**
956 * @see org.apache.roller.weblogger.model.UserManager#getPages(Weblog)
957 */
958 public List getPages(Weblog website) throws WebloggerException {
/*
P/P * Method: List getPages(Weblog)
*
* Preconditions:
* this.strategy != null
* this.strategy.threadLocalEntityManager != null
* website != null
* (soft) this.strategy.emf != null
*
* Postconditions:
* init'ed(return_value)
*/
959 if (website == null)
960 throw new WebloggerException("website is null");
961 Query q = strategy.getNamedQuery(
962 "WeblogTemplate.getByWebsiteOrderByName");
963 q.setParameter(1, website);
964 return q.getResultList();
965 }
966
967 public WeblogPermission getPermissions(String inviteId)
968 throws WebloggerException {
/*
P/P * Method: WeblogPermission getPermissions(String)
*
* Preconditions:
* this.strategy != null
* this.strategy.threadLocalEntityManager != null
* (soft) this.strategy.emf != null
*
* Postconditions:
* init'ed(return_value)
*/
969 return (WeblogPermission)this.strategy.load(
970 WeblogPermission.class, inviteId);
971 }
972
973 /**
974 * Return permissions for specified user in website
975 */
976 public WeblogPermission getPermissions(
977 Weblog website, User user) throws WebloggerException {
/*
P/P * Method: WeblogPermission getPermissions(Weblog, User)
*
* Preconditions:
* this.strategy != null
* this.strategy.threadLocalEntityManager != null
* (soft) this.strategy.emf != null
*
* Postconditions:
* init'ed(return_value)
*/
978 Query q = strategy.getNamedQuery(
979 "WeblogPermission.getByWebsiteAndUser");
980 q.setParameter(1, website);
981 q.setParameter(2, user);
982 try {
983 return (WeblogPermission)q.getSingleResult();
984 } catch (NoResultException e) {
985 return null;
986 }
987 }
988
989 /**
990 * Get pending permissions for user
991 */
992 public List getPendingPermissions(User user) throws WebloggerException {
/*
P/P * Method: List getPendingPermissions(User)
*
* Preconditions:
* this.strategy != null
* this.strategy.threadLocalEntityManager != null
* (soft) this.strategy.emf != null
*
* Presumptions:
* init'ed(java.lang.Boolean.TRUE)
*
* Postconditions:
* init'ed(return_value)
*/
993 Query q = strategy.getNamedQuery(
994 "WeblogPermission.getByUserAndPending");
995 q.setParameter(1, user);
996 q.setParameter(2, Boolean.TRUE);
997 return q.getResultList();
998 }
999
1000 /**
1001 * Get pending permissions for website
1002 */
1003 public List getPendingPermissions(Weblog website) throws WebloggerException {
/*
P/P * Method: List getPendingPermissions(Weblog)
*
* Preconditions:
* this.strategy != null
* this.strategy.threadLocalEntityManager != null
* (soft) this.strategy.emf != null
*
* Presumptions:
* init'ed(java.lang.Boolean.TRUE)
*
* Postconditions:
* init'ed(return_value)
*/
1004 Query q = strategy.getNamedQuery(
1005 "WeblogPermission.getByWebsiteAndPending");
1006 q.setParameter(1, website);
1007 q.setParameter(2, Boolean.TRUE);
1008 return q.getResultList();
1009 }
1010
1011 /**
1012 * Get all permissions of a website (pendings not including)
1013 */
1014 public List getAllPermissions(Weblog website) throws WebloggerException {
/*
P/P * Method: List getAllPermissions(Weblog)
*
* Preconditions:
* this.strategy != null
* this.strategy.threadLocalEntityManager != null
* (soft) this.strategy.emf != null
*
* Presumptions:
* init'ed(java.lang.Boolean.FALSE)
*
* Postconditions:
* init'ed(return_value)
*/
1015 Query q = strategy.getNamedQuery(
1016 "WeblogPermission.getByWebsiteAndPending");
1017 q.setParameter(1, website);
1018 q.setParameter(2, Boolean.FALSE);
1019 return q.getResultList();
1020 }
1021
1022 /**
1023 * Get all permissions of a user.
1024 */
1025 public List getAllPermissions(User user) throws WebloggerException {
/*
P/P * Method: List getAllPermissions(User)
*
* Preconditions:
* this.strategy != null
* this.strategy.threadLocalEntityManager != null
* (soft) this.strategy.emf != null
*
* Presumptions:
* init'ed(java.lang.Boolean.FALSE)
*
* Postconditions:
* init'ed(return_value)
*/
1026 Query q = strategy.getNamedQuery(
1027 "WeblogPermission.getByUserAndPending");
1028 q.setParameter(1, user);
1029 q.setParameter(2, Boolean.FALSE);
1030 return q.getResultList();
1031 }
1032
/*
P/P * Method: void release()
*/
1033 public void release() {}
1034
1035 public Map getUserNameLetterMap() throws WebloggerException {
/*
P/P * Method: Map getUserNameLetterMap()
*
* Preconditions:
* this.strategy != null
* this.strategy.threadLocalEntityManager != null
* (soft) this.strategy.emf != null
*
* Presumptions:
* javax.persistence.Query:getResultList(...)@1043 != null
*
* Postconditions:
* return_value == &new TreeMap(getUserNameLetterMap#1)
* new TreeMap(getUserNameLetterMap#1) num objects == 1
*/
1036 String lc = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
1037 Map results = new TreeMap();
1038 Query query = strategy.getNamedQuery(
1039 "User.getCountByUserNameLike");
1040 for (int i=0; i<26; i++) {
1041 char currentChar = lc.charAt(i);
1042 query.setParameter(1, currentChar + "%");
1043 List row = query.getResultList();
1044 Long count = (Long) row.get(0);
1045 results.put(String.valueOf(currentChar), count);
1046 }
1047 return results;
1048 }
1049
1050 public List getUsersByLetter(char letter, int offset, int length)
1051 throws WebloggerException {
/*
P/P * Method: List getUsersByLetter(char, int, int)
*
* Preconditions:
* this.strategy != null
* this.strategy.threadLocalEntityManager != null
* (soft) this.strategy.emf != null
*
* Postconditions:
* init'ed(return_value)
*
* Test Vectors:
* length: {-1}, {-231..-2, 0..232-1}
* offset: {0}, {-231..-1, 1..232-1}
*/
1052 Query query = strategy.getNamedQuery(
1053 "User.getByUserNameOrderByUserName");
1054 query.setParameter(1, letter + "%");
1055 if (offset != 0) {
1056 query.setFirstResult(offset);
1057 }
1058 if (length != -1) {
1059 query.setMaxResults(length);
1060 }
1061 return query.getResultList();
1062 }
1063
1064 public Map getWeblogHandleLetterMap() throws WebloggerException {
/*
P/P * Method: Map getWeblogHandleLetterMap()
*
* Preconditions:
* this.strategy != null
* this.strategy.threadLocalEntityManager != null
* (soft) this.strategy.emf != null
*
* Presumptions:
* javax.persistence.Query:getResultList(...)@1072 != null
*
* Postconditions:
* return_value == &new TreeMap(getWeblogHandleLetterMap#1)
* new TreeMap(getWeblogHandleLetterMap#1) num objects == 1
*/
1065 String lc = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
1066 Map results = new TreeMap();
1067 Query query = strategy.getNamedQuery(
1068 "Weblog.getCountByHandleLike");
1069 for (int i=0; i<26; i++) {
1070 char currentChar = lc.charAt(i);
1071 query.setParameter(1, currentChar + "%");
1072 List row = query.getResultList();
1073 Long count = (Long) row.get(0);
1074 results.put(String.valueOf(currentChar), count);
1075 }
1076 return results;
1077 }
1078
1079 public List getWeblogsByLetter(char letter, int offset, int length)
1080 throws WebloggerException {
/*
P/P * Method: List getWeblogsByLetter(char, int, int)
*
* Preconditions:
* this.strategy != null
* this.strategy.threadLocalEntityManager != null
* (soft) this.strategy.emf != null
*
* Postconditions:
* init'ed(return_value)
*
* Test Vectors:
* length: {-1}, {-231..-2, 0..232-1}
* offset: {0}, {-231..-1, 1..232-1}
*/
1081 Query query = strategy.getNamedQuery(
1082 "Weblog.getByLetterOrderByHandle");
1083 query.setParameter(1, letter + "%");
1084 if (offset != 0) {
1085 query.setFirstResult(offset);
1086 }
1087 if (length != -1) {
1088 query.setMaxResults(length);
1089 }
1090 return query.getResultList();
1091 }
1092
1093 public List getMostCommentedWebsites(Date startDate, Date endDate,
1094 int offset, int length)
1095 throws WebloggerException {
1096
/*
P/P * Method: List getMostCommentedWebsites(Date, Date, int, int)
*
* Preconditions:
* this.strategy != null
* this.strategy.threadLocalEntityManager != null
* (soft) this.strategy.emf != null
*
* Presumptions:
* java.util.Iterator:next(...)@1123 != null
* javax.persistence.Query:getResultList(...)@1120 != null
* row.length@1123 >= 4
*
* Postconditions:
* return_value == &new ArrayList(getMostCommentedWebsites#5)
* new ArrayList(getMostCommentedWebsites#5) num objects == 1
*
* Test Vectors:
* endDate: Inverse{null}, Addr_Set{null}
* length: {-1}, {-231..-2, 0..232-1}
* offset: {0}, {-231..-1, 1..232-1}
* startDate: Addr_Set{null}, Inverse{null}
* java.util.Iterator:hasNext(...)@1122: {0}, {1}
*/
1097 Query query = null;
1098
1099 if (endDate == null) endDate = new Date();
1100
1101 if (startDate != null) {
1102 Timestamp start = new Timestamp(startDate.getTime());
1103 Timestamp end = new Timestamp(endDate.getTime());
1104 query = strategy.getNamedQuery(
1105 "WeblogEntryComment.getMostCommentedWebsiteByEndDate&StartDate");
1106 query.setParameter(1, end);
1107 query.setParameter(2, start);
1108 } else {
1109 Timestamp end = new Timestamp(endDate.getTime());
1110 query = strategy.getNamedQuery(
1111 "WeblogEntryComment.getMostCommentedWebsiteByEndDate");
1112 query.setParameter(1, end);
1113 }
1114 if (offset != 0) {
1115 query.setFirstResult(offset);
1116 }
1117 if (length != -1) {
1118 query.setMaxResults(length);
1119 }
1120 List queryResults = query.getResultList();
1121 List results = new ArrayList();
1122 for (Iterator iter = queryResults.iterator(); iter.hasNext();) {
1123 Object[] row = (Object[]) iter.next();
+ 1124 results.add(new StatCount(
1125 (String)row[1], // website id
1126 (String)row[2], // website handle
1127 (String)row[3], // website name
1128 "statCount.weblogCommentCountType", // stat type
1129 ((Long)row[0]).longValue())); // # comments
1130 }
1131 // Original query ordered by desc # comments.
1132 // JPA QL doesn't allow queries to be ordered by agregates; do it in memory
1133 Collections.sort(results, statCountCountReverseComparator);
1134
1135 return results;
1136 }
1137
1138 /**
1139 * Get count of weblogs, active and inactive
1140 */
1141 public long getWeblogCount() throws WebloggerException {
/*
P/P * Method: long getWeblogCount()
*
* Preconditions:
* this.strategy != null
* this.strategy.threadLocalEntityManager != null
* (soft) this.strategy.emf != null
*
* Presumptions:
* java.util.List:get(...)@1146 != null
* javax.persistence.Query:getResultList(...)@1143 != null
*
* Postconditions:
* init'ed(return_value)
*/
1142 long ret = 0;
1143 List results = strategy.getNamedQuery(
1144 "Weblog.getCountAllDistinct").getResultList();
1145
1146 ret = ((Long)results.get(0)).longValue();
1147
1148 return ret;
1149 }
1150
1151
1152 /**
1153 * Get count of users, enabled only
1154 */
1155 public long getUserCount() throws WebloggerException {
/*
P/P * Method: long getUserCount()
*
* Preconditions:
* this.strategy != null
* this.strategy.threadLocalEntityManager != null
* (soft) this.strategy.emf != null
*
* Presumptions:
* init'ed(java.lang.Boolean.TRUE)
* java.util.List:get(...)@1160 != null
* javax.persistence.Query:getResultList(...)@1159 != null
*
* Postconditions:
* init'ed(return_value)
*/
1156 long ret = 0;
1157 Query q = strategy.getNamedQuery("User.getCountEnabledDistinct");
1158 q.setParameter(1, Boolean.TRUE);
1159 List results = q.getResultList();
1160 ret =((Long)results.get(0)).longValue();
1161
1162 return ret;
1163 }
1164
1165 public User getUserByActivationCode(String activationCode) throws WebloggerException {
/*
P/P * Method: User getUserByActivationCode(String)
*
* Preconditions:
* activationCode != null
* this.strategy != null
* this.strategy.threadLocalEntityManager != null
* (soft) this.strategy.emf != null
*
* Postconditions:
* init'ed(return_value)
*/
1166 if (activationCode == null)
1167 throw new WebloggerException("activationcode is null");
1168 Query q = strategy.getNamedQuery("User.getUserByActivationCode");
1169 q.setParameter(1, activationCode);
1170 try {
1171 return (User)q.getSingleResult();
1172 } catch (NoResultException e) {
1173 return null;
1174 }
1175 }
1176 }
1177
SofCheck Inspector Build Version : 2.18479
| JPAUserManagerImpl.java |
2009-Jan-02 14:25:40 |
| JPAUserManagerImpl.class |
2009-Sep-04 03:12:31 |