a28f51905b66ef62449f27ee8d8ba1d0ec2c82b9
[iotivity.git] / cloud / resourcedirectory / src / main / java / org / iotivity / cloud / rdserver / db / DBManager.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.base.exception.ServerException.InternalServerErrorException;
33 import org.iotivity.cloud.rdserver.Constants;
34
35 /**
36  *
37  * This class provides a set of APIs to access a DataBase.
38  *
39  */
40 public class DBManager {
41
42     private static DBManager                   mDBManager;
43     private MongoDB                            mMongoDB   = null;
44     private HashMap<String, ArrayList<String>> mKeyField  = new HashMap<>();
45
46     private DBManager(String dbHost) {
47         createDatabase(dbHost);
48         createTables();
49         createIndexes();
50     }
51
52     /**
53      * API to return DBManager object
54      * 
55      * @return DBManager DBManager object
56      */
57     public static DBManager getInstance() {
58         if (mDBManager == null)
59             mDBManager = new DBManager("127.0.0.1");
60         return mDBManager;
61     }
62
63     /**
64      * API to create DBManager instance with specific host
65      *
66      * @return created DB manager
67      */
68     public static DBManager createInstance(String dbHost) {
69         if (mDBManager == null)
70             mDBManager = new DBManager(dbHost);
71         return mDBManager;
72     }
73
74     private void createDatabase(String dbHost) {
75         try {
76             mMongoDB = new MongoDB(dbHost, Constants.RD_DB_NAME);
77         } catch (Exception e) {
78             e.printStackTrace();
79             throw new InternalServerErrorException("Database create failed!");
80         }
81     }
82
83     private void createTables() {
84         mMongoDB.createTable(Constants.RD_TABLE);
85         mMongoDB.createTable(Constants.PRESENCE_TABLE);
86     }
87
88     private void createIndexes() {
89
90         ArrayList<String> keys = new ArrayList<>();
91         keys.add(Constants.DEVICE_ID);
92         keys.add(Constants.INS);
93
94         mMongoDB.createIndex(Constants.RD_TABLE, keys);
95         mKeyField.put(Constants.RD_TABLE, keys);
96
97         keys = new ArrayList<>();
98         keys.add(Constants.DEVICE_ID);
99
100         mMongoDB.createIndex(Constants.PRESENCE_TABLE, keys);
101         mKeyField.put(Constants.PRESENCE_TABLE, keys);
102
103     }
104
105     /**
106      * API for inserting a record into DB table. the record will not be inserted
107      * if duplicated one.
108      * 
109      * @param tableName
110      *            table name to be inserted
111      * @param insert
112      *            record to be inserted
113      */
114     public void insertRecord(String tableName, HashMap<String, Object> insert) {
115
116         if (!_insertRecord(tableName, insert))
117             throw new InternalServerErrorException(
118                     "Database record insert failed");
119     }
120
121     /**
122      * API for inserting a record into DB table. the record will be replaced if
123      * duplicated one.
124      * 
125      * @param tableName
126      *            table name to be inserted or replaced
127      * @param replace
128      *            record to be inserted
129      */
130     public void insertAndReplaceRecord(String tableName,
131             HashMap<String, Object> replace) {
132
133         if (!_insertAndReplaceRecord(tableName, replace))
134             throw new InternalServerErrorException(
135                     "Database record insert failed");
136     }
137
138     /**
139      * API for selecting records from DB table.
140      * 
141      * @param tableName
142      *            table name to be selected
143      * @param condition
144      *            condition record to be selected
145      * @return selected records
146      */
147     public ArrayList<HashMap<String, Object>> selectRecord(String tableName,
148             HashMap<String, Object> condition) {
149
150         return _selectRecord(tableName, condition);
151     }
152
153     /**
154      * API for selecting records to primary key from DB table
155      * 
156      * @param tableName
157      *            table name to be selected
158      * 
159      * @param condition
160      *            condition record to be selected
161      * @return selected record
162      */
163
164     public HashMap<String, Object> selectOneRecord(String tableName,
165             HashMap<String, Object> condition) {
166
167         ArrayList<HashMap<String, Object>> records = _selectRecord(tableName,
168                 condition);
169
170         if (records != null && records.size() > 1) {
171             throw new InternalServerErrorException(
172                     "Database record select failed");
173         }
174
175         if (records.isEmpty()) {
176             return new HashMap<String, Object>();
177         } else {
178             return records.get(0);
179         }
180
181     }
182
183     /**
184      * API for deleting records from DB table.
185      * 
186      * @param tableName
187      *            table name to be deleted
188      * @param condition
189      *            condition record to be deleted
190      */
191     public void deleteRecord(String tableName,
192             HashMap<String, Object> condition) {
193
194         if (!_deleteRecord(tableName, condition))
195             throw new InternalServerErrorException(
196                     "Database record delete failed");
197     }
198
199     /**
200      * API for updating a record into DB table.
201      * 
202      * @param tableName
203      *            table name to be updated
204      * @param replace
205      *            record to be updated
206      */
207     public void updateRecord(String tableName,
208             HashMap<String, Object> replace) {
209
210         if (!_updateRecord(tableName, replace))
211             throw new InternalServerErrorException(
212                     "Database record update failed");
213
214     }
215
216     private Boolean _insertRecord(String tableName,
217             HashMap<String, Object> record) {
218
219         Document doc = createDocument(record);
220
221         return mMongoDB.insertRecord(tableName, doc);
222     }
223
224     private Boolean _insertAndReplaceRecord(String tableName,
225             HashMap<String, Object> record) {
226
227         Document doc = createDocument(record);
228         Document filter = getKeyFilter(tableName, record);
229
230         return mMongoDB.insertAndReplaceRecord(tableName, filter, doc);
231     }
232
233     private Boolean _deleteRecord(String tableName,
234             HashMap<String, Object> condition) {
235
236         Document doc = createDocument(condition);
237
238         return mMongoDB.deleteRecord(tableName, doc);
239     }
240
241     private Boolean _updateRecord(String tableName,
242             HashMap<String, Object> record) {
243
244         Document replace = createDocument(record);
245         Document filter = getKeyFilter(tableName, record);
246
247         return mMongoDB.updateRecord(tableName, filter, replace);
248     }
249
250     private ArrayList<HashMap<String, Object>> _selectRecord(String tableName,
251             HashMap<String, Object> record) {
252
253         Document doc = createDocument(record);
254
255         return mMongoDB.selectRecord(tableName, doc);
256     }
257
258     private Document getKeyFilter(String tableName,
259             HashMap<String, Object> record) {
260
261         Document filterDoc = new Document();
262
263         ArrayList<String> keys = mKeyField.get(tableName);
264
265         for (String key : keys) {
266
267             Object value = record.get(key);
268             filterDoc.append(key, value);
269         }
270
271         return filterDoc;
272     }
273
274     private Document createDocument(HashMap<String, Object> record) {
275
276         Document doc = new Document();
277         Set<Entry<String, Object>> resEntrySet = record.entrySet();
278         Iterator<Entry<String, Object>> entryIter = resEntrySet.iterator();
279
280         while (entryIter.hasNext()) {
281             Map.Entry<String, Object> entry = (Map.Entry<String, Object>) entryIter
282                     .next();
283             doc.append(entry.getKey().toString(), entry.getValue());
284         }
285
286         return doc;
287     }
288
289 }