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.servlets;
    20  
    21  import java.io.IOException;
    22  import java.util.HashMap;
    23  import java.util.Map;
    24  import javax.servlet.ServletConfig;
    25  import javax.servlet.ServletException;
    26  import javax.servlet.http.HttpServlet;
    27  import javax.servlet.http.HttpServletRequest;
    28  import javax.servlet.http.HttpServletResponse;
    29  import javax.servlet.jsp.JspFactory;
    30  import javax.servlet.jsp.PageContext;
    31  import org.apache.commons.logging.Log;
    32  import org.apache.commons.logging.LogFactory;
    33  import org.apache.roller.weblogger.WebloggerException;
    34  import org.apache.roller.weblogger.config.WebloggerConfig;
    35  import org.apache.roller.weblogger.config.WebloggerRuntimeConfig;
    36  import org.apache.roller.weblogger.business.WebloggerFactory;
    37  import org.apache.roller.weblogger.business.UserManager;
    38  import org.apache.roller.weblogger.pojos.ThemeTemplate;
    39  import org.apache.roller.weblogger.pojos.Weblog;
    40  import org.apache.roller.weblogger.ui.rendering.Renderer;
    41  import org.apache.roller.weblogger.ui.rendering.RendererManager;
    42  import org.apache.roller.weblogger.ui.rendering.model.Model;
    43  import org.apache.roller.weblogger.ui.rendering.model.ModelLoader;
    44  import org.apache.roller.weblogger.ui.rendering.model.SearchResultsModel;
    45  import org.apache.roller.weblogger.ui.rendering.util.WeblogPageRequest;
    46  import org.apache.roller.weblogger.ui.rendering.util.WeblogSearchRequest;
    47  import org.apache.roller.weblogger.util.cache.CachedContent;
    48  
    49  
    50  /**
    51   * Handles search queries for weblogs.
    52   */
         /* 
    P/P   *  Method: void org.apache.roller.weblogger.ui.rendering.servlets.SearchServlet()
          */
    53  public class SearchServlet extends HttpServlet {
    54      
             /* 
    P/P       *  Method: org.apache.roller.weblogger.ui.rendering.servlets.SearchServlet__static_init
              * 
              *  Postconditions:
              *    init'ed(log)
              */
    55      private static Log log = LogFactory.getLog(SearchServlet.class);
    56      
    57      
    58      /**
    59       * Init method for this servlet
    60       */
    61      public void init(ServletConfig servletConfig) throws ServletException {
    62          
                 /* 
    P/P           *  Method: void init(ServletConfig)
                  * 
                  *  Preconditions:
                  *    log != null
                  */
    63          super.init(servletConfig);
    64          
    65          log.info("Initializing SearchServlet");
    66      }
    67      
    68      
    69      /**
    70       * Handle GET requests for weblog pages.
    71       */
    72      public void doGet(HttpServletRequest request, HttpServletResponse response) 
    73              throws ServletException, IOException {
    74          
                 /* 
    P/P           *  Method: void doGet(HttpServletRequest, HttpServletResponse)
                  * 
                  *  Preconditions:
                  *    log != null
                  *    response != null
                  *    (soft) org/apache/roller/weblogger/ui/rendering/util/WeblogRequest.log != null
                  *    (soft) request != null
                  * 
                  *  Presumptions:
                  *    init'ed(java.lang.Boolean.TRUE)
                  *    javax.servlet.http.HttpServletResponse:getOutputStream(...)@217 != null
                  *    javax.servlet.jsp.JspFactory:getDefaultFactory(...)@127 != null
                  *    org.apache.roller.weblogger.business.UserManager:getWebsiteByHandle(...)@86 != null
                  *    org.apache.roller.weblogger.business.Weblogger:getUserManager(...)@85 != null
                  *    ...
                  * 
                  *  Test Vectors:
                  *    org.apache.roller.weblogger.config.WebloggerRuntimeConfig:isSiteWideWeblog(...)@154: {0}, {1}
                  *    org.apache.roller.weblogger.pojos.Weblog:isShowAllLangs(...)@96: {1}, {0}
                  *    org.apache.roller.weblogger.pojos.WeblogTheme:getTemplateByAction(...)@104: Inverse{null}, Addr_Set{null}
                  *    org.apache.roller.weblogger.ui.rendering.util.WeblogSearchRequest:getLocale(...)@96: Inverse{null}, Addr_Set{null}
                  */
    75          log.debug("Entering");
    76          
    77          Weblog weblog = null;
    78          WeblogSearchRequest searchRequest = null;
    79          
    80          // first off lets parse the incoming request and validate it
    81          try {
    82              searchRequest = new WeblogSearchRequest(request);
    83              
    84              // now make sure the specified weblog really exists
    85              UserManager userMgr = WebloggerFactory.getWeblogger().getUserManager();
    86              weblog = userMgr.getWebsiteByHandle(searchRequest.getWeblogHandle(), Boolean.TRUE);
    87              
    88          } catch(Exception e) {
    89              // invalid search request format or weblog doesn't exist
    90              log.debug("error creating weblog search request", e);
    91              response.sendError(HttpServletResponse.SC_NOT_FOUND);
    92              return;
    93          }
    94          
    95          // do we need to force a specific locale for the request?
    96          if(searchRequest.getLocale() == null && !weblog.isShowAllLangs()) {
    97              searchRequest.setLocale(weblog.getLocale());
    98          }
    99          
   100          // lookup template to use for rendering
   101          ThemeTemplate page = null;
   102          try {
   103              // first try looking for a specific search page
   104              page = weblog.getTheme().getTemplateByAction(ThemeTemplate.ACTION_SEARCH);
   105              
   106              // if not found then fall back on default page
   107              if(page == null) {
   108                  page = weblog.getTheme().getDefaultTemplate();
   109              }
   110              
   111              // if still null then that's a problem
   112              if(page == null) {
+  113                  throw new WebloggerException("Could not lookup default page "+
   114                          "for weblog "+weblog.getHandle());
   115              }
   116          } catch(Exception e) {
   117              log.error("Error getting default page for weblog "+
   118                      weblog.getHandle(), e);
   119          }
   120          
   121          // set the content type
   122          response.setContentType("text/html; charset=utf-8");
   123          
   124          // looks like we need to render content
   125          Map model = new HashMap();
   126          try {
   127              PageContext pageContext = JspFactory.getDefaultFactory().getPageContext(
   128                      this, request, response,"", false, 8192, true);
   129              
   130              // populate the rendering model
   131              Map initData = new HashMap();
   132              initData.put("request", request);
   133              initData.put("pageContext", pageContext);
   134              
   135              // this is a little hacky, but nothing we can do about it
   136              // we need the 'weblogRequest' to be a pageRequest so other models
   137              // are properly loaded, which means that searchRequest needs its
   138              // own custom initData property aside from the standard weblogRequest.
   139              // possible better approach is make searchRequest extend pageRequest.
   140              WeblogPageRequest pageRequest = new WeblogPageRequest();
   141              pageRequest.setWeblogHandle(searchRequest.getWeblogHandle());
   142              pageRequest.setWeblogCategoryName(searchRequest.getWeblogCategoryName());
   143              initData.put("parsedRequest", pageRequest);
   144              initData.put("searchRequest", searchRequest);
   145              
   146              // define url strategy
   147              initData.put("urlStrategy", WebloggerFactory.getWeblogger().getUrlStrategy());
   148              
   149              // Load models for pages
   150              String searchModels = WebloggerConfig.getProperty("rendering.searchModels");
   151              ModelLoader.loadModels(searchModels, model, initData, true);
   152              
   153              // Load special models for site-wide blog
   154              if(WebloggerRuntimeConfig.isSiteWideWeblog(weblog.getHandle())) {
   155                  String siteModels = WebloggerConfig.getProperty("rendering.siteModels");
   156                  ModelLoader.loadModels(siteModels, model, initData, true);
   157              }
   158  
   159              // Load weblog custom models
   160              ModelLoader.loadCustomModels(weblog, model, initData);
   161              
   162              // ick, gotta load pre-3.0 model stuff as well :(
   163              ModelLoader.loadOldModels(model, request, response, pageContext, pageRequest, WebloggerFactory.getWeblogger().getUrlStrategy());
   164              
   165              // manually add search model again to support pre-3.0 weblogs
   166              Model searchModel = new SearchResultsModel();
   167              searchModel.init(initData);
   168              model.put("searchResults", searchModel);
   169              
   170          } catch (WebloggerException ex) {
   171              log.error("Error loading model objects for page", ex);
   172              
   173              if(!response.isCommitted()) response.reset();
   174              response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
   175              return;
   176          }
   177  
   178          
   179          // lookup Renderer we are going to use
   180          Renderer renderer = null;
   181          try {
   182              log.debug("Looking up renderer");
   183              renderer = RendererManager.getRenderer(page);
   184          } catch(Exception e) {
   185              // nobody wants to render my content :(
   186              log.error("Couldn't find renderer for rsd template", e);
   187              
   188              if(!response.isCommitted()) response.reset();
   189              response.sendError(HttpServletResponse.SC_NOT_FOUND);
   190              return;
   191          }
   192          
   193          // render content
   194          CachedContent rendererOutput = new CachedContent(4096);
   195          try {
   196              log.debug("Doing rendering");
   197              renderer.render(model, rendererOutput.getCachedWriter());
   198              
   199              // flush rendered output and close
   200              rendererOutput.flush();
   201              rendererOutput.close();
   202          } catch(Exception e) {
   203              // bummer, error during rendering
   204              log.error("Error during rendering for rsd template", e);
   205              
   206              if(!response.isCommitted()) response.reset();
   207              response.sendError(HttpServletResponse.SC_NOT_FOUND);
   208              return;
   209          }
   210          
   211          
   212          // post rendering process
   213          
   214          // flush rendered content to response
   215          log.debug("Flushing response output");
   216          response.setContentLength(rendererOutput.getContent().length);
   217          response.getOutputStream().write(rendererOutput.getContent());
   218          
   219          log.debug("Exiting");
   220      }
   221      
   222  }