Coverage Report

Coverage Report - net.sourceforge.pebble.web.action.ManageResponsesAction

Classes in this File

3/56

0/28

 /*
  * Copyright (c) 2003-2011, Simon Brown
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *   - Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  *
  *   - Redistributions in binary form must reproduce the above copyright
  *     notice, this list of conditions and the following disclaimer in
  *     the documentation and/or other materials provided with the
  *     distribution.
  *
  *   - Neither the name of Pebble nor the names of its contributors may
  *     be used to endorse or promote products derived from this software
  *     without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
 package net.sourceforge.pebble.web.action;
 
 import net.sourceforge.pebble.Constants;
 import net.sourceforge.pebble.domain.*;
 import net.sourceforge.pebble.web.security.RequireSecurityToken;
 import net.sourceforge.pebble.web.view.ForwardView;
 import net.sourceforge.pebble.web.view.RedirectView;
 import net.sourceforge.pebble.web.view.View;
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 
 import javax.servlet.ServletException;
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 
 /**
  * Allows the user to manage recently added responses.
  *
  * @author    Simon Brown
  */
 @RequireSecurityToken
 public class ManageResponsesAction extends SecureAction {
 
   /** the log used by this class */
   private static final Log log = LogFactory.getLog(ManageResponsesAction.class);
 
   /** constant used to represent a comment */
   private static final String COMMENT = "c";
 
   /** constant used to represent a TrackBack */
   private static final String TRACKBACK = "t";
 
   /**
    * Peforms the processing associated with this action.
    *
    * @param request  the HttpServletRequest instance
    * @param response the HttpServletResponse instance
    * @return the name of the next view
    */
   public View process(HttpServletRequest request, HttpServletResponse response) throws ServletException {
     Blog blog = (Blog)getModel().get(Constants.BLOG_KEY);
     String ids[] = request.getParameterValues("response");
     String submit = request.getParameter("submit");
     BlogService service = new BlogService();
 
     if (ids != null && submit != null) {
       for (String id : ids) {
         Response ber = getBlogEntryResponse(blog, id);
 
         if (ber == null) {
           continue;
         }
 
         if (submit.equalsIgnoreCase("Approve")) {
           try {
             ber.setApproved();
             service.putBlogEntry(ber.getBlogEntry());
             blog.info("Response <a href=\"" + ber.getPermalink() + "\">" + ber.getTitle() + " (" + ber.getSourceName() + ")</a> approved.");
           } catch (BlogServiceException be) {
             log.error("Error updating state for response", be);
           }
         } else if (submit.equalsIgnoreCase("Reject")) {
           try {
             ber.setRejected();
             service.putBlogEntry(ber.getBlogEntry());
             blog.info("Response \"" + ber.getTitle() + "\" (" + ber.getSourceName() + ") rejected.");
           } catch (BlogServiceException be) {
             log.error("Error updating state for response", be);
           }
         } else if (submit.equalsIgnoreCase("Remove")) {
           try {
             ber.getBlogEntry().removeResponse(ber);
             service.putBlogEntry(ber.getBlogEntry());
             blog.info("Response \"" + ber.getTitle() + "\" (" + ber.getSourceName() + ") removed.");
           } catch (BlogServiceException be) {
             log.error("Error updating state for response", be);
           }
         }
 
       }
     }
 
     String redirectUrl = request.getParameter("redirectUrl");
     if (redirectUrl != null && redirectUrl.trim().length() > 0) {
       return new RedirectView(redirectUrl);
     } else {
       return new ForwardView("/viewResponses.secureaction");
     }
   }
 
   /**
    * Gets a list of all roles that are allowed to access this action.
    *
    * @return  an array of Strings representing role names
    * @param request
    */
   public String[] getRoles(HttpServletRequest request) {
     return new String[]{Constants.BLOG_CONTRIBUTOR_ROLE};
   }
 
   private Response getBlogEntryResponse(Blog blog, String guid) throws ServletException {
     // response key is of the form type/blogEntryId/responseId
     String type = guid.substring(0, 1);
     String blogEntryId = guid.substring(2, guid.indexOf("/", 2));
     String responseId = guid.substring(guid.lastIndexOf("/")+1);
 
     BlogService service = new BlogService();
     BlogEntry blogEntry = null;
     try {
       blogEntry = service.getBlogEntry(blog, blogEntryId);
     } catch (BlogServiceException e) {
       throw new ServletException(e);
     }
     if (blogEntry == null) {
       return null;
     }
 
     try {
       if (type != null && type.equalsIgnoreCase(COMMENT)) {
         return blogEntry.getComment(Long.parseLong(responseId));
       } else if (type != null && type.equalsIgnoreCase(TRACKBACK)) {
         return blogEntry.getTrackBack(Long.parseLong(responseId));
       }
     } catch (NumberFormatException e) {
       log.warn(e);
     }
 
     return null;
   }
 
 }

1		/*
2		* Copyright (c) 2003-2011, Simon Brown
3		* All rights reserved.
4		*
5		* Redistribution and use in source and binary forms, with or without
6		* modification, are permitted provided that the following conditions are met:
7		*
8		* - Redistributions of source code must retain the above copyright
9		* notice, this list of conditions and the following disclaimer.
10		*
11		* - Redistributions in binary form must reproduce the above copyright
12		* notice, this list of conditions and the following disclaimer in
13		* the documentation and/or other materials provided with the
14		* distribution.
15		*
16		* - Neither the name of Pebble nor the names of its contributors may
17		* be used to endorse or promote products derived from this software
18		* without specific prior written permission.
19		*
20		* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
21		* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22		* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23		* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
24		* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25		* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26		* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27		* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28		* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29		* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30		* POSSIBILITY OF SUCH DAMAGE.
31		*/
32		package net.sourceforge.pebble.web.action;
33
34		import net.sourceforge.pebble.Constants;
35		import net.sourceforge.pebble.domain.*;
36		import net.sourceforge.pebble.web.security.RequireSecurityToken;
37		import net.sourceforge.pebble.web.view.ForwardView;
38		import net.sourceforge.pebble.web.view.RedirectView;
39		import net.sourceforge.pebble.web.view.View;
40		import org.apache.commons.logging.Log;
41		import org.apache.commons.logging.LogFactory;
42
43		import javax.servlet.ServletException;
44		import javax.servlet.http.HttpServletRequest;
45		import javax.servlet.http.HttpServletResponse;
46
47		/**
48		* Allows the user to manage recently added responses.
49		*
50		* @author Simon Brown
51		*/
52		@RequireSecurityToken
53	4	public class ManageResponsesAction extends SecureAction {
54
55		/** the log used by this class */
56	4	private static final Log log = LogFactory.getLog(ManageResponsesAction.class);
57
58		/** constant used to represent a comment */
59		private static final String COMMENT = "c";
60
61		/** constant used to represent a TrackBack */
62		private static final String TRACKBACK = "t";
63
64		/**
65		* Peforms the processing associated with this action.
66		*
67		* @param request the HttpServletRequest instance
68		* @param response the HttpServletResponse instance
69		* @return the name of the next view
70		*/
71		public View process(HttpServletRequest request, HttpServletResponse response) throws ServletException {
72	0	Blog blog = (Blog)getModel().get(Constants.BLOG_KEY);
73	0	String ids[] = request.getParameterValues("response");
74	0	String submit = request.getParameter("submit");
75	0	BlogService service = new BlogService();
76
77	0	if (ids != null && submit != null) {
78	0	for (String id : ids) {
79	0	Response ber = getBlogEntryResponse(blog, id);
80
81	0	if (ber == null) {
82	0	continue;
83		}
84
85	0	if (submit.equalsIgnoreCase("Approve")) {
86		try {
87	0	ber.setApproved();
88	0	service.putBlogEntry(ber.getBlogEntry());
89	0	blog.info("Response <a href=\"" + ber.getPermalink() + "\">" + ber.getTitle() + " (" + ber.getSourceName() + ")</a> approved.");
90	0	} catch (BlogServiceException be) {
91	0	log.error("Error updating state for response", be);
92	0	}
93	0	} else if (submit.equalsIgnoreCase("Reject")) {
94		try {
95	0	ber.setRejected();
96	0	service.putBlogEntry(ber.getBlogEntry());
97	0	blog.info("Response \"" + ber.getTitle() + "\" (" + ber.getSourceName() + ") rejected.");
98	0	} catch (BlogServiceException be) {
99	0	log.error("Error updating state for response", be);
100	0	}
101	0	} else if (submit.equalsIgnoreCase("Remove")) {
102		try {
103	0	ber.getBlogEntry().removeResponse(ber);
104	0	service.putBlogEntry(ber.getBlogEntry());
105	0	blog.info("Response \"" + ber.getTitle() + "\" (" + ber.getSourceName() + ") removed.");
106	0	} catch (BlogServiceException be) {
107	0	log.error("Error updating state for response", be);
108	0	}
109		}
110
111		}
112		}
113
114	0	String redirectUrl = request.getParameter("redirectUrl");
115	0	if (redirectUrl != null && redirectUrl.trim().length() > 0) {
116	0	return new RedirectView(redirectUrl);
117		} else {
118	0	return new ForwardView("/viewResponses.secureaction");
119		}
120		}
121
122		/**
123		* Gets a list of all roles that are allowed to access this action.
124		*
125		* @return an array of Strings representing role names
126		* @param request
127		*/
128		public String[] getRoles(HttpServletRequest request) {
129	4	return new String[]{Constants.BLOG_CONTRIBUTOR_ROLE};
130		}
131
132		private Response getBlogEntryResponse(Blog blog, String guid) throws ServletException {
133		// response key is of the form type/blogEntryId/responseId
134	0	String type = guid.substring(0, 1);
135	0	String blogEntryId = guid.substring(2, guid.indexOf("/", 2));
136	0	String responseId = guid.substring(guid.lastIndexOf("/")+1);
137
138	0	BlogService service = new BlogService();
139	0	BlogEntry blogEntry = null;
140		try {
141	0	blogEntry = service.getBlogEntry(blog, blogEntryId);
142	0	} catch (BlogServiceException e) {
143	0	throw new ServletException(e);
144	0	}
145	0	if (blogEntry == null) {
146	0	return null;
147		}
148
149		try {
150	0	if (type != null && type.equalsIgnoreCase(COMMENT)) {
151	0	return blogEntry.getComment(Long.parseLong(responseId));
152	0	} else if (type != null && type.equalsIgnoreCase(TRACKBACK)) {
153	0	return blogEntry.getTrackBack(Long.parseLong(responseId));
154		}
155	0	} catch (NumberFormatException e) {
156	0	log.warn(e);
157	0	}
158
159	0	return null;
160		}
161
162		}