Kawai Wiki

Rev

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

package org.kawai.dao.jdbc;

import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.LinkedList;
import java.util.List;

import org.kawai.dao.PageDAO;
import org.kawai.model.Language;
import org.kawai.model.Page;
import org.kawai.model.Preview;
import org.kawai.model.Revision;
import org.kawai.model.User;
import org.mentabean.BeanSession;

public class JdbcPageDAO extends AbstractJdbcDAO implements PageDAO {
       
        public JdbcPageDAO(BeanSession session) {
                super(session);
        }

        @Override
        public Page load(int id) {
               
                Page p = new Page();
                p.setId(id);
               
                if (session.load(p)) {
                        loadUsers(p);
                        return p;
                }
               
                return null;
        }
       
        @Override
        public Page loadByName(String name, Language lang) {
                Page p = new Page();
                p.setName(name);
                p.setLanguageId(lang.getId());
                p.setDeleted(false);
                p = session.loadUnique(p);
                if (p != null) {
                        loadUsers(p);
                }
                return p;
        }
       
        @Override
        public Page loadFrontPage(Language lang) {
                Page p = new Page();
                p.setLanguageId(lang.getId());
                p.setFrontPage(true);
                p.setDeleted(false);
                p = session.loadUnique(p);
                if (p != null) {
                        loadUsers(p);
                }
                return p;
        }
       
        private void loadUsers(Page p) {
                User modifier = new User();
                modifier.setId(p.getModifiedById());
               
                if (p.getModifiedById() > 0) {
                        if (session.load(modifier)) {
                                p.setModifiedBy(modifier);
                        } else {
                                throw new IllegalStateException("Cannot load user by id: " + p.getModifiedById());
                        }
                }
               
                User creator = new User();
                creator.setId(p.getCreatedById());
               
                if (p.getCreatedById() > 0) {
                        if (session.load(creator)) {
                                p.setCreatedBy(creator);
                        } else {
                                throw new IllegalStateException("Cannot load user by id: " + p.getCreatedById());
                        }
                }
        }
       
        @Override
        public void update(Page p) {
                session.update(p);
        }
       
        @Override
        public void insert(Page p) {
                p.setDeleted(false);
                session.insert(p);
        }
       
        @Override
        public boolean exists(String name, Language lang) {
                return loadByName(name, lang) != null;
        }
       
        @Override
        public boolean isSystemPage(String name) {
                Page page = new Page();
                page.setName(name);
                page.setDeleted(false);
                List<Page> list = session.loadList(page);
                for(Page thePage : list) {
                        if (thePage.isSystemPage()) return true;
                }
                return false;
        }
       
        @Override
        public List<Page> loadAll(boolean includeSystemPages) {
               
                PreparedStatement stmt = null;
                ResultSet rset = null;
               
                try {

                        StringBuilder query = new StringBuilder(512);
                        query.append("select ").append(session.buildSelect(Page.class, "p"));
                        query.append(", ").append(session.buildSelect(User.class, "creator"));
                        query.append(", ").append(session.buildSelect(User.class, "modifier"));
                        query.append(" from Pages p");
                        query.append(" join Users creator on p.created_by = creator.id");
                        query.append(" left join Users modifier on p.modified_by = modifier.id");
                        query.append(" where p.deleted = 'F'");
                        if (!includeSystemPages) {
                                query.append(" and p.system_page = 'F'");
                        }
                        query.append(" order by p.system_page, p.front_page, p.name, p.language_id");
                       
                        stmt = conn.prepareStatement(query.toString());
                       
                        rset = stmt.executeQuery();
                       
                        List<Page> pages = new LinkedList<Page>();
                       
                        while(rset.next()) {
                               
                                Page p = new Page();
                                session.populateBean(rset, p, "p");
                               
                                User creator = new User();
                                session.populateBean(rset, creator, "creator");
                                p.setCreatedBy(creator);
                               
                                if (rset.getInt("modifier_id") > 0) {
                                        User modifier = new User();
                                        session.populateBean(rset, modifier, "modifier");
                                        p.setModifiedBy(modifier);
                                }
                               
                                pages.add(p);
                        }
                       
                        return pages;
                       
                } catch(Exception e) {
                        throw new RuntimeException(e);
                } finally {
                        close(stmt, rset);
                }
        }
       
        private Page get(List<Page> pages, Language lang) {
                for(Page p : pages) {
                        if (p.getLanguage() == lang) return p;
                }
                return null;
        }
       
        @Override
        public boolean setNewFrontPage(Page p) {
               
                if (p.isSystemPage() || p.isFrontPage() || p.isDeleted()) return false;
               
                Page page = new Page();
                page.setFrontPage(true);
                page.setDeleted(false);
               
                List<Page> frontPages = session.loadList(page);
                Page currFrontPage = get(frontPages, p.getLanguage());
               
                if (currFrontPage != null) {
                        // it is not front-page anymore...
                        session.load(currFrontPage); // reload to attach to session...
                        currFrontPage.setFrontPage(false);
                        session.update(currFrontPage);
                }
               
                p.setFrontPage(true);
                session.update(p);
               
                return true;
        }
       
        @Override
        public boolean delete(Page p) {
                if (p.isDeleted() || p.isSystemPage() || p.isFrontPage()) return false;
                p.setDeleted(true);
                session.update(p);
                return true;
        }
       
        @Override
        public Preview loadPreview(int userId, String name, Language lang) {
                Preview p = new Preview();
                p.setName(name);
                p.setLanguageId(lang.getId());
                p.setUserId(userId);
               
                p = session.loadUnique(p);
               
                if (p != null) {
                        User user = new User();
                        user.setId(userId);
                        session.load(user);
                        p.setUser(user);
                       
                        Page page = loadByName(name, lang);
                        if (page != null) {
                                p.setNew(false);
                                p.setSystemPage(page.isSystemPage());
                        } else {
                                p.setNew(true);
                                p.setSystemPage(false);
                        }
                }
               
                return p;
        }
       
        @Override
        public Preview insertPreview(int userId, Page page) {
                Preview preview = loadPreview(userId, page.getName(), page.getLanguage());
                if (preview != null) {
                        preview.setTitle(page.getTitle());
                        preview.setBody(page.getBody());
                        session.update(preview);
                } else {
                        preview = new Preview();
                        preview.setName(page.getName());
                        preview.setLanguageId(page.getLanguageId());
                        preview.setUserId(userId);
                        preview.setTitle(page.getTitle());
                        preview.setBody(page.getBody());
                        session.insert(preview);
                }
                return preview;
        }
       
        @Override
        public String getFrontPage(Language lang) {
                Page page = new Page();
                page.setLanguageId(lang.getId());
                page.setFrontPage(true);
               
                Page front = session.loadUnique(page);
                if (front != null) {
                        return front.getName();
                }
                return null;
        }
       
        @Override
        public Page loadByNameWithPreview(int userId, String name, Language lang) {
                Page p = loadByName(name, lang);
                if (p == null) {
                        // we may still have a preview...
                        Preview preview = loadPreview(userId, name, lang);
                        if (preview != null) {
                                preview.setNew(true);
                                return preview.getPage();
                        }
                        return null;
                } else {
                        // check if we have a preview for this page...
                        Preview preview = loadPreview(userId, name, lang);
                        if (preview != null) {
                                preview.setNew(false);
                                p.setPreview(preview);
                        }
                        return p;
                }
        }
       
        @Override
        public void deletePreview(int userId, String name, Language lang) {
                Preview preview = loadPreview(userId, name, lang);
                if (preview != null) {
                        Preview p = new Preview();
                        p.setId(preview.getId());
                        session.delete(p);
                }
        }
       
        @Override
        public Revision loadRevision(int revision, String name, Language lang) {
                Revision r = new Revision();
                r.setRevision(revision);
                r.setName(name);
                r.setLanguageId(lang.getId());
                return session.loadUnique(r);
        }
       
        @Override
        public void insertRevision(Revision r) {
               
                PreparedStatement stmt = null;
                ResultSet rset = null;
               
                try {
                       
                        // first time, lock whole table
                        stmt = conn.prepareStatement("LOCK TABLES Revisions WRITE"); // this works as a synchronized block locked on the database... (I tested it!)
                        stmt.execute();
                        stmt.close();
                       
                        stmt = conn.prepareStatement("select max(revision) from Revisions where name = ? and language_id = ?");
                        stmt.setString(1, r.getName());
                        stmt.setInt(2, r.getLanguageId());
                        rset = stmt.executeQuery();
                        rset.next();
                        int revisionNumber = rset.getInt(1) + 1;
                        rset.close();
                        stmt.close();
                       
                        r.setRevision(revisionNumber);
                        session.insert(r);

                        stmt = conn.prepareStatement("UNLOCK TABLES");
                        stmt.execute();
                       
                } catch(Exception e) {
                        throw new RuntimeException(e);
                } finally {
                        close(stmt, rset);
                }
        }
       
        @Override
        public List<Revision> loadRevisions(String name, Language lang) {
               
                Revision r = new Revision();
                r.setName(name);
                r.setLanguageId(lang.getId());
               
                return session.loadList(r, "revision desc");
        }
}