weblogentryformaction.java

这个weblogging 设计得比较精巧

                entry.save();
                rreq.getRoller().commit();

                mLogger.debug("Populating form");
                wf.copyFrom(entry, request.getLocale());
                
                reindexEntry(rreq.getRoller(), entry);
                
                // open up a new session, because we will forward to the edit action
                //rreq.getRoller().begin(); // begin already called by RequestFilter
                
                request.setAttribute(RollerRequest.WEBLOGENTRYID_KEY, entry.getId());
                 
                // Flush the page cache
                mLogger.debug("Removing from cache");
                PageCacheFilter.removeFromCache(request, user);
                
				// refresh the front page cache
                MainPageAction.flushMainPageCache();

                // remove session objects that may be left over from spellchecking
                HttpSession session = request.getSession(true);
                session.removeAttribute("spellCheckEvents");
                session.removeAttribute("entryText");

                request.setAttribute("model",
                        new WeblogEntryPageModel(request, response, mapping,
                                (WeblogEntryFormEx)actionForm,
                                WeblogEntryPageModel.EDIT_MODE));
                
                uiMessages.add(null, new ActionMessage("weblogEdit.changesSaved"));
                saveMessages(request, uiMessages);
                
                mLogger.debug("operation complete");
            }
            else
            {
                forward = mapping.findForward("access-denied");
            }
        }
        catch (RollerPermissionsException e)
        {
            ActionErrors errors = new ActionErrors();
            errors.add(null, new ActionError("error.permissions.deniedSave"));
            saveErrors(request, errors);
            forward = mapping.findForward("access-denied");
        }
        catch (Exception e)
        {
            throw new ServletException(e);
        }
        return forward;
    }
    
    private boolean checkMediaCast(WeblogEntryData entry)
    {
        boolean valid = false;
        String url = entry.findEntryAttribute("att_mediacast_url");
        boolean empty = (url == null) || (url.trim().length() == 0);
        if (!empty)
        {
            // fetch MediaCast content type and length
            valid = false;
            try
            {
                mLogger.debug("Sending HTTP HEAD");
                HttpURLConnection con = (HttpURLConnection)
                    new URL(url).openConnection();
                mLogger.debug("Getting response code");
                con.setRequestMethod("HEAD");
                if (con.getResponseCode() != 200) 
                {
                    mLogger.debug("Response code indicates error");
                    mLogger.error("ERROR "+con.getResponseCode()+" return from MediaCast URL");
                    mLogger.debug(con.getContent().toString());
                }
                else if (con.getContentType()!=null && con.getContentLength()!=-1)
                {
                    mLogger.debug("Got good reponse and content info");
                    entry.putEntryAttribute(
                        "att_mediacast_type", con.getContentType());
                    entry.putEntryAttribute(
                        "att_mediacast_length", ""+con.getContentLength());
                    valid = true;
                }
            }
            catch (Exception e)
            {
                mLogger.error("ERROR checking MediaCast URL");
            }
        } 
        else 
        {
            mLogger.debug("No MediaCast specified, but that is OK");
            valid = true;
        }
        if (!valid || empty)
        {
            mLogger.debug("Removing MediaCast attributes");
            try 
            {
                entry.removeEntryAttribute("att_mediacast_url");
                entry.removeEntryAttribute("att_mediacast_type");
                entry.removeEntryAttribute("att_mediacast_length");
            }
            catch (RollerException e) 
            {
                mLogger.error("ERROR removing invalid MediaCast attributes");
            }
        }
        mLogger.debug("operation complete");
        return valid;
    }
    

    //-----------------------------------------------------------------------
    /**
     * Responds to request to remove weblog entry. Forwards user to page
     * that presents the 'are you sure?' question.
     */
    public ActionForward removeOk(
        ActionMapping       mapping,
        ActionForm          actionForm,
        HttpServletRequest  request,
        HttpServletResponse response)
        throws IOException, ServletException
    {
        ActionForward forward = mapping.findForward("weblogEntryRemove.page");
        try
        {
            RollerRequest rreq = RollerRequest.getRollerRequest(request);
            if ( rreq.isUserAuthorizedToEdit() )
            {
                WeblogEntryFormEx wf = (WeblogEntryFormEx)actionForm;
                WeblogEntryData wd = 
                    rreq.getRoller().getWeblogManager().retrieveWeblogEntry(wf.getId());
                wf.copyFrom(wd, request.getLocale());
                if (wd == null || wd.getId() == null)
                {
                    throw new NullPointerException(
                        "Unable to find WeblogEntry for " +
                        request.getParameter(RollerRequest.WEBLOGENTRYID_KEY));
                }
            }
            else
            {
                forward = mapping.findForward("access-denied");
            }
        }
        catch (Exception e)
        {
            throw new ServletException(e);
        }
        return forward;
    }

    //-----------------------------------------------------------------------
    /**
     * Responds to request from the 'are you sure you want to remove?' page.
     * Removes the specified weblog entry and flushes the cache.
     */
    public ActionForward remove(
        ActionMapping       mapping,
        ActionForm          actionForm,
        HttpServletRequest  request,
        HttpServletResponse response)
        throws IOException, ServletException
    {
        try
        {
            RollerRequest rreq = RollerRequest.getRollerRequest(request);
            if ( rreq.isUserAuthorizedToEdit() )
            {
                WeblogManager mgr = rreq.getRoller().getWeblogManager();
                WeblogEntryData wd = mgr.retrieveWeblogEntry(request.getParameter("id"));
                UserData user = rreq.getUser();
                
				// remove the index for it
                wd.setPublishEntry(Boolean.FALSE);
		        reindexEntry(rreq.getRoller(), wd);

                // remove entry itself
                wd.remove();
                rreq.getRoller().commit();

				// flush caches
                PageCacheFilter.removeFromCache(request, user);
                MainPageAction.flushMainPageCache();
                
                ActionMessages uiMessages = new ActionMessages();
                uiMessages.add(null, new ActionMessage("weblogEdit.entryRemoved"));
                saveMessages(request, uiMessages);
            }
            else
            {
                return mapping.findForward("access-denied");
            }
        }
        catch (Exception e)
        {
            throw new ServletException(e);
        }
        
        // need to reset all values to empty (including 'id')
        actionForm = new WeblogEntryFormEx();
        request.setAttribute(mapping.getName(), actionForm);
        return create(mapping, actionForm, request, response);
    }

    //-----------------------------------------------------------------------
    public ActionForward correctSpelling(
        ActionMapping       mapping,
        ActionForm          actionForm,
        HttpServletRequest  request,
        HttpServletResponse response)
        throws IOException, ServletException
    {
        try
        {
            RollerRequest rreq = RollerRequest.getRollerRequest(request);
            if ( rreq.isUserAuthorizedToEdit() )
            {
                HttpSession session = request.getSession(true);
                WeblogEntryFormEx wf = (WeblogEntryFormEx)actionForm;
                // misspelt words have been submitted
                if (wf.getReplacementWords() != null &&
                    wf.getReplacementWords().length > 0)
                {
                    // replace misspelt words with chosen replacement
                    String[] replacementWords = wf.getReplacementWords();
                    StringBuffer entryText = new StringBuffer(wf.getText());

                    ArrayList events =
                        (ArrayList) session.getAttribute("spellCheckEvents");
                    SpellCheckEvent event = null;
                    String oldWord = null;
                    String newWord = null;
                    int start = -1;
                    int end = -1;
                    int count = replacementWords.length;
                    for(ListIterator it=events.listIterator(events.size());
                        it.hasPrevious();)
                    {
                        event = (SpellCheckEvent)it.previous();
                        oldWord = event.getInvalidWord();
                        newWord = replacementWords[ --count ];
                        if (!oldWord.equals(newWord))
                        {
                            start = event.getWordContextPosition();
                            end = start + oldWord.length();
                            entryText.replace( start, end, newWord );
                        }
                    }
                    wf.setText( entryText.toString() );

                    return save(mapping, wf, request, response);
                }
            }
        }
        catch (Exception e)
        {
            throw new ServletException(e);
        }
        return mapping.findForward("access-denied");
    }    
    
    //-----------------------------------------------------------------------
    public ActionForward spellCheck(
        ActionMapping       mapping,
        ActionForm          actionForm,
        HttpServletRequest  request,
        HttpServletResponse response)
        throws IOException, ServletException
    {
        ActionForward forward = mapping.findForward("weblogEdit.page");
        try
        {
            RollerRequest rreq = RollerRequest.getRollerRequest(request);
            if ( rreq.isUserAuthorizedToEdit() )
            {
                HttpSession session = request.getSession(true);
                WeblogEntryFormEx wf = (WeblogEntryFormEx)actionForm;
                
                // we need to save any new entries before SpellChecking
                if (wf.getId() == null) 
                {
                    save(mapping, actionForm, request, response);
                }

                // pass the submitted entry text through the spellchecker
                ArrayList words =