a79d02779b0bc86a2609e4698f66e1c5e211c0e2
[iotivity.git] / cloud / account / src / main / java / org / iotivity / cloud / accountserver / db / MongoDB.java
1 /*
2  * //******************************************************************
3  * //
4  * // Copyright 2016 Samsung Electronics All Rights Reserved.
5  * //
6  * //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
7  * //
8  * // Licensed under the Apache License, Version 2.0 (the "License");
9  * // you may not use this file except in compliance with the License.
10  * // You may obtain a copy of the License at
11  * //
12  * //      http://www.apache.org/licenses/LICENSE-2.0
13  * //
14  * // Unless required by applicable law or agreed to in writing, software
15  * // distributed under the License is distributed on an "AS IS" BASIS,
16  * // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17  * // See the License for the specific language governing permissions and
18  * // limitations under the License.
19  * //
20  * //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
21  */
22 package org.iotivity.cloud.accountserver.db;
23
24 import java.util.List;
25 import java.util.ArrayList;
26 import java.util.HashMap;
27 import java.util.Iterator;
28 import java.util.Map;
29 import java.util.Map.Entry;
30 import java.util.Set;
31
32 import org.bson.Document;
33 import org.iotivity.cloud.util.Log;
34
35 import com.mongodb.MongoClient;
36 import com.mongodb.client.MongoCollection;
37 import com.mongodb.client.MongoCursor;
38 import com.mongodb.client.MongoDatabase;
39 import com.mongodb.client.model.IndexOptions;
40 import com.mongodb.client.result.DeleteResult;
41
42 /**
43  *
44  * This class provides a set of APIs to use MongoDB APIs.
45  *
46  */
47 public class MongoDB {
48
49     private MongoClient   mongoClient = null;
50     private MongoDatabase db          = null;
51
52     /**
53      * API creating MongoClient and initializing MongoDatabase
54      *
55      * @param dbname
56      *            database name to create MongoDatabase
57      * @throws Exception
58      */
59     public MongoDB(String dbname) throws Exception {
60
61         mongoClient = new MongoClient();
62         mongoClient.dropDatabase(dbname);
63         db = mongoClient.getDatabase(dbname);
64     }
65
66     /**
67      * API for creating collection
68      *
69      * @param tableName
70      *            collection name
71      */
72     public void createTable(String tableName) {
73
74         db.createCollection(tableName);
75     }
76
77     /**
78      * API for creating index
79      *
80      * @param tableName
81      *            collection name
82      * @param keys
83      *            key fields of collection
84      */
85     public void createIndex(String tablename, ArrayList<String> keys) {
86
87         Document doc = new Document();
88
89         for (String key : keys) {
90
91             doc.append(key, 1);
92         }
93
94         IndexOptions options = new IndexOptions();
95         options.unique(true);
96
97         db.getCollection(tablename).createIndex(doc, options);
98     }
99
100     /**
101      * API for deleting collection
102      *
103      * @param tableName
104      *            collection name
105      */
106     public void deleteTable(String tableName) {
107
108         db.getCollection(tableName).drop();
109     }
110
111     /**
112      * API for getting database object
113      *
114      */
115     public MongoDatabase getMongoDatabase() {
116
117         return db;
118     }
119
120     /**
121      * API for inserting a record into DB table. the record will not be inserted
122      * if duplicated one.
123      * 
124      * @param tableName
125      *            table name to be inserted
126      * @param doc
127      *            document to be inserted
128      */
129     public Boolean insertRecord(String tableName, Document doc) {
130
131         if (tableName == null || doc == null)
132             return false;
133
134         MongoCollection<Document> collection = db.getCollection(tableName);
135
136         try {
137
138             if (collection.find(doc).first() == null) {
139
140                 collection.insertOne(doc);
141
142             } else {
143
144                 Log.w("DB insert failed due to duplecated one.");
145                 return false;
146             }
147
148         } catch (Exception e) {
149
150             e.printStackTrace();
151             return false;
152         }
153
154         showRecord(tableName);
155
156         return true;
157     }
158
159     /**
160      * API for inserting a record into DB table. the record will be replaced if
161      * duplicated one.
162      * 
163      * @param tableName
164      *            table name to be inserted
165      * @param filter
166      *            document filter
167      * @param doc
168      *            document to be inserted
169      * @return returns true if the record is inserted and replaced successfully,
170      *         or returns false
171      */
172     public Boolean insertAndReplaceRecord(String tableName, Document filter,
173             Document doc) {
174
175         if (tableName == null || filter == null || doc == null)
176             return false;
177
178         MongoCollection<Document> collection = db.getCollection(tableName);
179
180         try {
181
182             if (collection.findOneAndReplace(filter, doc) == null) {
183
184                 collection.insertOne(doc);
185             }
186
187         } catch (Exception e) {
188
189             e.printStackTrace();
190             return false;
191         }
192
193         showRecord(tableName);
194
195         return true;
196     }
197
198     /**
199      * API for updating a record into DB table.
200      * 
201      * @param tableName
202      *            table name to be updated
203      * @param filter
204      *            document filter
205      * @param record
206      *            record to be updated
207      * @return returns true if the record is updated successfully, or returns
208      *         false
209      */
210     public Boolean updateRecord(String tableName, Document filter,
211             Document record) {
212
213         if (tableName == null || filter == null || record == null)
214             return false;
215
216         MongoCollection<Document> collection = db.getCollection(tableName);
217
218         if (collection.findOneAndReplace(filter, record) == null) {
219
220             Log.w("DB updateX509CRL failed due to no matched record!");
221             return false;
222         }
223
224         showRecord(tableName);
225
226         return true;
227     }
228
229     /**
230      * API for deleting records from DB table.
231      * 
232      * @param tableName
233      *            table name for the record to be deleted
234      * @param record
235      *            record filter to be deleted
236      * @return returns true if the record is deleted successfully, or returns
237      *         false
238      */
239     public Boolean deleteRecord(String tableName, Document record) {
240
241         if (tableName == null || record == null)
242             return false;
243
244         MongoCollection<Document> collection = db.getCollection(tableName);
245
246         try {
247
248             DeleteResult result = collection.deleteMany(record);
249
250             if (result.getDeletedCount() == 0) {
251                 Log.w("DB delete failed due to no mached record!");
252                 return false;
253             }
254
255         } catch (Exception e) {
256
257             e.printStackTrace();
258             return false;
259         }
260
261         showRecord(tableName);
262
263         return true;
264     }
265
266     /**
267      * API for selecting records from DB table.
268      * 
269      * @param tableName
270      *            table name for the record to be selected
271      * @param doc
272      *            document filter to be selected
273      * @return record list according to the filter document
274      */
275     public ArrayList<HashMap<String, Object>> selectRecord(String tableName,
276             Document doc) {
277
278         if (tableName == null || doc == null)
279             return null;
280
281         MongoCollection<Document> collection = db.getCollection(tableName);
282         MongoCursor<Document> cursor = collection.find(doc).iterator();
283
284         ArrayList<HashMap<String, Object>> recordList = new ArrayList<HashMap<String, Object>>();
285
286         try {
287
288             while (cursor.hasNext()) {
289                 Document selectedDoc = cursor.next();
290                 recordList.add(convertDocumentToHashMap(selectedDoc));
291             }
292
293         } finally {
294
295             cursor.close();
296         }
297
298         return recordList;
299     }
300
301     private HashMap<String, Object> convertDocumentToHashMap(Document doc) {
302         HashMap<String, Object> resourceMap = new HashMap<String, Object>();
303
304         Set<Entry<String, Object>> entrySet = doc.entrySet();
305         Iterator<Entry<String, Object>> entryIter = entrySet.iterator();
306
307         while (entryIter.hasNext()) {
308
309             Map.Entry<String, Object> entry = (Map.Entry<String, Object>) entryIter.next();
310
311             String entryKey = entry.getKey();
312
313             // remove a mongoDB index
314             if (entry.getValue() != null && !entryKey.equals("_id")) {
315
316                 // if value is Array
317                 if (entry.getValue() instanceof List && !((List) entry.getValue()).isEmpty()
318                         && ((List) entry.getValue()).get(0) instanceof Document)
319
320                 {
321                     List<HashMap<String, Object>> list = new ArrayList<HashMap<String, Object>>();
322
323                     for (Document document : (List<Document>) entry.getValue()) {
324                         list.add(convertDocumentToHashMap(document));
325                     }
326                     resourceMap.put(entry.getKey(), list);
327                 } else {
328                     resourceMap.put(entry.getKey(), entry.getValue());
329                 }
330             }
331         }
332
333         return resourceMap;
334     }
335
336     private void showRecord(String tableName) {
337
338         MongoCollection<Document> collection = db.getCollection(tableName);
339         MongoCursor<Document> cursor = collection.find().iterator();
340
341         Log.i("<" + tableName + ">");
342
343         HashMap<String, Object> records = null;
344         int index = 0;
345         while (cursor.hasNext()) {
346
347             Document doc = cursor.next();
348             records = convertDocumentToHashMap(doc);
349
350             Log.i("[" + index + "] " + records.toString());
351             index++;
352         }
353
354         cursor.close();
355     }
356 }