8955edcb47c58175b6e1e9a5b9117bca2587b138
[iotivity.git] / cloud / resourcedirectory / src / main / java / org / iotivity / cloud / rdserver / 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.rdserver.db;
23
24 import java.util.ArrayList;
25 import java.util.HashMap;
26 import java.util.Iterator;
27 import java.util.Map;
28 import java.util.Map.Entry;
29 import java.util.Set;
30
31 import org.bson.Document;
32 import org.iotivity.cloud.util.Log;
33
34 import com.mongodb.MongoClient;
35 import com.mongodb.client.MongoCollection;
36 import com.mongodb.client.MongoCursor;
37 import com.mongodb.client.MongoDatabase;
38 import com.mongodb.client.model.IndexOptions;
39
40 /**
41  *
42  * This class provides a set of APIs to use MongoDB APIs.
43  *
44  */
45 public class MongoDB {
46
47     private MongoClient   mongoClient = null;
48     private MongoDatabase db          = null;
49
50     /**
51      * API creating MongoClient and initializing MongoDatabase
52      *
53      * @param host
54      *            host of MongoDatabase
55      * @param dbname
56      *            database name to create MongoDatabase
57      * @throws Exception
58      */
59     public MongoDB(String host, String dbname) throws Exception {
60
61         mongoClient = new MongoClient(host);
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 update 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             collection.deleteMany(record);
249
250         } catch (Exception e) {
251
252             e.printStackTrace();
253             return false;
254         }
255
256         showRecord(tableName);
257
258         return true;
259     }
260
261     /**
262      * API for selecting records from DB table.
263      * 
264      * @param tableName
265      *            table name for the record to be selected
266      * @param doc
267      *            document filter to be selected
268      * @return record list according to the filter document
269      */
270     public ArrayList<HashMap<String, Object>> selectRecord(String tableName,
271             Document doc) {
272
273         if (tableName == null || doc == null)
274             return new ArrayList<>();
275
276         MongoCollection<Document> collection = db.getCollection(tableName);
277         MongoCursor<Document> cursor = collection.find(doc).iterator();
278
279         ArrayList<HashMap<String, Object>> recordList = new ArrayList<>();
280
281         try {
282
283             while (cursor.hasNext()) {
284                 Document selectedDoc = cursor.next();
285                 recordList.add(convertDocumentToHashMap(selectedDoc));
286             }
287
288         } finally {
289
290             cursor.close();
291         }
292
293         return recordList;
294     }
295
296     private HashMap<String, Object> convertDocumentToHashMap(Document doc) {
297         HashMap<String, Object> resourceMap = new HashMap<>();
298
299         Set<Entry<String, Object>> entrySet = doc.entrySet();
300         Iterator<Entry<String, Object>> entryIter = entrySet.iterator();
301
302         while (entryIter.hasNext()) {
303
304             Map.Entry<String, Object> entry = (Map.Entry<String, Object>) entryIter
305                     .next();
306
307             String entryKey = entry.getKey();
308
309             // remove a mongoDB index
310             if (entry.getValue() != null && !entryKey.equals("_id")) {
311
312                 resourceMap.put(entry.getKey(), entry.getValue());
313             }
314         }
315
316         return resourceMap;
317     }
318
319     private void showRecord(String tableName) {
320
321         MongoCollection<Document> collection = db.getCollection(tableName);
322         MongoCursor<Document> cursor = collection.find().iterator();
323
324         Log.i("<" + tableName + ">");
325
326         HashMap<String, Object> records = null;
327         int index = 0;
328         while (cursor.hasNext()) {
329
330             Document doc = cursor.next();
331             records = convertDocumentToHashMap(doc);
332
333             Log.i("[" + index + "] " + records.toString());
334             index++;
335         }
336
337         cursor.close();
338     }
339 }