Kawai Wiki

Rev

Rev 191 | Rev 228 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
11 soliveira 1
package org.kawai.dao.jdbc;
2
 
49 soliveira 3
import java.sql.PreparedStatement;
4
import java.sql.ResultSet;
80 soliveira 5
import java.util.ArrayList;
49 soliveira 6
import java.util.LinkedList;
39 soliveira 7
import java.util.List;
8
 
11 soliveira 9
import org.kawai.dao.PageDAO;
22 soliveira 10
import org.kawai.model.Language;
11 soliveira 11
import org.kawai.model.Page;
60 soliveira 12
import org.kawai.model.Preview;
78 soliveira 13
import org.kawai.model.Revision;
25 soliveira 14
import org.kawai.model.User;
11 soliveira 15
import org.mentabean.BeanSession;
16
 
191 helio.frota 17
/**
18
 * DAO class JdbcPageDAO.
19
 *
20
 * @author Sergio Oliveira
21
 *
22
 */
12 soliveira 23
public class JdbcPageDAO extends AbstractJdbcDAO implements PageDAO {
24
 
191 helio.frota 25
        /**
26
         * Parametric constructor.
27
         * @param session BeanSession
28
         */
29
    public JdbcPageDAO(BeanSession session) {
30
        super(session);
31
    }
86 soliveira 32
 
191 helio.frota 33
    /**
34
     * Loads the page object by id.
35
     * @return Page
36
     */
37
    @Override
38
    public Page load(int id) {
49 soliveira 39
 
191 helio.frota 40
        Page p = new Page();
41
        p.setId(id);
78 soliveira 42
 
191 helio.frota 43
        if (session.load(p)) {
44
            loadUsers(p);
45
            return p;
46
        }
47
 
48
        return null;
49
    }
50
 
51
    /**
52
     * Loads the page object by name and language.
53
     * @return Page
54
     */
55
    @Override
56
    public Page loadByName(String name, Language lang) {
57
        return loadByName(name, lang, -1);
58
    }
59
 
60
    /**
61
     * Loads the page object by name, language and revision.
62
     * @return Page
63
     */
64
    @Override
65
    public Page loadByName(String name, Language lang, int revision) {
66
        Page p = new Page();
67
        p.setName(name);
68
        p.setLanguageId(lang.getId());
69
        p.setDeleted(false);
70
        p = session.loadUnique(p);
71
 
72
        if (p != null) {
73
            if (revision >= 0) {
74
                Revision r = loadRevision(revision, name, lang);
75
                if (r != null) {
76
                    p.setCreatedById(r.getUserId());
77
                    p.setCreatedOn(r.getCreatedOn());
78
                    p.setModifiedById(-1);
79
                    p.setModifiedOn(null);
80
                    p.setRevision(true);
81
                    p.setRevisionNumber(r.getRevision());
82
                    p.setTitle(r.getNewTitle());
83
                    p.setBody(r.getNewBody());
84
                }
85
            }
86
            loadUsers(p);
87
        }
88
        return p;
89
    }
90
 
91
    /**
92
     * Loads the front page by language.
93
     * @return Page
94
     */
95
    @Override
96
    public Page loadFrontPage(Language lang) {
97
        Page p = new Page();
98
        p.setLanguageId(lang.getId());
99
        p.setFrontPage(true);
100
        p.setDeleted(false);
101
        p = session.loadUnique(p);
102
        if (p != null) {
103
            loadUsers(p);
104
        }
105
        return p;
106
    }
107
 
108
    private void loadUsers(Page p) {
109
        User modifier = new User();
110
        modifier.setId(p.getModifiedById());
111
 
112
        if (p.getModifiedById() > 0) {
113
            if (session.load(modifier)) {
114
                p.setModifiedBy(modifier);
115
            } else {
116
                throw new IllegalStateException("Cannot load user by id: " + p.getModifiedById());
117
            }
118
        }
119
 
120
        User creator = new User();
121
        creator.setId(p.getCreatedById());
122
 
123
        if (p.getCreatedById() > 0) {
124
            if (session.load(creator)) {
125
                p.setCreatedBy(creator);
126
            } else {
127
                throw new IllegalStateException("Cannot load user by id: " + p.getCreatedById());
128
            }
129
        }
130
    }
131
 
132
    /**
133
     * Updates the page on database.
134
     * @param p Page
135
     */
136
    @Override
137
    public void update(Page p) {
138
        session.update(p);
139
    }
140
 
141
    /**
142
     * Persist the page on database.
143
     * @param p Page
144
     */
145
    @Override
146
    public void insert(Page p) {
147
        p.setDeleted(false);
148
        session.insert(p);
149
    }
150
 
151
    /**
152
     * Checks if page exists by name and language.
153
     * @param name String
154
     * @param lang Language
155
     * @return boolean
156
     */
157
    @Override
158
    public boolean exists(String name, Language lang) {
159
        return loadByName(name, lang) != null;
160
    }
161
 
162
    /**
163
     * Checks if is system page.
164
     * @param name String
165
     * @return boolean
166
     */
167
    @Override
168
    public boolean isSystemPage(String name) {
169
        Page page = new Page();
170
        page.setName(name);
171
        page.setDeleted(false);
172
        List<Page> list = session.loadList(page);
173
        for(Page thePage : list) {
174
            if (thePage.isSystemPage()) return true;
175
        }
176
        return false;
177
    }
178
 
179
    /**
180
     * Load all page including system pages.
181
     * @return List < Page >
182
     */
183
    @Override
184
    public List<Page> loadAll(boolean includeSystemPages) {
185
 
186
        String[] propsToExclude = { "body" };
187
 
188
        PreparedStatement stmt = null;
189
        ResultSet rset = null;
190
 
191
        try {
192
 
193
            StringBuilder query = new StringBuilder(512);
194
            query.append("select ").append(session.buildSelectMinus(Page.class, "p", propsToExclude));
195
            query.append(", ").append(session.buildSelect(User.class, "creator"));
196
            query.append(", ").append(session.buildSelect(User.class, "modifier"));
197
            query.append(" from Pages p");
198
            query.append(" join Users creator on p.created_by = creator.id");
199
            query.append(" left join Users modifier on p.modified_by = modifier.id");
200 soliveira 200
            query.append(" where p.deleted = 'F' and p.language_id in (");
201
 
202
            List<Language> langs = Language.all();
203
            int count = 0;
204
            for(Language lang : langs) {
205
                if (count++ > 0) query.append(",");
206
                query.append(lang.getId());
207
            }
208
            query.append(")");
209
 
191 helio.frota 210
            if (!includeSystemPages) {
211
                query.append(" and p.system_page = 'F'");
212
            }
213
            query.append(" order by p.system_page, p.front_page, p.name, p.language_id");
214
 
215
            stmt = conn.prepareStatement(query.toString());
216
 
217
            rset = stmt.executeQuery();
218
 
219
            List<Page> pages = new LinkedList<Page>();
220
 
221
            while(rset.next()) {
222
 
223
                Page p = new Page();
224
                session.populateBeanMinus(rset, p, "p", propsToExclude);
225
 
226
                User creator = new User();
227
                session.populateBean(rset, creator, "creator");
228
                p.setCreatedBy(creator);
229
 
230
                if (rset.getInt("modifier_id") > 0) {
231
                    User modifier = new User();
232
                    session.populateBean(rset, modifier, "modifier");
233
                    p.setModifiedBy(modifier);
234
                }
235
 
236
                pages.add(p);
237
            }
238
 
239
            return pages;
240
 
241
        } catch(Exception e) {
242
            throw new RuntimeException(e);
243
        } finally {
244
            close(stmt, rset);
245
        }
246
    }
247
 
248
    private Page get(List<Page> pages, Language lang) {
249
        for(Page p : pages) {
250
            if (p.getLanguage() == lang) return p;
251
        }
252
        return null;
253
    }
254
 
255
    /**
256
     * Sets the new front page.
257
     * @param p Page
258
     * @return boolean
259
     */
260
    @Override
261
    public boolean setNewFrontPage(Page p) {
262
 
263
        if (p.isSystemPage() || p.isFrontPage() || p.isDeleted()) return false;
264
 
265
        Page page = new Page();
266
        page.setFrontPage(true);
267
        page.setDeleted(false);
268
 
269
        List<Page> frontPages = session.loadList(page);
270
        Page currFrontPage = get(frontPages, p.getLanguage());
271
 
272
        if (currFrontPage != null) {
273
            // it is not front-page anymore...
274
            session.load(currFrontPage); // reload to attach to session...
275
            currFrontPage.setFrontPage(false);
276
            session.update(currFrontPage);
277
        }
278
 
279
        p.setFrontPage(true);
280
        session.update(p);
281
 
282
        return true;
283
    }
284
 
285
    @Override
286
    public boolean delete(Page p) {
287
        if (p.isDeleted() || p.isSystemPage() || p.isFrontPage()) return false;
288
        p.setDeleted(true);
289
        session.update(p);
290
        return true;
291
    }
292
 
293
    @Override
294
    public Preview loadPreview(int userId, String name, Language lang) {
295
        Preview p = new Preview();
296
        p.setName(name);
297
        p.setLanguageId(lang.getId());
298
        p.setUserId(userId);
299
 
300
        p = session.loadUnique(p);
301
 
302
        if (p != null) {
303
            User user = new User();
304
            user.setId(userId);
305
            session.load(user);
306
            p.setUser(user);
307
 
308
            Page page = loadByName(name, lang);
309
            if (page != null) {
310
                p.setNew(false);
311
                p.setSystemPage(page.isSystemPage());
312
            } else {
313
                p.setNew(true);
314
                p.setSystemPage(false);
315
            }
316
        }
317
 
318
        return p;
319
    }
320
 
321
    @Override
322
    public Preview insertPreview(int userId, Page page, String comment) {
323
        Preview preview = loadPreview(userId, page.getName(), page.getLanguage());
324
        if (preview != null) {
325
            preview.setTitle(page.getTitle());
326
            preview.setBody(page.getBody());
327
            preview.setComment(comment);
328
            session.update(preview);
329
        } else {
330
            preview = new Preview();
331
            preview.setName(page.getName());
332
            preview.setLanguageId(page.getLanguageId());
333
            preview.setUserId(userId);
334
            preview.setTitle(page.getTitle());
335
            preview.setBody(page.getBody());
336
            preview.setComment(comment);
337
            session.insert(preview);
338
        }
339
        return preview;
340
    }
341
 
342
    @Override
343
    public String getFrontPage(Language lang) {
344
        Page page = new Page();
345
        page.setLanguageId(lang.getId());
346
        page.setFrontPage(true);
347
 
348
        Page front = session.loadUnique(page);
349
        if (front != null) {
350
            return front.getName();
351
        }
352
        return null;
353
    }
354
 
355
    @Override
356
    public Page loadByNameWithPreview(int userId, String name, Language lang) {
357
        Page p = loadByName(name, lang);
358
        if (p == null) {
359
            // we may still have a preview...
360
            Preview preview = loadPreview(userId, name, lang);
361
            if (preview != null) {
362
                preview.setNew(true);
363
                return preview.getPage();
364
            }
365
            return null;
366
        } else {
367
            // check if we have a preview for this page...
368
            Preview preview = loadPreview(userId, name, lang);
369
            if (preview != null) {
370
                preview.setNew(false);
371
                p.setPreview(preview);
372
            }
373
            return p;
374
        }
375
    }
376
 
377
    @Override
378
    public void deletePreview(int userId, String name, Language lang) {
379
        Preview preview = loadPreview(userId, name, lang);
380
        if (preview != null) {
381
            Preview p = new Preview();
382
            p.setId(preview.getId());
383
            session.delete(p);
384
        }
385
    }
386
 
387
    @Override
388
    public Revision loadRevision(int revision, String name, Language lang) {
389
        Revision r = new Revision();
390
        r.setRevision(revision);
391
        r.setName(name);
392
        r.setLanguageId(lang.getId());
393
        return session.loadUnique(r);
394
    }
395
 
396
    @Override
397
    public void insertRevision(Revision r) {
398
 
399
        PreparedStatement stmt = null;
400
        ResultSet rset = null;
401
 
402
        try {
403
 
404
            // first time, lock whole table
405
            stmt = conn.prepareStatement("LOCK TABLES Revisions WRITE"); // this works as a synchronized block locked on the database... (I tested it!)
406
            stmt.execute();
407
            stmt.close();
408
 
409
            stmt = conn.prepareStatement("select max(revision) from Revisions where name = ? and language_id = ?");
410
            stmt.setString(1, r.getName());
411
            stmt.setInt(2, r.getLanguageId());
412
            rset = stmt.executeQuery();
413
            rset.next();
414
            int revisionNumber = rset.getInt(1) + 1;
415
 
416
            if (rset.wasNull()) {
417
                // inserting for the very first time... (page creatiion, not modification)
418
                revisionNumber = 0;
419
            }
420
 
421
            rset.close();
422
            stmt.close();
423
 
424
            r.setRevision(revisionNumber);
425
            session.insert(r);
426
 
427
            stmt = conn.prepareStatement("UNLOCK TABLES");
428
            stmt.execute();
429
 
430
        } catch(Exception e) {
431
            throw new RuntimeException(e);
432
        } finally {
433
            close(stmt, rset);
434
        }
435
    }
436
 
437
    @Override
438
    public List<Revision> loadRevisions(String name, Language lang) {
439
 
440
        String[] propsToExclude = { "oldTitle", "newTitle", "oldBody", "newBody" };
441
 
442
        PreparedStatement stmt = null;
443
        ResultSet rset = null;
444
 
445
        try {
446
 
447
            StringBuilder query = new StringBuilder(256);
448
            query.append("select ").append(session.buildSelectMinus(Revision.class, "r", propsToExclude));
449
            query.append(", ").append(session.buildSelect(User.class, "u"));
450
            query.append(", p.system_page p_system_page");
451
            query.append(", p.front_page p_front_page");
452
            query.append(", p.title p_title");
453
            query.append(" from Revisions r join Users u on r.user_id = u.id");
454
            query.append(" join Pages p on r.name = p.name and r.language_id = p.language_id");
455
            query.append(" where r.name = ? and r.language_id = ?");
456
            query.append(" order by revision desc");
457
            query.append(" limit 50");
458
 
459
            stmt = conn.prepareStatement(query.toString());
460
            stmt.setString(1, name);
461
            stmt.setInt(2, lang.getId());
462
 
463
            rset = stmt.executeQuery();
464
 
465
            List<Revision> revisions = new ArrayList<Revision>(50);
466
 
467
            while(rset.next()) {
468
 
469
                Revision r = new Revision();
470
                session.populateBeanMinus(rset, r, "r", propsToExclude);
471
 
472
                User u = new User();
473
                session.populateBean(rset, u, "u");
474
                r.setUser(u);
475
 
476
                boolean isSystemPage = rset.getString("p_system_page").equals("T");
477
                r.setSystemPage(isSystemPage);
478
 
479
                boolean isFrontPage = rset.getString("p_front_page").equals("T");
480
                r.setFrontPage(isFrontPage);
481
 
482
                String title = rset.getString("p_title");
483
                r.setTitle(title);
484
 
485
                revisions.add(r);
486
            }
487
 
488
            return revisions;
489
        } catch(Exception e) {
490
            throw new RuntimeException(e);
491
        } finally {
492
            close(stmt, rset);
493
        }
494
    }
495
 
496
    @Override
497
    public List<Revision> loadLastRevisions(Language lang, boolean includeSystemPages) {
498
 
499
        String[] propsToExclude = { "oldTitle", "newTitle", "oldBody", "newBody" };
500
 
501
        PreparedStatement stmt = null;
502
        ResultSet rset = null;
503
 
504
        try {
505
            StringBuilder sb = new StringBuilder(512);
506
            sb.append("select ").append(session.buildSelectMinus(Revision.class, "r", propsToExclude));
507
            sb.append(", ").append(session.buildSelect(User.class, "u"));
508
            sb.append(", p.system_page p_system_page");
509
            sb.append(", p.front_page p_front_page");
510
            sb.append(", p.title p_title");
511
            sb.append(" from Revisions r join Users u on r.user_id = u.id");
512
            sb.append(" join Pages p on r.name = p.name and r.language_id = p.language_id");
513
            sb.append(" where r.language_id = ?");
514
            if (!includeSystemPages) {
515
                sb.append(" and p.system_page = 'F'");
516
            }
517
            sb.append(" order by r.created_on desc");
518
            sb.append(" limit 50");
519
 
520
            stmt = conn.prepareStatement(sb.toString());
521
            stmt.setInt(1, lang.getId());
522
 
523
            rset = stmt.executeQuery();
524
 
525
            List<Revision> results = new ArrayList<Revision>(50);
526
 
527
            while(rset.next()) {
528
                Revision r = new Revision();
529
                session.populateBeanMinus(rset, r, "r", propsToExclude);
530
 
531
                User u = new User();
532
                session.populateBean(rset, u, "u");
533
                r.setUser(u);
534
 
535
                boolean isSystemPage = rset.getString("p_system_page").equals("T");
536
                r.setSystemPage(isSystemPage);
537
 
538
                boolean isFrontPage = rset.getString("p_front_page").equals("T");
539
                r.setFrontPage(isFrontPage);
540
 
541
                String title = rset.getString("p_title");
542
                r.setTitle(title);
543
 
544
                results.add(r);
545
            }
546
 
547
            return results;
548
 
549
        } catch(Exception e) {
550
            throw new RuntimeException(e);
551
        } finally {
552
            close(stmt, rset);
553
        }
554
 
555
    }
556
}