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

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

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