pagemodel.java

这个weblogging 设计得比较精巧

            // get first entry in map
            Object[] keys = days.keySet().toArray(new Object[numDays]);
            List vals = (List)days.get( keys[0] );
            int valSize = vals.size();
            if (valSize > 0) 
            {
                mFirstEntry = (WeblogEntryData)vals.get(0);
            }
            
            // get last entry in map
            vals = (List)days.get( keys[--numDays] );
            valSize = vals.size();
            if (valSize > 0)
            {
                mLastEntry = (WeblogEntryData)vals.get(--valSize);
            }
        }
    }

    //------------------------------------------------------------------------
    
    /** 
     * Returns list of 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 same places and 
     * same order as does the getRecentWeblogEntries() method.</p>
     * 
     * @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 List of WeblogEntryData objects in revese chronological order.
     */
    public List getRecentWeblogEntriesArray(int maxEntries, String categoryName)
    {
        if (VELOCITY_NULL.equals(categoryName)) categoryName = null;
        List ret = new ArrayList();
        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;
                }
            }
            WeblogManager mgr = mRollerReq.getRoller().getWeblogManager();
            
            //ret = mgr.getRecentWeblogEntriesArray( 
                //name, day, catParam, maxEntries, true );
            
            ret = mgr.getWeblogEntries(
                            mRollerReq.getWebsite(), 
                            null,                    // startDate
                            day,                      // endDate
                            catParam,                 // catName
                            WeblogManager.PUB_ONLY,   // status
                            new Integer(maxEntries)); // maxEntries
        }
        catch (Exception e)
        {
            mLogger.error("PageModel getRecentWeblogEntries()", e);
        }
        return ret;
    }   
    
    //------------------------------------------------------------------------
    
    /** Encapsulates RefererManager **/
    public List getReferers(String date)
    {
        date = date.trim();
        ArrayList referers = new ArrayList();
        try
        {
            List refs = 
                mRefererMgr.getReferersToDate(mRollerReq.getWebsite(), date);
            
            for (Iterator rdItr = refs.iterator(); rdItr.hasNext();) {
                RefererData referer = (RefererData) rdItr.next();
                String title =referer.getTitle();
                String excerpt = referer.getExcerpt();
                if (   StringUtils.isNotEmpty(title) 
                    && StringUtils.isNotEmpty(excerpt) )
                {
                    if (   referer.getVisible().booleanValue() 
                        || this.mRollerReq.isUserAuthorizedToEdit() )
                    { 
                        referers.add(referer);
                    }
                }
            }
            
        }
        catch (Exception e)
        {
            mLogger.error("PageModel getReferersToDate() fails with URL" 
                            + mRollerReq.getRequestURL(), e);
        }
        return referers;
    }   
    
    //------------------------------------------------------------------------
    
    /** Encapsulates RefererManager */
    public List getTodaysReferers()
    {
        List referers = null;
        try
        {
            referers = mRefererMgr.getTodaysReferers(mRollerReq.getWebsite());
         
        }
        catch (RollerException e)
        {
            mLogger.error("PageModel getTodaysReferers()", e);
        }
        return (referers == null ? Collections.EMPTY_LIST : referers);
    }
    
    //------------------------------------------------------------------------
    
    /** Encapsulates RefererManager */
    public int getTotalHits()
    {
        try
        {
            return mRefererMgr.getTotalHits(mRollerReq.getWebsite());
        }
        catch (RollerException e)
        {
            mLogger.error("PageModel getTotalHits()", e);
        }
        return 0;
    }
    
    //------------------------------------------------------------------------
    /**
     * Returns most recent update time of collection of weblog entries.
     * @param weblogEntries Collection of weblog entries.
     * @return Most recent update time.
     */
    public static Date getUpdateTime( ArrayList weblogEntries )
    {
        Date updateTime = null;
        Iterator iter = weblogEntries.iterator();
        while (iter.hasNext())
        {
            WeblogEntryData wd = (WeblogEntryData)iter.next();
            if ( updateTime == null )
            {
                updateTime = wd.getUpdateTime();
            }
            //else if ( updateTime.compareTo(wd.getUpdateTime()) < 0 )
            else if (updateTime.before( wd.getUpdateTime() ))
            {
                updateTime = wd.getUpdateTime();
            }
        }
        return updateTime;
    }

    //------------------------------------------------------------------------
    
    /** Encapsulates WeblogManager.getWeblogCategories() */
    public List getWeblogCategories(String categoryName)
    {
        List ret = null;
        if (VELOCITY_NULL.equals(categoryName)) categoryName = null;
        
        // Make sure we have not already fetched this category.
        if (categoryName != null)
        {
            ret = (List)mCategories.get(categoryName);
        }
        
        if (null == ret) 
        {
            try 
            {
                WeblogCategoryData category = null;                
                if (categoryName != null)
                {
                    category = mWeblogMgr.getWeblogCategoryByPath(
                                  mRollerReq.getWebsite(), null, categoryName);                    
                }
                else 
                {
                    category = mRollerReq.getWebsite().getDefaultCategory();
                }
                ret = category.getWeblogCategories();
                mCategories.put(categoryName, ret);
            }
            catch (RollerException e) 
            {
                mLogger.error(e);
            }
        }       
        return ret;
    }
    
    //------------------------------------------------------------------------
    
    /** Encapsulates RollerRequest.getWeblogEntry() */
    public WeblogEntryData getWeblogEntry()
    {
        return mRollerReq.getWeblogEntry();
    }
    
    //------------------------------------------------------------------------
    
    /**
     * Get the next occurring Entry.
     */
    public WeblogEntryData getNextEntry()
    {
        WeblogEntryData currentEntry = getWeblogEntry();
        if (mFirstEntry != null) currentEntry = mFirstEntry;
        if (mNextEntry == null && currentEntry != null) 
        {
            String catName = null;
            if (mRollerReq.getWeblogCategory() != null)
            {
                catName = mRollerReq.getWeblogCategory().getName();
            }
            try
            {
                mNextEntry = mWeblogMgr.getNextEntry(currentEntry, catName);
                
                // make sure that mNextEntry is not published to future
                if (mNextEntry != null && 
                    mNextEntry.getPubTime().after( new Date() ))
                {
                    mNextEntry = null;
                }
            }
            catch (RollerException e)
            {
                mLogger.error("PageModel.getNextEntry)", e);
            }
        }
        return mNextEntry;
    }

    //------------------------------------------------------------------------
    
    /**
     * Get the previous occurring Entry.
     */
    public WeblogEntryData getPreviousEntry()
    {
        WeblogEntryData currentEntry = getWeblogEntry();
        if (mLastEntry != null) currentEntry = mLastEntry;
        if (mPreviousEntry == null && currentEntry != null )
        {
            String catName = null;
            if (mRollerReq.getWeblogCategory() != null)
            {
                catName = mRollerReq.getWeblogCategory().getName();
            }
            try
            {
                mPreviousEntry = mWeblogMgr.getPreviousEntry(currentEntry, catName);
            }
            catch (RollerException e)
            {
                mLogger.error("PageModel.getPreviousEntry)", e);
            }            
        }
        return mPreviousEntry;
    }

    //------------------------------------------------------------------------
    
    public boolean isUserAuthorizedToEdit()
    {
        try
        {
            return mRollerReq.isUserAuthorizedToEdit();
        }
        catch (Exception e)
        {
            mLogger.warn("PageModel.isUserAuthorizedToEdit)", e);
        }
        return false;
    }
    
    //------------------------------------------------------------------------
    
    public String getRequestParameter(String key)
    {
        return mRollerReq.getRequest().getParameter(key);
    }
    
    //------------------------------------------------------------------------
    
    public FolderData getFolderByPath(String path)
    {
        try
        {
            return mBookmarkMgr.getFolderByPath(
                mUserMgr.getWebsite(mUsername), null, path);
        }
        catch (RollerException e)
        {
            mLogger.error(e);
            return null;
        }
    }

    /**
     * Facade for WeblogManager.getRecentComments().
     * Get the most recent (chronologically) posted Comments
     * for this website, limited to maxCount.  
     * @return List of Comments.
     */
    public List getRecentComments(int maxCount)
    {
        try
        {
            return mWeblogMgr.getRecentComments(mRollerReq.getWebsite(), maxCount);
        }
        catch (RollerException e)
        {
            mLogger.error(e);
            return new ArrayList();
        }
    }
 
    public boolean getEmailComments() 
    {
        WebsiteData website = mRollerReq.getWebsite();
        boolean emailComments = RollerRuntimeConfig.getBooleanProperty("users.comments.emailnotify");
        
        return (website.getEmailComments().booleanValue() && emailComments);
    }
}