roller/src/org/roller/presentation/atom RollerAtomServlet.java,NONE,1.1

Update of /cvsroot/roller/roller/src/org/roller/presentation/atom
In directory sc8-pr-cvs1:/tmp/cvs-serv6743/src/org/roller/presentation/atom

Added Files:
        RollerAtomServlet.java 
Log Message:
Adding RollerAtomServlet.

--- NEW FILE: RollerAtomServlet.java ---
/*
 * Created on Aug 21, 2003
 */
package org.roller.presentation.atom;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.lucene.document.Document;
import org.apache.lucene.search.Hits;
import org.osjava.atom4j.pojo.Entry;
import org.osjava.atom4j.pojo.Template;
import org.osjava.atom4j.pojo.UserPreferences;
import org.osjava.atom4j.servlet.AtomServlet;
import org.roller.RollerException;
import org.roller.model.Roller;
import org.roller.model.UserManager;
import org.roller.model.WeblogManager;
import org.roller.pojos.CommentData;
import org.roller.pojos.PageData;
import org.roller.pojos.UserData;
import org.roller.pojos.WeblogEntryData;
import org.roller.pojos.WebsiteData;
import org.roller.presentation.RollerContext;
import org.roller.presentation.RollerRequest;
import org.roller.presentation.pagecache.PageCache;
import org.roller.presentation.weblog.search.FieldConstants;
import org.roller.presentation.weblog.search.IndexManager;
import org.roller.presentation.weblog.search.operations.SearchOperation;
import org.roller.presentation.xmlrpc.RollerXmlRpcClient;

import java.net.URLDecoder;
import java.sql.Timestamp;
import java.util.ArrayList;
import java.util.Date;
import java.util.Iterator;
import java.util.List;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;

/** 
 * This servlet must occur after the RequestFilter.
 * 
 * @author llavandowska
 * 
 * @web.servlet name="AtomServlet"
 * @web.servlet-mapping url-pattern="/atom/*"
 */
public class RollerAtomServlet extends AtomServlet
{
    private static Log mLogger = 
        LogFactory.getFactory().getInstance(RollerAtomServlet.class);
                
    protected static String mBaseUrl = null;
    
    /* (non-Javadoc)
     * @see javax.servlet.GenericServlet#init()
     */
    public void init() throws ServletException
    {
        super.init();

        RollerContext rContext = 
RollerContext.getRollerContext(getServletContext());
        if (rContext == null) return;
        mBaseUrl = rContext.getRollerConfig().getAbsoluteURL();
    }  

    //------------------------------------------------------------------------
    /**
     * @return
     */
    protected boolean authorized()
    {        
        try
        {
            return RollerRequest.getRollerRequest().isUserAuthorizedToEdit();
        }
        catch (Exception e)
        {
            mLogger.error("Error checking User Authorization", e);
        }
        return false;
    }

    //------------------------------------------------------------------------
    /**
     * @param request
     */
    private WeblogManager getWeblogManager() throws RollerException
    {
        return RollerRequest.getRollerRequest().getRoller().getWeblogManager();
    }

    /**
     * 
     */
    private UserManager getUserManager() throws RollerException
    {
        return RollerRequest.getRollerRequest().getRoller().getUserManager();
    }

    //------------------------------------------------------------------------
    protected void flushPageCache(RollerRequest rreq)
    {
        PageCache.removeFromCache( rreq.getRequest(), rreq.getUser() );
    } 

    //------------------------------------------------------------------------
    private Entry convertToAtomEntry(WeblogEntryData weblogEntry)
    {
        UserData user = weblogEntry.getWebsite().getUser();
        Entry atomEntry = new Entry();
        atomEntry.setId( weblogEntry.getId() );
        atomEntry.setTitle( weblogEntry.getTitle() );
        atomEntry.setIssued( weblogEntry.getPubTime() );
        atomEntry.setCreated( weblogEntry.getPubTime() );
        atomEntry.setModified( weblogEntry.getUpdateTime() );
        atomEntry.setLink( mBaseUrl + weblogEntry.getPermaLink() );
        atomEntry.setComment( mBaseUrl + "/atom/" + user.getUserName() + 
                              "/comment/" + weblogEntry.getAnchor() );
        
        atomEntry.getAuthor().setName( user.getFullName() );
        atomEntry.getAuthor().setUrl( mBaseUrl + "/" + user.getUserName() );
        atomEntry.getAuthor().setEmail( user.getEmailAddress() );
        
        atomEntry.getContent().setText( weblogEntry.getText() );
        atomEntry.getContent().setMimeType( "application/xhtml+xml" );
        atomEntry.getContent().setLanguage( "en-us" );
        return atomEntry;
    }

    //------------------------------------------------------------------------
    /* (non-Javadoc)
     * @see org.osjava.atom4j.servlet.AtomServlet#getEntry(java.lang.String[])
     */
    protected Entry getEntry(String[] pathInfo) throws Exception
    {
        WeblogEntryData entry = 
            getWeblogManager().getWeblogEntryByAnchor(pathInfo[0], pathInfo[2]);
            
        return convertToAtomEntry(entry);
    }

    //------------------------------------------------------------------------
    /* (non-Javadoc)
     * @see 
org.osjava.atom4j.servlet.AtomServlet#deleteEntry(java.lang.String[])
     */
    protected void deleteEntry(String[] pathInfo) throws Exception
    {
        // find the WeblogEntryData to be edited
        WeblogManager weblogMgr = getWeblogManager();
        WeblogEntryData entry = 
            weblogMgr.getWeblogEntryByAnchor(pathInfo[0], pathInfo[2]);
            
        if (entry != null)
        {
            weblogMgr.removeWeblogEntry( entry.getId() );
            flushPageCache( RollerRequest.getRollerRequest() );            
        }
    }

    //------------------------------------------------------------------------
    /* (non-Javadoc)
     * @see 
org.osjava.atom4j.servlet.AtomServlet#saveNewEntry(org.osjava.atom4j.pojo.Entry)
     */
    protected void saveNewEntry(Entry atomEntry) throws Exception
    {
        RollerRequest rreq = RollerRequest.getRollerRequest();
        HttpServletRequest req = rreq.getRequest();
        String contextUrl = 
            RollerContext.getRollerContext(req).getAbsoluteContextUrl(req);
        Roller roller = rreq.getRoller();

        WeblogManager weblogMgr = roller.getWeblogManager();

        WebsiteData website = rreq.getWebsite();
        Timestamp current = new Timestamp(System.currentTimeMillis());
        
        Timestamp pubTime = current;
        Timestamp updateTime = current;
        if (atomEntry.getIssued() != null)
        {
            pubTime = new Timestamp( atomEntry.getIssued().getTime() );
        }
        if (atomEntry.getModified() != null)
        {
            updateTime = new Timestamp( atomEntry.getModified().getTime() );
        }
        
        WeblogEntryData entry = new WeblogEntryData();
        entry.setTitle(atomEntry.getTitle());
        entry.setText(atomEntry.getContent().getText());
        entry.setPubTime(pubTime);
        entry.setUpdateTime(updateTime);
        entry.setWebsite(website);
        entry.setPublishEntry( Boolean.TRUE );
        entry.setCategory(
            weblogMgr.retrieveWeblogCategory(
                website.getBloggerCategoryId()) );

        // store it
        weblogMgr.storeWeblogEntry(entry);
        flushPageCache(rreq);            
        
        // send ping
        RollerXmlRpcClient.sendWeblogsPing(
            contextUrl + entry.getPermaLink(), 
            entry.getWebsite().getName());  
    }

    //------------------------------------------------------------------------
    /* (non-Javadoc)
     * @see 
org.osjava.atom4j.servlet.AtomServlet#updateEntry(org.osjava.atom4j.pojo.Entry)
     */
    protected void updateEntry(Entry atomEntry, String[] pathInfo) throws 
Exception
    {
        RollerRequest rreq = RollerRequest.getRollerRequest();
        UserData user = rreq.getUser();
        if (user != null && pathInfo.length > 2)
        {
            // find the WeblogEntryData to be edited
            WeblogManager weblogMgr = getWeblogManager();
            WeblogEntryData rollerEntry = 
                weblogMgr.getWeblogEntryByAnchor(user.getUserName(), 
pathInfo[2]);
            
            if (rollerEntry != null)
            {
                Timestamp pubTime = rollerEntry.getPubTime();
                Timestamp updateTime = new 
Timestamp(System.currentTimeMillis());
                if (atomEntry.getIssued() != null)
                {
                    pubTime = new Timestamp( atomEntry.getIssued().getTime() );
                }
                if (atomEntry.getModified() != null)
                {
                    updateTime = new Timestamp( 
atomEntry.getModified().getTime() );
                }
                    
                rollerEntry.setTitle(atomEntry.getTitle());
                rollerEntry.setText(atomEntry.getContent().getText());
                rollerEntry.setPubTime(pubTime);
                rollerEntry.setUpdateTime(updateTime);
        
                // store it
                weblogMgr.storeWeblogEntry(rollerEntry);
                flushPageCache(rreq);
            }
        }
    }

    //------------------------------------------------------------------------
    /* (non-Javadoc)
     * @see org.osjava.atom4j.servlet.AtomServlet#getLatestEntries(int)
     */
    protected List getLatestEntries(String username, int maxEntries)
    {
        List rollerEntries = new ArrayList(maxEntries);        
        try
        {
            rollerEntries = getWeblogManager().getRecentWeblogEntriesArray( 
                        username, new Date(), null, maxEntries, true );
        }
        catch (RollerException e)
        {
            mLogger.error(e);
        }
        
        List entries= convertEntries(rollerEntries);
        
        return entries;
    }

    //------------------------------------------------------------------------
    /**
     * Convert a List of Atom Entries to a List of WeblogEntryData objects.
     * 
     * @param rollerEntries
     * @return
     */
    private List convertEntries(List rollerEntries)
    {
        // Convert Roller entries into Atom entries
        List entries = new ArrayList(rollerEntries.size());
        Iterator iter = rollerEntries.iterator();
        WeblogEntryData weblogEntry = null;
        while (iter.hasNext())
        {
            weblogEntry = (WeblogEntryData)iter.next();
            entries.add( convertToAtomEntry(weblogEntry) );
        }
        return entries;
    }

    //------------------------------------------------------------------------
    /* (non-Javadoc)
     * @see org.osjava.atom4j.servlet.AtomServlet#allEntries(String[])
     */
    protected List allEntries(String[] pathInfo) throws Exception
    {
        List rollerEntries = new ArrayList(50);        
        try
        {
            rollerEntries = getWeblogManager().getAllRecentWeblogEntries(new 
Date(), 0);
        }
        catch (RollerException e)
        {
            mLogger.error(e);
        }

        List entries= convertEntries(rollerEntries);
        
        return entries;
    }

    //------------------------------------------------------------------------
    /* (non-Javadoc)
     * @see org.osjava.atom4j.servlet.AtomServlet#getEntryRange(int, int, 
java.lang.String[])
     */
    protected List getEntryRange(int startRange, int endRange, String[] 
pathInfo) throws Exception
    {
        List rollerEntries = new ArrayList(endRange);        
        try
        {
            rollerEntries = getWeblogManager().getAllRecentWeblogEntries(new 
Date(), endRange);
        }
        catch (RollerException e)
        {
            mLogger.error(e);
        }
        
        if (startRange >= 0)
        {
            if (endRange > rollerEntries.size()) endRange = 
rollerEntries.size();
            rollerEntries = rollerEntries.subList(startRange, endRange);
        }

        List entries= convertEntries(rollerEntries);
        
        return entries;
    }

    //------------------------------------------------------------------------
    /* (non-Javadoc)
     * @see 
org.osjava.atom4j.servlet.AtomServlet#entryKeywordSearch(java.lang.String[])
     */
    protected List entryKeywordSearch(String[] pathInfo) throws Exception
    {
        String searchTerm = URLDecoder.decode( pathInfo[2], "UTF-8" );
        IndexManager manager =
            RollerContext.getRollerContext(
                RollerContext.getServletContext() ).getIndexManager();
        SearchOperation search = new SearchOperation();
        search.setTerm( searchTerm );
        search.setUsername( pathInfo[0] );
        manager.executeIndexOperationNow( search );

        Hits hits = search.getResults();
        WeblogManager wmanager = getWeblogManager();

        if (mLogger.isDebugEnabled())
        {
            mLogger.debug("numresults = " + hits.length());
        }

        List searchResults = new ArrayList();
        Document doc = null;
        String username = null;
        String anchor = null;
        WeblogEntryData entry = null;
        for (int i = 0; i < hits.length(); i++)
        {
             doc = hits.doc(i);
             username =
                 doc.getField(FieldConstants.USERNAME).stringValue();
             anchor =
                 doc.getField(FieldConstants.ANCHOR).stringValue();
             entry =
                 wmanager.getWeblogEntryByAnchor(username, anchor);
             searchResults.add( convertToAtomEntry(entry) );
        }
        return searchResults;
    }

    //------------------------------------------------------------------------
    /* (non-Javadoc)
     * @see 
org.osjava.atom4j.servlet.AtomServlet#findTemplates(java.lang.String[])
     */
    protected List findTemplates(String[] pathInfo) throws Exception
    {
        PageData[] pages = getUserManager().getPages(pathInfo[0]);
        ArrayList templates = new ArrayList(pages.length);
        Template template = null;
        for (int i=0; i<pages.length; i++)
        {
            template = new Template();
            template.setBaseURL(mBaseUrl);
            template.setId(pages[i].getId());
            template.setTitle(pages[i].getName());
            templates.add(template);
        }
        return templates;
    }

    //------------------------------------------------------------------------
    /* (non-Javadoc)
     * @see 
org.osjava.atom4j.servlet.AtomServlet#getTemplate(java.lang.String[])
     */
    protected byte[] getTemplate(String[] pathInfo) throws Exception
    {
        PageData page = getUserManager().retrievePage(pathInfo[2]); // page id
        
        return page.getTemplate().getBytes();
    }

    //------------------------------------------------------------------------
    /* (non-Javadoc)
     * @see 
org.osjava.atom4j.servlet.AtomServlet#updateTemplate(javax.servlet.ServletInputStream,
 java.lang.String[])
     */
    protected void updateTemplate(String template, String[] pathInfo) throws 
Exception
    {
        PageData page = getUserManager().retrievePage(pathInfo[2]); // page id
        page.setTemplate(template);
        getUserManager().storePage(page);
        flushPageCache( RollerRequest.getRollerRequest() );
    }

    //------------------------------------------------------------------------
    /* (non-Javadoc)
     * @see 
org.osjava.atom4j.servlet.AtomServlet#deleteTemplate(java.lang.String[])
     */
    protected byte[] deleteTemplate(String[] pathInfo) throws Exception
    {
        PageData page = getUserManager().retrievePage(pathInfo[2]); // page id
        byte[] bytes = page.getTemplate().getBytes();
        getUserManager().removePage(pathInfo[2]); // page id
        flushPageCache( RollerRequest.getRollerRequest() );
        return bytes;
    }

    //------------------------------------------------------------------------
    /* (non-Javadoc)
     * @see 
org.osjava.atom4j.servlet.AtomServlet#getUserPreferences(java.lang.String[])
     */
    protected UserPreferences getUserPreferences(String[] pathInfo) throws 
Exception
    {
        UserData user = getUserManager().getUser(pathInfo[0]);
        if (user == null) return null;
        UserPreferences userPrefs = new UserPreferences();
        userPrefs.setEmail( user.getEmailAddress() );
        userPrefs.setId(user.getUserName());
        userPrefs.setName(user.getFullName());
        return userPrefs;
    }

    //------------------------------------------------------------------------
    /* (non-Javadoc)
     * @see 
org.osjava.atom4j.servlet.AtomServlet#updatePrefs(org.osjava.atom4j.pojo.UserPreferences,
 java.lang.String[])
     */
    protected void updatePrefs(UserPreferences userPrefs, String[] pathInfo) 
throws Exception
    {
        UserData user = getUserManager().getUser(pathInfo[0]);
        user.setEmailAddress( userPrefs.getEmail() );
        user.setFullName( userPrefs.getName() );
        getUserManager().storeUser(user);
        flushPageCache( RollerRequest.getRollerRequest() );
    }

    //------------------------------------------------------------------------
    /* (non-Javadoc)
     * @see 
org.osjava.atom4j.servlet.AtomServlet#postComment(org.osjava.atom4j.pojo.Entry, 
org.osjava.atom4j.pojo.Entry, java.lang.String[])
     */
    protected void postComment(Entry entry, Entry comment, String[] pathInfo) 
throws Exception
    {
        WeblogEntryData rollerEntry = getWeblogManager().retrieveWeblogEntry( 
entry.getId() );
        if (rollerEntry != null)
        {
            CommentData rollerComment = new CommentData(
                null, rollerEntry, 
                comment.getAuthor().getName(), 
                comment.getAuthor().getEmail(), 
                comment.getAuthor().getUrl(), 
                comment.getContent().getText(), 
                new java.sql.Timestamp( new Date().getTime() )
            );
            getWeblogManager().storeComment(rollerComment);
            flushPageCache( RollerRequest.getRollerRequest() );
        }
        
    }
}




-------------------------------------------------------
This sf.net email is sponsored by:ThinkGeek
Welcome to geek heaven.
http://thinkgeek.com/sf