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