pagemodel.java

这个weblogging 设计得比较精巧

package org.roller.presentation.velocity;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.roller.RollerException;
import org.roller.config.RollerRuntimeConfig;
import org.roller.model.BookmarkManager;
import org.roller.model.RefererManager;
import org.roller.model.UserManager;
import org.roller.model.WeblogManager;
import org.roller.pojos.BookmarkComparator;
import org.roller.pojos.FolderData;
import org.roller.pojos.PageData;
import org.roller.pojos.RefererData;
import org.roller.pojos.UserData;
import org.roller.pojos.WeblogCategoryData;
import org.roller.pojos.WeblogEntryData;
import org.roller.pojos.WebsiteData;
import org.roller.presentation.RollerRequest;
import org.roller.util.StringUtils;

/**
 * Provides Roller page templates with access to Roller domain model objects.
 *  
 * @author llavandowska
 * @author David M Johnson
 */
public class PageModel
{
    public final static String VELOCITY_NULL = "nil";
    
    protected static Log mLogger = 
       LogFactory.getFactory().getInstance(PageModel.class);
    
    private BookmarkManager      mBookmarkMgr = null;
    private WeblogManager        mWeblogMgr = null;
    private UserManager          mUserMgr = null;
    private RefererManager       mRefererMgr = null;

    private Map                mCategories = new HashMap();
    private HashMap              mPageMap = new HashMap();
    private RollerRequest        mRollerReq = null;
    private String               mUsername = null;
    
    private WeblogEntryData      mNextEntry = null;
    private WeblogEntryData      mPreviousEntry = null;

    private WeblogEntryData      mLastEntry = null;

    private WeblogEntryData mFirstEntry;
        
    //------------------------------------------------------------------------
    
    /** init() must be called to complete construction */
    public PageModel() {}
    
    /**
     * Initialize PageModel and allow PageModel to initialized VelocityContext.
     * @param rreq
     * @param ctx
     */
    public void init(RollerRequest rreq)
    {
        mRollerReq = rreq;
        UserData user = null;
        if ( rreq.getRequest().getAttribute(RollerRequest.OWNING_USER) != null)
        {
            user = (UserData)
                rreq.getRequest().getAttribute(RollerRequest.OWNING_USER);
        }
        else if ( rreq.getUser() != null )
        {
            user = rreq.getUser();
        }
        if ( user != null )
        {
            mUsername = user.getUserName();
        }
        
        try
        {
            mBookmarkMgr = rreq.getRoller().getBookmarkManager();
            mRefererMgr  = rreq.getRoller().getRefererManager();
            mUserMgr     = rreq.getRoller().getUserManager();
            mWeblogMgr   = rreq.getRoller().getWeblogManager();
            
            /** 
             * Preload what we can for encapsulation.  What we cannot preload we
             * will use the Managers later to fetch.
             */
            if ( mUsername != null )
            {
                // Get the pages, put into context & load map
                WebsiteData website = mUserMgr.getWebsite(user.getUserName());
                List pages = mUserMgr.getPages(website);
                Iterator pageIter = pages.iterator();
                while (pageIter.hasNext())
                {
                    PageData page = (PageData) pageIter.next();
                    mPageMap.put(page.getName(), page);
                }
            }
            
        }
        catch (RollerException e)
        {
            mLogger.error("PageModel Roller get*Manager Exception", e);
        }
    }
    
    //------------------------------------------------------------------------
    
    /** Encapsulates folder.getBookmarks() & sorting */
    public Collection getBookmarks(FolderData folder)
    {
        Collection bookmarks = folder.getBookmarks();
        List list = new ArrayList(bookmarks);
        Collections.sort( list, new BookmarkComparator() );
        return list;
    }
    
    //------------------------------------------------------------------------
    
    /** Get top level bookmark folders. */
    public Collection getTopLevelFolders()
    {
        Collection tops = null;
        try
        {
         tops= mBookmarkMgr.getRootFolder(
                    mUserMgr.getWebsite(mUsername)).getFolders();
        }
        catch (RollerException e)
        {
            tops = new ArrayList();
        }
        return tops;
    }
    
    //------------------------------------------------------------------------
    
    /** Encapsulates WeblogManager.getComments().size() */
    public int getCommentCount(String entryId)
    {
        try
        {
            return mWeblogMgr.getComments( entryId ).size();
        }
        catch (RollerException e)
        {
            mLogger.error("PageModel getCommentCount()", e);
        }
        return 0;
    }
    
    //------------------------------------------------------------------------
    
    /** Get comments for weblog entry specified by request */
    public List getComments( WeblogEntryData entry )
    {
        try
        {
            return mWeblogMgr.getComments( entry.getId() );
        }
        catch (RollerException e)
        {
            mLogger.error("PageModel getComments()", e);
        }
        return new ArrayList();
    }
    
    //------------------------------------------------------------------------
    
    /** Encapsulates RefererManager */
    public int getDayHits()
    {
        try
        {
            return mRefererMgr.getDayHits(mRollerReq.getWebsite());
        }
        catch (RollerException e)
        {
            mLogger.error("PageModel getDayHits()", e);
        }
        return 0;
    }
    
    //------------------------------------------------------------------------
    
    /** Encapsulates BookmarkManager.getFolder() */
    public FolderData getFolder(String folderPath)
    {
        try
        {
            return mBookmarkMgr.getFolder(
                mUserMgr.getWebsite(mUsername), folderPath);
        }
        catch (RollerException e)
        {
            mLogger.error("PageModel getFolder()", e);
        }
        return null;
    }
        
    //------------------------------------------------------------------------
    
    /** Encapsulates UserManager.getPageByName() */
    public PageData getUsersPageByName(WebsiteData website, String pageName)
    {
        PageData page = null;
        try
        {
            if (website == null) 
                throw new NullPointerException("website is null");
                
            if (pageName == null) 
                throw new NullPointerException("pageName is null");
                
            page = mUserMgr.getPageByName(website, pageName);
        }
        catch (NullPointerException npe)
        {
            mLogger.warn(npe.getMessage());
        }
        catch (RollerException e)
        {
            mLogger.error("ERROR getting user's page by name: " + e.getMessage(),e);
        }
        return page;
    }
    
    //------------------------------------------------------------------------
    
    /** Encapsulates UserManager.getPageByName() */
    public PageData getPageByName(String pageName)
    {
        return (PageData)mPageMap.get(pageName);
    }
    
    //------------------------------------------------------------------------
    
    /** Encapsulates UserManager.getPageByName() */
    public String getPageIdByName(String pageName)
    {
        PageData pd = (PageData)mPageMap.get(pageName);
        if ( pd != null ) 
        {
            return pd.getId();
        }
        else
        {
            return null;
        }
    }
    
    //------------------------------------------------------------------------
    
    /**
     * Get collection of user pages.
     * @return
     */
    public Object getPages()
    {
        return mPageMap.values();
    }
    
    //------------------------------------------------------------------------
    
    /** 
     * Returns a map of up to 100 recent weblog entries for the user and day 
     * specified in the request, filtered by the category specified by the 
     * request, limited by the 'maxEntries' argument, and sorted by reverse 
     * chronological order.
     * 
     * <p>This method will look for a category name in the following places
     * and in the following order:</p>
     * <ul>
     * <li>The request via RollerRequest.getWeblogCategory().</li>
     * <li>The categoryName argument to this method.</li>
     * <li>The default category for the website specified by the request via 
     *     RollerRequest.getWebsite().getDefaultCategory().</li>
     * <li></li>
     * </ul>
     * 
     * @param maxEntries Maximum number of entries to be returned.
     * @param categoryName Only return entries from this category and it's 
     *         subcategories. If null, returns all categories of entry.
     * @return Map of Lists of WeblogEntryData, keyed by 8-char date strings.
     */
    public Map getRecentWeblogEntries(int maxEntries, String categoryName)
    {
        if (VELOCITY_NULL.equals(categoryName)) categoryName = null;
        Map ret = new HashMap();
        try
        {
            Date day = mRollerReq.getDate();
            if (day == null) day = new Date();
            
            // If request specifies a category, then use that
            String catParam = null;
            if (mRollerReq.getWeblogCategory() != null)
            {
                catParam = mRollerReq.getWeblogCategory().getPath();
            }
            else if (categoryName != null)
            {
                // use category argument instead
                catParam = categoryName;
            }
            else if (mRollerReq.getWebsite() != null) // MAIN
            {
                catParam = mRollerReq.getWebsite().getDefaultCategory().getPath();
                if (catParam.equals("/"))
                {
                    catParam = null;
                }
            }
            
            ret = mRollerReq.getRoller().getWeblogManager().getWeblogEntryObjectMap(
                            mRollerReq.getWebsite(),  
                            null,                     // startDate
                            day,                 // endDate
                            catParam,                 // catName
                            WeblogManager.PUB_ONLY,   // status
                            new Integer(maxEntries)); // maxEntries
            
            setFirstAndLastEntries( ret );
        }
        catch (Exception e)
        {
            mLogger.error("PageModel getRecentWeblogEntries()", e);
        }
        return ret;
    }
    
    //------------------------------------------------------------------------
    
    /**
     * Pull the last WeblogEntryData out of the Map.
     * @param ret
     */
    private void setFirstAndLastEntries(Map days)
    {
        int numDays = days.keySet().size();
        if (numDays > 0) // there is at least one day
        {