Kawai Wiki

Rev

Rev 77 | Rev 79 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | RSS feed

package org.kawai.action;

import java.util.List;

import org.kawai.dao.PageDAO;
import org.kawai.dao.UserDAO;
import org.kawai.model.Group;
import org.kawai.model.Language;
import org.kawai.model.Page;
import org.kawai.model.Preview;
import org.kawai.model.Revision;
import org.mentawai.filter.AuthenticationFree;
import org.mentawai.rule.MethodRule;
import org.mentawai.rule.RegexRule;
import org.mentawai.validation.Validatable;
import org.mentawai.validation.ValidationInterceptor;
import org.mentawai.validation.Validator;

public class PageAction extends AbstractAction implements AuthenticationFree, Validatable, ValidationInterceptor {
       
        private static final String LEFT_COLUMN_KEY = "leftColumn";
        private static final String BODY_COLUMN_KEY = "bodyColumn";
        private static final String CSS_KEY = "css";
        private static final String LOGO_KEY = "logo";
       
        public PageAction(UserDAO userDAO, PageDAO pageDAO) {
                super(userDAO, pageDAO);
        }

        @Override
        public boolean bypassAuthentication(String method) {
               
                return true;
        }
       
        @Override
        public void prepareValidator(Validator val, String method) {
               
                if (method != null && method.equals("add") && isPost()) {
                       
                        val.requiredFields("Required field!", "newPage.name", "newPage.title", "newPage.body", "newPage.languageId");
                       
                        val.requiredLists("Required field!", "newPage.languageId");
                       
                        val.add("newPage.name", RegexRule.getInstance("[A-Za-z0-9_\\-]+"), "Invalid name for page!");
                       
                        val.add("newPage.name", MethodRule.getInstance(this, "checkPageDoesNotExist"), "This page already exists!");
                       
                        val.add("newPage.name", MethodRule.getInstance(this, "checkNotSystemPage"), "Cannot create a system page!");
                }              
        }
       
        @Override
        public boolean beforeValidation(String method) {
                return true; // go ahead with validation...
        }
       
        @Override
        public void afterValidation(String method, boolean wasOk) {
                if (method == null) return;
               
                if (method.equals("add") && !wasOk) {
                        output.setValue("showForm", method);
                }
        }
       
        public boolean checkPageDoesNotExist() {
                Page p = input.getObject(Page.class, "newPage");
                if (p.getName() == null || p.getLanguage() == null) {
                        return true;
                }
                return !pageDAO.exists(p.getName(), p.getLanguage());
        }
       
        public boolean checkNotSystemPage() {
                Page p = input.getObject(Page.class, "newPage");
                if (p.getName() == null) {
                        return true;
                }
                return !pageDAO.isSystemPage(p.getName());
        }
       
        private Page loadLeftColumn(Language lang) {
                if (sessionUser != null) {
                        return pageDAO.loadByNameWithPreview(sessionUser.getId(), Page.LEFT_COLUMN, lang);
                } else {
                        return pageDAO.loadByName(Page.LEFT_COLUMN, lang);
                }
        }
       
        private Page loadLogo(Language lang) {
                if (sessionUser != null) {
                        return pageDAO.loadByNameWithPreview(sessionUser.getId(), Page.LOGO, lang);
                } else {
                        return pageDAO.loadByName(Page.LOGO, lang);
                }
        }
       
        private void setLogo(Language lang) {
                Page logo = loadLogo(lang);
                output.setValue(LOGO_KEY, logo);
        }
       
        private void setLeftColumn(Language lang) {
                Page lc = loadLeftColumn(lang);
                output.setValue(LEFT_COLUMN_KEY, lc);
        }
       
        private Page loadCSS() {
                if (sessionUser != null) {
                        return pageDAO.loadByNameWithPreview(sessionUser.getId(), Page.CSS, Language.ENGLISH);
                } else {
                        return pageDAO.loadByName(Page.CSS, Language.ENGLISH); // we only have one CSS (in English)...
                }
        }
       
        private void setCSS() {
                Page css = loadCSS();
                output.setValue(CSS_KEY, css);
        }
       
        // for ajax
        public String get() {
                String name = input.getString("name");
                String lang = input.getString("lang");
                Language language = Language.fromString(lang);
                if (name != null && language != null) {
                        Page page = pageDAO.loadByName(name, language);
                        if (page != null) {
                                output.setValue("page", page);
                        }
                }
                return AJAX;
        }
       
        public String getPreview() {
                String name = input.getString("name");
                String lang = input.getString("lang");
                Language language = Language.fromString(lang);
                Page page = null;
                if (name != null && language != null) {
                        if (sessionUser != null) {
                                Preview preview = pageDAO.loadPreview(sessionUser.getId(), name, language);
                                if (preview != null) {
                                        page = preview.getPage();
                                }
                        }
                        if (page != null) {
                                output.setValue("page", page);
                        }
                }
                return AJAX;
        }
       
        public String getCSS() {
                setCSS();
                return SUCCESS;
        }
       
        public String getPrintCSS() {
                Page page = pageDAO.loadByName(Page.PRINT_CSS, Language.ENGLISH);
                output.setValue(CSS_KEY, page);
                return SUCCESS;
        }
       
        private Language getLanguage() {
                return getLanguage(input.getString("lang"));
        }
       
        private Language getLanguage(String lang) {
                if (lang == null) return language;
                Language l = Language.fromString(lang);
                if (l == null) return language;
                return l;
        }
       
        private String getName() {
                String name = input.getString("name");
                return getName(name);
        }
       
        private String getName(String name) {
                if (name == null) {
                        name = pageDAO.getFrontPage(language);
                        if (name == null) {
                                throw new IllegalStateException("There is no front page defined for language: " + language);
                        }
                }
                return name;
        }
       
        @Override
        public String execute() {
                String name = getName();
                Language language = getLanguage();
                Page page;
                if (sessionUser != null) {
                        page = pageDAO.loadByNameWithPreview(sessionUser.getId(), name, language);
                } else {
                        page = pageDAO.loadByName(name, language);
                }
                if (page == null || page.isDeleted() || page.isSystemPage()) {
                        return INDEX;
                }
                setCSS();
                setLeftColumn(page.getLanguage());
                setLogo(page.getLanguage());
                output.setValue(BODY_COLUMN_KEY, page);
                return SUCCESS;
        }
       
        private void setPageRedirParams(Page page) {
                if (!page.isSystemPage()) {
                        output.setValue("name", page.getName());
                        output.setValue("lang", page.getLanguage().getLocale());
                }
        }
       
        public String savePreview() {
                String name = input.getString("name");
                Language lang = Language.fromString(input.getString("lang"));
                int userId = sessionUser.getId();
                Preview preview = pageDAO.loadPreview(userId, name, lang);
                if (preview != null) {
                        Page page = pageDAO.loadByName(name, lang);
                        if (page != null) {
                               
                                String oldTitle = page.getTitle();
                                String oldBody = page.getBody();
                               
                                page.setTitle(preview.getTitle());
                                page.setBody(preview.getBody());
                                page.setModifiedById(preview.getUserId());
                                pageDAO.update(page);
                               
                                insertRevision(page, oldTitle, oldBody);
                               
                                pageDAO.deletePreview(userId, name, lang);
                        } else {
                                page = preview.getPage();
                                pageDAO.insert(page);
                                pageDAO.deletePreview(userId, name, lang);
                        }
                        setPageRedirParams(page);
                }
                return SUCCESS;
        }
       
        private void insertRevision(Page page, String oldTitle, String oldBody) {
                Revision r = new Revision();
                r.setName(page.getName());
                r.setLanguageId(page.getLanguageId());
                r.setUserId(sessionUser.getId());
                r.setNewTitle(page.getTitle());
                r.setNewBody(page.getBody());
                r.setOldTitle(oldTitle);
                r.setOldBody(oldBody);
                pageDAO.insertRevision(r);
        }
       
        public String edit() {
                if (!isPost()) return INDEX;
                String name = input.getString("name");
                String lang = input.getString("lang");
                if (name.equals("CSS")) {
                        // does not make sense to have CSS in different languages... (well, maybe it does, but we do NOT want to maintain more than one CSS)
                        lang = "en";
                }
                Page page = pageDAO.loadByName(name, Language.fromString(lang));
                if (page != null) {
                       
                        String oldTitle = page.getTitle();
                        String oldBody = page.getBody();
                       
                        input.inject(page);
                       
                        page.setModifiedById(sessionUser.getId());
                       
                        if (input.getBoolean("isPreview")) {
                                pageDAO.insertPreview(sessionUser.getId(), page);
                        } else {
                                pageDAO.update(page);
                               
                                insertRevision(page, oldTitle, oldBody);
                               
                                // and now you have to delete the preview!
                                pageDAO.deletePreview(sessionUser.getId(), page.getName(), page.getLanguage());
                        }
                        setPageRedirParams(page);
                }
                return UPDATED;
        }
       
        public String discardPreview() {
                String name = input.getString("name");
                Language lang = Language.fromString(input.getString("lang"));
                int userId = sessionUser.getId();
                pageDAO.deletePreview(userId, name, lang);
                output.setValue("name", name);
                output.setValue("lang", lang.getLocale());
                return REMOVED;
        }
       
        public String add() {
                if (!isPost()) return INDEX;
                Page p = input.getObject(Page.class, "newPage");
                p.setCreatedById(sessionUser.getId());
               
                if (input.getBoolean("isPreview")) {
                        pageDAO.insertPreview(sessionUser.getId(), p);
                } else {
                        pageDAO.insert(p);
                        // and now you have to delete the preview!
                        pageDAO.deletePreview(sessionUser.getId(), p.getName(), p.getLanguage());
                }
                setPageRedirParams(p);
                return CREATED;
        }
       
        public String list() {
                List<Page> pages = pageDAO.loadAll(sessionUser.getGroup() == Group.ADMIN);
                output.setValue("pages", pages);
                return AJAX;
        }
       
        public String setFrontPage() {
                int id = input.getInt("pageId");
                Page p = pageDAO.load(id);
                if (p != null) {
                        if (pageDAO.setNewFrontPage(p)) {
                                output.setValue("lang", p.getLang());
                        }
                }
                return UPDATED;
        }
       
        public String delete() {
                int id = input.getInt("pageId");
                Page p = pageDAO.load(id);
                if (p != null ) {
                        pageDAO.delete(p);
                }
                return UPDATED;
        }
}