Kawai Wiki

Rev

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