KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > apache > roller > ui > authoring > struts > actions > WeblogTemplateFormAction


1 /*
2  * Licensed to the Apache Software Foundation (ASF) under one or more
3  * contributor license agreements. The ASF licenses this file to You
4  * under the Apache License, Version 2.0 (the "License"); you may not
5  * use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License. For additional information regarding
15  * copyright in this work, please see the NOTICE file in the top level
16  * directory of this distribution.
17  */

18
19 package org.apache.roller.ui.authoring.struts.actions;
20
21 import java.io.IOException JavaDoc;
22 import java.util.Date JavaDoc;
23 import java.util.List JavaDoc;
24 import java.util.ResourceBundle JavaDoc;
25
26 import javax.servlet.ServletException JavaDoc;
27 import javax.servlet.http.HttpServletRequest JavaDoc;
28 import javax.servlet.http.HttpServletResponse JavaDoc;
29
30 import org.apache.commons.lang.StringUtils;
31
32 import org.apache.commons.logging.Log;
33 import org.apache.commons.logging.LogFactory;
34 import org.apache.roller.RollerException;
35 import org.apache.roller.RollerPermissionsException;
36 import org.apache.roller.model.RollerFactory;
37 import org.apache.roller.model.UserManager;
38 import org.apache.roller.pojos.UserData;
39 import org.apache.roller.pojos.WeblogTemplate;
40 import org.apache.roller.pojos.WebsiteData;
41 import org.apache.roller.ui.authoring.struts.forms.WeblogTemplateForm;
42 import org.apache.roller.ui.core.BasePageModel;
43 import org.apache.roller.ui.core.RollerRequest;
44 import org.apache.roller.ui.core.RollerSession;
45 import org.apache.roller.util.Utilities;
46 import org.apache.roller.util.cache.CacheManager;
47 import org.apache.struts.action.ActionError;
48 import org.apache.struts.action.ActionErrors;
49 import org.apache.struts.action.ActionForm;
50 import org.apache.struts.action.ActionForward;
51 import org.apache.struts.action.ActionMapping;
52 import org.apache.struts.action.ActionMessage;
53 import org.apache.struts.action.ActionMessages;
54 import org.apache.struts.actions.DispatchAction;
55
56 /////////////////////////////////////////////////////////////////////////////
57
/**
58  * Page form action.
59  * @struts.action name="weblogTemplateForm" path="/roller-ui/authoring/page"
60  * scope="session" parameter="method"
61  *
62  * @struts.action-forward name="removePage.page" path=".remove-page"
63  * @struts.action-forward name="editPage.page" path=".edit-page"
64  * @struts.action-forward name="editPages.page" path=".edit-pages"
65  */

66 public final class WeblogTemplateFormAction extends DispatchAction {
67     protected static ResourceBundle JavaDoc bundle =
68         ResourceBundle.getBundle("ApplicationResources");
69     private static Log mLogger =
70             LogFactory.getFactory().getInstance(WeblogTemplateFormAction.class);
71     
72     public ActionForward add(
73             ActionMapping mapping,
74             ActionForm actionForm,
75             HttpServletRequest JavaDoc request,
76             HttpServletResponse JavaDoc response)
77             throws IOException JavaDoc, ServletException JavaDoc {
78         ActionForward forward = mapping.findForward("editPages.page");
79         try {
80             request.setAttribute("model", new BasePageModel(
81                     "pagesForm.title", request, response, mapping));
82             RollerRequest rreq = RollerRequest.getRollerRequest(request);
83             RollerSession rses = RollerSession.getRollerSession(request);
84             WebsiteData website = rreq.getWebsite();
85             if ( rses.isUserAuthorizedToAdmin(website) ) {
86                 WeblogTemplateForm form = (WeblogTemplateForm)actionForm;
87                 WeblogTemplate data = new WeblogTemplate();
88                 form.copyTo(data, request.getLocale());
89                 data.setWebsite(website);
90                 data.setLastModified( new Date JavaDoc() );
91                 data.setDescription(data.getName());
92                 data.setContents(bundle.getString("pageForm.newTemplateContent"));
93                 validateLink( data );
94                 
95                 // all templates start out as velocity templates
96
data.setTemplateLanguage("velocity");
97                 
98                 // for now, all templates just use _decorator
99
if(!"_decorator".equals(data.getName())) {
100                     data.setDecoratorName("_decorator");
101                 }
102                 
103                 UserManager mgr = RollerFactory.getRoller().getUserManager();
104                 mgr.savePage( data );
105                 RollerFactory.getRoller().flush();
106                 
107                 ActionMessages uiMessages = new ActionMessages();
108                 uiMessages.add(ActionMessages.GLOBAL_MESSAGE,
109                         new ActionMessage("pagesForm.addNewPage.success",
110                         data.getName()));
111                 saveMessages(request, uiMessages);
112                 
113                 actionForm.reset(mapping,request);
114                 
115                 addModelObjects(request, response, mapping, website, data);
116             } else {
117                 forward = mapping.findForward("access-denied");
118             }
119         } catch (Exception JavaDoc e) {
120             mLogger.error("ERROR in action",e);
121             throw new ServletException JavaDoc(e);
122         }
123         return forward;
124     }
125     
126     //-----------------------------------------------------------------------
127
public ActionForward edit(
128             ActionMapping mapping,
129             ActionForm actionForm,
130             HttpServletRequest JavaDoc request,
131             HttpServletResponse JavaDoc response)
132             throws IOException JavaDoc, ServletException JavaDoc {
133         ActionForward forward = mapping.findForward("editPage.page");
134         try {
135             RollerRequest rreq = RollerRequest.getRollerRequest(request);
136             WeblogTemplate pd = (WeblogTemplate)rreq.getPage();
137             
138             RollerSession rses = RollerSession.getRollerSession(request);
139             if ( rses.isUserAuthorizedToAdmin(pd.getWebsite()) ) {
140                 BasePageModel pageModel = new BasePageModel(
141                         "pageForm.title", request, response, mapping);
142                 pageModel.setWebsite(pd.getWebsite());
143                 request.setAttribute("model", pageModel);
144                 
145                 WeblogTemplateForm pf = (WeblogTemplateForm)actionForm;
146                 pf.copyFrom(pd, request.getLocale());
147                 
148                 addModelObjects(request, response, mapping, pd.getWebsite(), pd);
149             } else {
150                 forward = mapping.findForward("access-denied");
151             }
152         } catch (Exception JavaDoc e) {
153             mLogger.error("ERROR in action",e);
154             throw new ServletException JavaDoc(e);
155         }
156         return forward;
157     }
158     
159     //-----------------------------------------------------------------------
160
public ActionForward editPages(
161             ActionMapping mapping,
162             ActionForm actionForm,
163             HttpServletRequest JavaDoc request,
164             HttpServletResponse JavaDoc response)
165             throws IOException JavaDoc, ServletException JavaDoc {
166         ActionForward forward = mapping.findForward("editPages.page");
167         try {
168             WeblogTemplateForm form = (WeblogTemplateForm)actionForm;
169             RollerRequest rreq = RollerRequest.getRollerRequest(request);
170             RollerSession rses = RollerSession.getRollerSession(request);
171             request.setAttribute("model", new BasePageModel(
172                     "pagesForm.title", request, response, mapping));
173             
174             WebsiteData website = rreq.getWebsite();
175             if (website == null && form.getId()!=null) {
176                 UserManager mgr = RollerFactory.getRoller().getUserManager();
177                 WeblogTemplate template = mgr.getPage(form.getId());
178                 website = template.getWebsite();
179             }
180             
181             if ( rses.isUserAuthorizedToAdmin(website)) {
182                 addModelObjects(request, response, mapping, website, null);
183             } else {
184                 forward = mapping.findForward("access-denied");
185             }
186         } catch (Exception JavaDoc e) {
187             mLogger.error("ERROR in action",e);
188             throw new ServletException JavaDoc(e);
189         }
190         return forward;
191     }
192     
193     //-----------------------------------------------------------------------
194
public ActionForward remove(
195             ActionMapping mapping,
196             ActionForm actionForm,
197             HttpServletRequest JavaDoc request,
198             HttpServletResponse JavaDoc response)
199             throws IOException JavaDoc, ServletException JavaDoc {
200         ActionForward forward = mapping.findForward("editPages");
201         request.setAttribute("model", new BasePageModel(
202                 "pagesForm.title", request, response, mapping));
203         try {
204             UserManager mgr = RollerFactory.getRoller().getUserManager();
205             WeblogTemplateForm form = (WeblogTemplateForm)actionForm;
206             WeblogTemplate template = mgr.getPage(form.getId());
207             WebsiteData website = template.getWebsite();
208             
209             RollerSession rses = RollerSession.getRollerSession(request);
210             if ( rses.isUserAuthorizedToAdmin(website) ) {
211                 if(!template.isRequired()) {
212                     
213                     mgr.removePage(template);
214                     RollerFactory.getRoller().flush();
215                     
216                     // notify cache
217
CacheManager.invalidate(template);
218                 } else {
219                     
220                     // someone trying to remove a required template
221
throw new RollerException("Cannot remove required page");
222                 }
223                 
224                 addModelObjects(
225                    request, response, mapping, template.getWebsite(), template);
226                 actionForm.reset(mapping, request);
227             } else {
228                 forward = mapping.findForward("access-denied");
229             }
230         } catch (RollerException e) {
231             ActionErrors errors = new ActionErrors();
232             errors.add(null, new ActionError(
233                     "error.internationalized",e.getRootCauseMessage()));
234             saveErrors(request, errors);
235         } catch (Exception JavaDoc e) {
236             mLogger.error("ERROR in action",e);
237             throw new ServletException JavaDoc(e);
238         }
239         return forward;
240     }
241     
242     //-----------------------------------------------------------------------
243
/** Send user to remove confirmation page */
244     public ActionForward removeOk(
245             ActionMapping mapping,
246             ActionForm actionForm,
247             HttpServletRequest JavaDoc request,
248             HttpServletResponse JavaDoc response)
249             throws IOException JavaDoc, ServletException JavaDoc {
250         ActionForward forward = mapping.findForward("removePage.page");
251         try {
252             RollerSession rses = RollerSession.getRollerSession(request);
253             RollerRequest rreq = RollerRequest.getRollerRequest(request);
254             WeblogTemplate page = (WeblogTemplate) rreq.getPage();
255             WebsiteData website = page.getWebsite();
256             if ( rses.isUserAuthorizedToAdmin(website) ) {
257                 WeblogTemplateForm form = (WeblogTemplateForm)actionForm;
258                 form.copyFrom(page, request.getLocale());
259                 
260                 addModelObjects(request, response, mapping, page.getWebsite(), page);
261                 
262                 BasePageModel pageModel = new BasePageModel(
263                         "editPages.title.removeOK", request, response, mapping);
264                 pageModel.setWebsite(website);
265                 request.setAttribute("model", pageModel);
266                 
267                 UserData ud = rses.getAuthenticatedUser();
268                 request.setAttribute("user",ud);
269             } else {
270                 forward = mapping.findForward("access-denied");
271             }
272         } catch (Exception JavaDoc e) {
273             mLogger.error("ERROR in action",e);
274             throw new ServletException JavaDoc(e);
275         }
276         return forward;
277     }
278     
279     //-----------------------------------------------------------------------
280
public ActionForward update(
281             ActionMapping mapping,
282             ActionForm actionForm,
283             HttpServletRequest JavaDoc request,
284             HttpServletResponse JavaDoc response)
285             throws IOException JavaDoc, ServletException JavaDoc {
286         ActionForward forward = mapping.findForward("editPage.page");
287         try {
288             RollerRequest rreq = RollerRequest.getRollerRequest(request);
289             WeblogTemplateForm form = (WeblogTemplateForm)actionForm;
290             UserManager mgr = RollerFactory.getRoller().getUserManager();
291             WeblogTemplate data = mgr.getPage(form.getId());
292             WebsiteData website = data.getWebsite();
293             
294             RollerSession rses = RollerSession.getRollerSession(request);
295             if (rses.isUserAuthorizedToAdmin(website)) {
296                 form.copyTo(data, request.getLocale());
297                 data.setLastModified( new Date JavaDoc() );
298                 
299                 validateLink( data );
300                 
301                 mgr.savePage( data );
302                 RollerFactory.getRoller().flush();
303                 
304                 // set the (possibly) new link back into the Form bean
305
((WeblogTemplateForm)actionForm).setLink( data.getLink() );
306                 
307                 ActionMessages uiMessages = new ActionMessages();
308                 uiMessages.add(ActionMessages.GLOBAL_MESSAGE,
309                         new ActionMessage("pageForm.save.success",
310                         data.getName()));
311                 saveMessages(request, uiMessages);
312                 
313                 CacheManager.invalidate(data);
314                 
315                 addModelObjects(request, response, mapping, data.getWebsite(), data);
316
317                 BasePageModel pageModel = new BasePageModel(
318                         "pageForm.title", request, response, mapping);
319                 pageModel.setWebsite(website);
320                 request.setAttribute("model", pageModel);
321                 
322             } else {
323                 forward = mapping.findForward("access-denied");
324             }
325             
326             // Don't reset this form. Allow user to keep on tweaking.
327
//actionForm.reset(mapping,request);
328
} catch (RollerPermissionsException e) {
329             ActionErrors errors = new ActionErrors();
330             errors.add(null, new ActionError("error.permissions.deniedSave"));
331             saveErrors(request, errors);
332             forward = mapping.findForward("access-denied");
333         } catch (Exception JavaDoc e) {
334             mLogger.error("ERROR in action",e);
335             throw new ServletException JavaDoc(e);
336         }
337         return forward;
338     }
339     
340     //-----------------------------------------------------------------------
341
/**
342      * Ensures that the page has a safe value for the link
343      * field. "Safe" is defined as containing no html
344      * or any other non-alphanumeric characters.
345      * While this is overly strict (there are non-alphanum
346      * characters that are web-safe), this is a much easier
347      * test-and-correct. Otherwise we would need a RegEx package.
348      */

349     private void validateLink( WeblogTemplate data ) {
350         // if data.getLink() is null or empty
351
// use the title ( data.getName() )
352
if ( StringUtils.isEmpty( data.getLink() ) ) {
353             data.setLink( data.getName() );
354         }
355         
356         // if link contains any nonAlphanumeric, strip them
357
// first we must remove any html, as this is
358
// non-instructional markup. Then do a straight
359
// removeNonAlphanumeric.
360
if ( !StringUtils.isAlphanumeric( data.getLink() ) ) {
361             String JavaDoc link = Utilities.removeHTML( data.getLink() );
362             link = Utilities.removeNonAlphanumeric( link );
363             data.setLink( link );
364         }
365     }
366     
367     //-----------------------------------------------------------------------
368
public ActionForward cancel(
369             ActionMapping mapping,
370             ActionForm actionForm,
371             HttpServletRequest JavaDoc request,
372             HttpServletResponse JavaDoc response)
373             throws IOException JavaDoc, ServletException JavaDoc {
374         request.setAttribute("model", new BasePageModel(
375                 "pagesForm.title", request, response, mapping));
376         return (mapping.findForward("editPages"));
377     }
378     
379     //-----------------------------------------------------------------------
380
private void addModelObjects(
381             HttpServletRequest JavaDoc request,
382             HttpServletResponse JavaDoc response,
383             ActionMapping mapping,
384             WebsiteData website,
385             WeblogTemplate page)
386             throws RollerException {
387         UserManager mgr = RollerFactory.getRoller().getUserManager();
388         RollerSession rses = RollerSession.getRollerSession(request);
389         RollerRequest rreq = RollerRequest.getRollerRequest(request);
390         
391         UserData user = rses.getAuthenticatedUser();
392         request.setAttribute("user", user);
393         
394         WebsiteData wd = rreq.getWebsite();
395         request.setAttribute("website", website);
396         
397         List JavaDoc pages = mgr.getPages(website);
398         request.setAttribute("pages", pages);
399         
400         if (page != null) request.setAttribute("page", page);
401     }
402 }
403
404
Popular Tags