source: DASISH/t5.6/backend/annotator-backend/trunk/annotator-backend/src/main/java/eu/dasish/annotation/backend/dao/impl/JdbcNotebookDao.java @ 4506

Last change on this file since 4506 was 4506, checked in by olhsha, 10 years ago

NotebookDao? Unit test is finished. Passes.
File size: 19.4 KB
Line 
1/*
2 * Copyright (C) 2013 DASISH
3 *
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public License
6 * as published by the Free Software Foundation; either version 2
7 * of the License, or (at your option) any later version.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
17 */
18package eu.dasish.annotation.backend.dao.impl;
19
20import eu.dasish.annotation.backend.dao.NotebookDao;
21import eu.dasish.annotation.schema.Notebook;
22import eu.dasish.annotation.schema.NotebookInfo;
23import eu.dasish.annotation.schema.Permission;
24import java.sql.ResultSet;
25import java.sql.SQLException;
26import java.util.GregorianCalendar;
27import java.util.HashMap;
28import java.util.List;
29import java.util.Map;
30import java.util.UUID;
31import javax.sql.DataSource;
32import org.springframework.jdbc.core.RowMapper;
33import javax.xml.datatype.DatatypeConfigurationException;
34import javax.xml.datatype.DatatypeFactory;
35import javax.xml.datatype.XMLGregorianCalendar;
36import org.slf4j.Logger;
37import org.slf4j.LoggerFactory;
38
39/**
40 * Created on : Jun 14, 2013, 3:27:04 PM
41 *
42 * @author Peter Withers <peter.withers@mpi.nl>
43 */
44// TODO: not updated fully yet.
45public class JdbcNotebookDao extends JdbcResourceDao implements NotebookDao {
46
47    private final Logger loggerNotebookDao = LoggerFactory.getLogger(JdbcNotebookDao.class);
48
49    public JdbcNotebookDao(DataSource dataSource) {
50        setDataSource(dataSource);
51        internalIdName = notebook_id;
52        resourceTableName = notebookTableName;
53    }
54
55    /// GETTERS /////////
56    ////////////////////////////////////////////////
57    ////////////////////////////////////////////////
58    @Override
59    public Number getOwner(Number notebookID) {
60        if (notebookID == null) {
61            loggerNotebookDao.debug("notebookID: " + nullArgument);
62            return null;
63        }
64        StringBuilder sql = new StringBuilder("SELECT ");
65        sql.append(owner_id).append(" FROM ").append(notebookTableName).append(" WHERE ").
66                append(notebook_id).append(" = ?");
67        List<Number> result = getSimpleJdbcTemplate().query(sql.toString(), ownerIDRowMapper, notebookID);
68        if (result.isEmpty()) {
69            return null;
70        } else {
71            return result.get(0);
72        }
73    }
74
75    @Override
76    public List<Number> getNotebookIDs(Number principalID, Permission permission) {
77
78        if (principalID == null) {
79            loggerNotebookDao.debug("princiaplID: " + nullArgument);
80            return null;
81        }
82
83        if (permission == null) {
84            loggerNotebookDao.debug("permission: " + nullArgument);
85            return null;
86        }
87
88        Map<String, Object> params = new HashMap<String, Object>();
89        params.put("principalID", principalID);
90        params.put("accessMode", permission.value());
91        StringBuilder sql = new StringBuilder("SELECT ");
92        sql.append(notebook_id).append(" FROM ").append(notebookPermissionsTableName).append(" WHERE ").
93                append(principal_id).append(" = :principalID AND ").append(this.permission).append(" = :accessMode");
94        return getSimpleJdbcTemplate().query(sql.toString(), internalIDRowMapper, params);
95    }
96
97    ////////////////////////////////////////////////
98    @Override
99    public List<Number> getNotebookIDsOwnedBy(Number principalID) {
100
101        if (principalID == null) {
102            loggerNotebookDao.debug("principalID: " + nullArgument);
103            return null;
104        }
105
106        StringBuilder sql = new StringBuilder("SELECT ");
107        sql.append(notebook_id).append(" FROM ").append(notebookTableName).append(" WHERE ").
108                append(owner_id).append(" = ?");
109        return getSimpleJdbcTemplate().query(sql.toString(), internalIDRowMapper, principalID);
110    }
111
112    @Override
113    public List<Number> getPrincipalIDsWithPermission(Number notebookID, Permission permission) {
114        if (notebookID == null) {
115            loggerNotebookDao.debug("notebookID: " + nullArgument);
116            return null;
117        }
118
119        if (permission == null) {
120            loggerNotebookDao.debug("permission: " + nullArgument);
121            return null;
122        }
123        Map<String, Object> params = new HashMap<String, Object>();
124        params.put("notebookID", notebookID);
125        params.put("accessMode", permission.value());
126
127        StringBuilder sql = new StringBuilder("SELECT ");
128        sql.append(principal_id).append(" FROM ").append(notebookPermissionsTableName).append(" WHERE ").
129                append(notebook_id).append(" = :notebookID AND ").append(this.permission).append(" = :accessMode");
130
131        return getSimpleJdbcTemplate().query(sql.toString(), principalIDRowMapper, params);
132
133    }
134
135    @Override
136    public NotebookInfo getNotebookInfoWithoutOwner(Number notebookID) {
137        if (notebookID == null) {
138            loggerNotebookDao.debug("notebookID: " + nullArgument);
139            return null;
140        }
141
142        StringBuilder sql = new StringBuilder("SELECT ");
143        sql.append(external_id).append(" , ").append(title).
144                append(" FROM ").append(notebookTableName).append(" WHERE ").
145                append(notebook_id).append(" = :notebookID");
146        List<NotebookInfo> result = getSimpleJdbcTemplate().query(sql.toString(), notebookInfoRowMapper, notebookID);
147        return (!result.isEmpty() ? result.get(0) : null);
148    }
149    private final RowMapper<NotebookInfo> notebookInfoRowMapper = new RowMapper<NotebookInfo>() {
150        @Override
151        public NotebookInfo mapRow(ResultSet rs, int rowNumber) throws SQLException {
152            NotebookInfo notebookInfo = new NotebookInfo();
153            notebookInfo.setRef(externalIDtoURI(rs.getString(external_id)));
154            notebookInfo.setTitle(rs.getString(title));
155            return notebookInfo;
156        }
157    };
158
159    @Override
160    public Notebook getNotebookWithoutAnnotationsAndPermissionsAndOwner(Number notebookID) {
161        if (notebookID == null) {
162            loggerNotebookDao.debug("notebookID: " + nullArgument);
163            return null;
164        }
165        StringBuilder sql = new StringBuilder("SELECT ");
166        sql.append(external_id).append(" , ").append(title).append(" , ").append(last_modified).
167                append(" FROM ").append(notebookTableName).append(" WHERE ").
168                append(notebook_id).append(" = :notebookID");
169        List<Notebook> result = getSimpleJdbcTemplate().query(sql.toString(), notebookRowMapper, notebookID);
170        return (!result.isEmpty() ? result.get(0) : null);
171    }
172    private final RowMapper<Notebook> notebookRowMapper = new RowMapper<Notebook>() {
173        @Override
174        public Notebook mapRow(ResultSet rs, int rowNumber) throws SQLException {
175            Notebook notebook = new Notebook();
176            notebook.setTitle(rs.getString(title));
177            notebook.setLastModified(timeStampToXMLGregorianCalendar(rs.getString(last_modified)));
178            notebook.setURI(externalIDtoURI(rs.getString(external_id)));
179            return notebook;
180        }
181    };
182
183    @Override
184    public List<Number> getAnnotations(Number notebookID) {
185
186        if (notebookID == null) {
187            loggerNotebookDao.debug("notebookID: " + nullArgument);
188            return null;
189        }
190
191        StringBuilder sql = new StringBuilder("SELECT ");
192        sql.append(annotation_id).
193                append(" FROM ").append(notebooksAnnotationsTableName).append(" WHERE ").
194                append(notebook_id).append(" = :notebookID");
195        return getSimpleJdbcTemplate().query(sql.toString(), annotationIDRowMapper, notebookID);
196
197    }
198
199    /**
200     *
201     * UPDATERS
202     *
203     *
204     */
205    /**
206     *
207     * @param notebookID
208     * @return true if updated, false otherwise. Logs the reason if the notebook
209     * is not updated.
210     */
211    @Override
212    public boolean updateNotebookMetadata(Number notebookID, String title, Number ownerID) {
213
214        if (notebookID == null) {
215            loggerNotebookDao.debug("notebookID: " + nullArgument);
216            return false;
217        }
218
219        if (title == null) {
220            loggerNotebookDao.debug("title: " + nullArgument);
221            return false;
222        }
223
224        if (ownerID == null) {
225            loggerNotebookDao.debug("ownerID: " + nullArgument);
226            return false;
227        }
228
229        Map<String, Object> params = new HashMap<String, Object>();
230        params.put("notebookID", notebookID);
231        params.put("title", title);
232        params.put("owner", ownerID);
233
234        StringBuilder sql = new StringBuilder("UPDATE ");
235        sql.append(notebookTableName).append(" SET ").
236                append(last_modified).append("=  default,").
237                append(this.title).append("= :title, ").
238                append(owner_id).append("= :owner").
239                append(" WHERE ").append(notebook_id).append("= :notebookID");
240        int affectedRows = getSimpleJdbcTemplate().update(sql.toString(), params);
241        if (affectedRows <= 0) {
242            logger.info("For some reason no rows in the table notebooks were updated. ");
243            return false;
244        } else {
245            if (affectedRows > 1) {
246                logger.info("For some reason more than 1 row in the table notebooks were updated. that's strange.");
247                return true;
248            } else {
249                return true;
250            }
251        }
252    }
253   
254    @Override
255    public boolean setOwner(Number notebookID, Number ownerID) {
256
257        if (notebookID == null) {
258            loggerNotebookDao.debug("notebookID: " + nullArgument);
259            return false;
260        }
261
262        if (ownerID == null) {
263            loggerNotebookDao.debug("ownerID: " + nullArgument);
264            return false;
265        }
266
267        Map<String, Object> params = new HashMap<String, Object>();
268        params.put("notebookID", notebookID);
269        params.put("ownerID", ownerID);
270
271        StringBuilder sql = new StringBuilder("UPDATE ");
272        sql.append(notebookTableName).append(" SET ").
273                append(last_modified).append("=  default,").
274                append(owner_id).append("= :ownerID").
275                append(" WHERE ").append(notebook_id).append("= :notebookID");
276        int affectedRows = getSimpleJdbcTemplate().update(sql.toString(), params);
277        if (affectedRows <= 0) {
278            logger.info("For some reason no rows in the table notebooks were updated. ");
279            return false;
280        } else {
281            if (affectedRows > 1) {
282                logger.info("For some reason more than 1 row in the table notebooks were updated. that's strange.");
283                return true;
284            } else {
285                return true;
286            }
287        }
288    }
289
290    @Override
291    public boolean updateUserPermissionForNotebook(Number notebookID, Number principalID, Permission permission) {
292
293        if (notebookID == null) {
294            loggerNotebookDao.debug("notebookID: " + nullArgument);
295            return false;
296        }
297
298        if (principalID == null) {
299            loggerNotebookDao.debug("principalID: " + nullArgument);
300            return false;
301        }
302
303        if (permission == null) {
304            loggerNotebookDao.debug("permission: " + nullArgument);
305            return false;
306        }
307
308
309        Map<String, Object> params = new HashMap<String, Object>();
310        params.put("notebookID", notebookID);
311        params.put("principalID", principalID);
312        params.put("permission", permission.value());
313
314        StringBuilder sql = new StringBuilder("UPDATE ");
315        sql.append(notebookPermissionsTableName).append(" SET ").
316                append(this.permission).append("= :permission ").
317                append(" WHERE ").append(notebook_id).append("= :notebookID AND ").
318                append(principal_id).append("= :principalID");
319        int affectedRows = getSimpleJdbcTemplate().update(sql.toString(), params);
320        if (affectedRows <= 0) {
321            logger.info("For some reason no rows in the table notebooks-permissions were updated. ");
322            return false;
323        } else {
324            if (affectedRows > 1) {
325                logger.info("For some reason more than 1 row in the table notebooks-permissions were updated. that's strange.");
326                return true;
327            } else {
328                return true;
329            }
330        }
331    }
332
333    /**
334     *
335     * ADDERS
336     *
337     *
338     */
339    @Override
340    public Number createNotebookWithoutPermissionsAndAnnotations(Notebook notebook, Number ownerID) {
341        if (notebook == null) {
342            loggerNotebookDao.debug("notebook: " + nullArgument);
343            return null;
344        }
345
346        if (ownerID == null) {
347            loggerNotebookDao.debug("ownerID: " + nullArgument);
348            return null;
349        }
350
351        UUID externalID = UUID.randomUUID();
352        Map<String, Object> params = new HashMap<String, Object>();
353        params.put("externalId", externalID.toString());
354        params.put("owner", ownerID);
355        params.put("title", notebook.getTitle());
356
357        StringBuilder sql = new StringBuilder("INSERT INTO ");
358        sql.append(notebookTableName).append("(").append(external_id).append(",").append(owner_id);
359        sql.append(",").append(title).
360                append(" ) VALUES (:externalId, :owner, :title)");
361        int affectedRows = getSimpleJdbcTemplate().update(sql.toString(), params);
362        return ((affectedRows > 0) ? getInternalID(externalID) : null);
363    }
364
365    @Override
366    public boolean addAnnotationToNotebook(Number notebookID, Number annotationID) {
367
368        if (notebookID == null) {
369            loggerNotebookDao.debug("notebookID: " + nullArgument);
370            return false;
371        }
372
373        if (annotationID == null) {
374            loggerNotebookDao.debug("annotationID: " + nullArgument);
375            return false;
376        }
377
378        Map<String, Object> params = new HashMap<String, Object>();
379        params.put("notebookID", notebookID);
380        params.put("annotationID", annotationID);
381
382        StringBuilder sql = new StringBuilder("INSERT INTO ");
383        sql.append(notebooksAnnotationsTableName).append("(").append(notebook_id).append(",").append(annotation_id);
384        sql.append(" ) VALUES (:notebookID, :annotationID)");
385        int affectedRows = getSimpleJdbcTemplate().update(sql.toString(), params);
386        return (affectedRows > 0);
387    }
388
389    @Override
390    public boolean addPermissionToNotebook(Number notebookID, Number principalID, Permission permission) {
391        if (notebookID == null) {
392            loggerNotebookDao.debug("notebookID: " + nullArgument);
393            return false;
394        }
395
396        if (principalID == null) {
397            loggerNotebookDao.debug("principalID: " + nullArgument);
398            return false;
399        }
400
401        if (permission == null) {
402            loggerNotebookDao.debug("premission: " + nullArgument);
403            return false;
404        }
405
406        Map<String, Object> params = new HashMap<String, Object>();
407        params.put("notebookID", notebookID);
408        params.put("principalID", principalID);
409        params.put("permission", permission.value());
410
411        StringBuilder sql = new StringBuilder("INSERT INTO ");
412        sql.append(notebookPermissionsTableName).append("(").append(notebook_id).append(",").append(principal_id);
413        sql.append(",").append(this.permission).
414                append(" ) VALUES (:notebookID, :principalID, :permission)");
415        int affectedRows = getSimpleJdbcTemplate().update(sql.toString(), params);
416        return (affectedRows > 0);
417    }
418
419    /**
420     *
421     * DELETERS
422     *
423     *
424     */
425    @Override
426    public boolean deleteAnnotationFromNotebook(Number notebookID, Number annotationID) {
427        if (notebookID != null) {
428            if (annotationID != null) {
429                Map<String, Number> params = new HashMap();
430                params.put("notebookID", notebookID);
431                params.put("annotationID", annotationID);
432                StringBuilder sql = new StringBuilder("DELETE FROM ");
433                sql.append(notebooksAnnotationsTableName).append(" WHERE ").append(notebook_id).append(" = :notebookID AND ").
434                        append(annotation_id).append(" = :annotationID");
435                int affectedRows = getSimpleJdbcTemplate().update(sql.toString(), params);
436                return (affectedRows > 0);
437            } else {
438                loggerNotebookDao.debug("annotationID: " + nullArgument);
439                return false;
440            }
441        } else {
442            loggerNotebookDao.debug("notebookID: " + nullArgument);
443            return false;
444        }
445    }
446
447    @Override
448    public boolean deleteNotebookPrincipalPermission(Number notebookID, Number principalID) {
449        if (notebookID != null) {
450            if (principalID != null) {
451                Map<String, Number> params = new HashMap();
452                params.put("notebookID", notebookID);
453                params.put("principalID", principalID);
454                StringBuilder sqlPermissions = new StringBuilder("DELETE FROM ");
455                sqlPermissions.append(notebookPermissionsTableName).append(" WHERE ").append(notebook_id).append(" = :notebookID AND ").
456                        append(principal_id).append(" = :principalID");
457                int affectedRows = getSimpleJdbcTemplate().update(sqlPermissions.toString(), params);
458                return (affectedRows > 0);
459            } else {
460                loggerNotebookDao.debug("principalID: " + nullArgument);
461                return false;
462            }
463        } else {
464            loggerNotebookDao.debug("notebookID: " + nullArgument);
465            return false;
466        }
467    }
468
469    @Override
470    public boolean deleteAllAnnotationsFromNotebook(Number notebookID) {
471        if (notebookID != null) {
472            StringBuilder sql = new StringBuilder("DELETE FROM ");
473            sql.append(notebooksAnnotationsTableName).append(" WHERE ").append(notebook_id).append(" = ? ");
474            int affectedRows = getSimpleJdbcTemplate().update(sql.toString(), notebookID);
475            return (affectedRows > 0);
476        } else {
477            loggerNotebookDao.debug("notebookID: " + nullArgument);
478            return false;
479        }
480    }
481
482    @Override
483    public boolean deleteAllPermissionsForNotebook(Number notebookID) {
484        if (notebookID != null) {
485            StringBuilder sqlPermissions = new StringBuilder("DELETE FROM ");
486            sqlPermissions.append(notebookPermissionsTableName).append(" WHERE ").append(notebook_id).append(" = ? ");
487            int affectedRows = getSimpleJdbcTemplate().update(sqlPermissions.toString(), notebookID);
488            return (affectedRows > 0);
489        } else {
490            loggerNotebookDao.debug("notebookID: " + nullArgument);
491            return false;
492        }
493    }
494
495    @Override
496    public boolean deleteNotebook(Number notebookID) {
497        if (notebookID != null) {
498            StringBuilder sql = new StringBuilder("DELETE FROM ");
499            sql.append(notebookTableName).append(" WHERE ").append(notebook_id).append(" = ? ");
500            int affectedRows = getSimpleJdbcTemplate().update(sql.toString(), notebookID);
501            return (affectedRows > 0);
502        } else {
503            loggerNotebookDao.debug("notebookID: " + nullArgument);
504            return false;
505        }
506    }
507}
Note: See TracBrowser for help on using the repository browser.