2 * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
17 * @file feature_dao_read_only.cpp
18 * @author Krzysztof Jackiewicz (k.jackiewicz@samsung.com)
20 * @brief This file contains the implementation of feature dao read only
23 #include <dpl/wrt-dao-ro/feature_dao_read_only.h>
25 #include <dpl/log/log.h>
26 #include <dpl/foreach.h>
27 #include <dpl/db/orm.h>
28 #include <orm_generator_wrt.h>
29 #include <dpl/wrt-dao-ro/webruntime_database.h>
30 #include <dpl/wrt-dao-ro/plugin_dao_read_only.h>
33 FeatureDAOReadOnly::FeatureDAOReadOnly(FeatureHandle featureHandle) :
34 m_featureHandle(featureHandle)
36 if (!isFeatureInstalled(m_featureHandle)) {
37 std::ostringstream exc;
38 exc << "Feature " << m_featureHandle << " not installed.";
40 ThrowMsg(FeatureDAOReadOnly::Exception::FeatureNotExist, exc.str());
44 FeatureDAOReadOnly::FeatureDAOReadOnly(const std::string &featureName)
46 LogDebug("FeatureDAOReadOnly ( " << featureName << " )");
48 using namespace DPL::DB::ORM;
49 using namespace DPL::DB::ORM::wrt;
50 WRT_DB_SELECT(select, FeaturesList, &WrtDatabase::interface())
51 select->Where(Equals<FeaturesList::FeatureName>(
52 DPL::FromUTF8String(featureName)));
54 m_featureHandle = select->GetSingleValue<FeaturesList::FeatureUUID>();
55 LogDebug(" >> FeatureHandle retrieved: " << m_featureHandle);
57 Catch(DPL::DB::SqlConnection::Exception::Base){
58 ReThrowMsg(FeatureDAOReadOnly::Exception::DatabaseError,
59 "Failure during creating FeatureDAOReadOnly");
63 #define GET_PLUGIN_DATA(func) \
65 DPL::DB::ORM::wrt::ScopedTransaction transaction( \
66 &WrtDatabase::interface()); \
67 LogDebug(#func << ". FeatureHandle: " << m_featureHandle); \
68 std::string ret = PluginDAOReadOnly(GetPluginHandle()).func(); \
69 transaction.Commit(); \
72 Catch(DPL::DB::SqlConnection::Exception::Base) { \
73 std::ostringstream failure("Failure during "); \
75 ReThrowMsg(FeatureDAOReadOnly::Exception::DatabaseError, \
79 std::string FeatureDAOReadOnly::GetLibraryPath() const
81 GET_PLUGIN_DATA(getLibraryPath)
84 std::string FeatureDAOReadOnly::GetLibraryName() const
86 GET_PLUGIN_DATA(getLibraryName)
89 #undef GET_PLUGIN_DATA
91 FeatureHandle FeatureDAOReadOnly::GetFeatureHandle() const
93 return m_featureHandle;
96 std::string FeatureDAOReadOnly::GetName() const
98 LogDebug("Getting Feature Name. Handle: " << m_featureHandle);
100 using namespace DPL::DB::ORM;
101 using namespace DPL::DB::ORM::wrt;
102 WRT_DB_SELECT(select, FeaturesList, &WrtDatabase::interface())
103 select->Where(Equals<FeaturesList::FeatureUUID>(m_featureHandle));
105 std::string ret = DPL::ToUTF8String(
106 select->GetSingleValue< FeaturesList::FeatureName>());
108 LogDebug(" >> Feature name: " << ret);
111 Catch(DPL::DB::SqlConnection::Exception::Base){
112 ReThrowMsg(FeatureDAOReadOnly::Exception::DatabaseError,
113 "Failure during getting GetName");
117 DbPluginHandle FeatureDAOReadOnly::GetPluginHandle() const
119 LogDebug("Getting Plugin handle. FHandle: " << m_featureHandle);
121 using namespace DPL::DB::ORM;
122 using namespace DPL::DB::ORM::wrt;
123 WRT_DB_SELECT(select, FeaturesList, &WrtDatabase::interface())
124 select->Where(Equals<FeaturesList::FeatureUUID>(m_featureHandle));
126 DbPluginHandle pluginHandle =
127 select->GetSingleValue< FeaturesList::PluginPropertiesId>();
129 LogDebug(" >> Plugin Handle: " << pluginHandle);
132 Catch(DPL::DB::SqlConnection::Exception::Base){
133 ReThrowMsg(FeatureDAOReadOnly::Exception::DatabaseError,
134 "Failure during getting Plugin Handle");
138 FeatureHandleList FeatureDAOReadOnly::GetHandleList()
140 LogDebug("Getting FeatureHandle list.");
142 using namespace DPL::DB::ORM;
143 using namespace DPL::DB::ORM::wrt;
144 WRT_DB_SELECT(select, FeaturesList, &WrtDatabase::interface())
146 FeatureHandleList ret =
147 select->GetValueList<FeaturesList::FeatureUUID>();
149 std::ostringstream handles;
151 handles << *it << " ";
152 LogDebug(" >> FeatureHandle list retrieved: (" << handles << ")");
156 Catch(DPL::DB::SqlConnection::Exception::Base){
157 ReThrowMsg(FeatureDAOReadOnly::Exception::DatabaseError,
158 "Failure during getting FeatureHandle list");
162 bool FeatureDAOReadOnly::isFeatureInstalled(const std::string &featureName)
164 LogDebug("Check if Feature is installed. Name: " << featureName);
166 using namespace DPL::DB::ORM;
167 using namespace DPL::DB::ORM::wrt;
168 WRT_DB_SELECT(select, FeaturesList, &WrtDatabase::interface())
169 select->Where(Equals<FeaturesList::FeatureName>(
170 DPL::FromUTF8String(featureName)));
172 FeaturesList::Select::RowList rows = select->GetRowList();
174 bool flag = !rows.empty();
175 LogDebug(" >> Feature " << featureName <<
176 (flag ? " found." : " not found."));
180 Catch(DPL::DB::SqlConnection::Exception::Base) {
181 ReThrowMsg(FeatureDAOReadOnly::Exception::DatabaseError,
182 "Failure during checking if Feature is installed");
186 bool FeatureDAOReadOnly::isFeatureInstalled(FeatureHandle handle)
188 LogDebug("Check if Feature is installed. Handle: " << handle);
191 using namespace DPL::DB::ORM;
192 using namespace DPL::DB::ORM::wrt;
193 WRT_DB_SELECT(select, FeaturesList, &WrtDatabase::interface())
194 select->Where(Equals<FeaturesList::FeatureUUID>(handle));
196 FeaturesList::Select::RowList rows = select->GetRowList();
198 bool flag = !rows.empty();
199 LogDebug(" >> Feature " << handle <<
200 (flag ? " found." : " not found."));
204 Catch(DPL::DB::SqlConnection::Exception::Base){
205 ReThrowMsg(FeatureDAOReadOnly::Exception::DatabaseError,
206 "Failure during checking if Feature is installed");
210 bool FeatureDAOReadOnly::isDeviceCapabilityInstalled(
211 const std::string &deviceCapName)
213 LogDebug("Check if DeviceCap is installed. Name: " << deviceCapName);
215 using namespace DPL::DB::ORM;
216 using namespace DPL::DB::ORM::wrt;
217 WRT_DB_SELECT(select, DeviceCapabilities, &WrtDatabase::interface())
218 select->Where(Equals<DeviceCapabilities::DeviceCapName>(
219 DPL::FromUTF8String(deviceCapName)));
221 DeviceCapabilities::Select::RowList rows = select->GetRowList();
223 bool flag = !rows.empty();
224 LogDebug(" >> Device Cap " << deviceCapName <<
225 (flag ? "found." : "not found."));
229 Catch(DPL::DB::SqlConnection::Exception::Base){
230 ReThrowMsg(FeatureDAOReadOnly::Exception::DatabaseError,
231 "Failure during checking if DeviceCap is installed");
235 FeatureDAOReadOnly::DeviceCapabilitiesList
236 FeatureDAOReadOnly::GetDeviceCapabilities() const
239 LogDebug("Get DeviceCap. FeatureHandle: " << m_featureHandle);
240 DPL::DB::ORM::wrt::ScopedTransaction transaction(
241 &WrtDatabase::interface());
243 using namespace DPL::DB::ORM;
244 using namespace DPL::DB::ORM::wrt;
245 WRT_DB_SELECT(selectDevCP,
246 FeatureDeviceCapProxy,
247 &WrtDatabase::interface())
248 selectDevCP->Where(Equals<FeatureDeviceCapProxy::FeatureUUID>(
251 DeviceCapabilitiesList devCap;
253 std::list<int> deviceIDs =
254 selectDevCP->GetValueList<FeatureDeviceCapProxy::DeviceCapID>();
255 FOREACH(devCId, deviceIDs)
257 WRT_DB_SELECT(selectDevC,
259 &WrtDatabase::interface())
260 selectDevC->Where(Equals<DeviceCapabilities::DeviceCapID>(*devCId));
262 DPL::String devNames =
263 selectDevC->GetSingleValue<DeviceCapabilities::DeviceCapName>();
265 devCap.insert(DPL::ToUTF8String(devNames));
268 transaction.Commit();
271 Catch(DPL::DB::SqlConnection::Exception::Base){
272 ReThrowMsg(FeatureDAOReadOnly::Exception::DatabaseError,
273 "Failure during getting DeviceCapabilities names");
277 FeatureHandleListPtr FeatureDAOReadOnly::GetFeatureHandleListForPlugin(
278 DbPluginHandle pluginHandle)
280 LogDebug("Getting FeatureHandle list for pluginHandle: " << pluginHandle);
282 using namespace DPL::DB::ORM;
283 using namespace DPL::DB::ORM::wrt;
285 WRT_DB_SELECT(select, FeaturesList, &WrtDatabase::interface())
286 select->Where(Equals<FeaturesList::PluginPropertiesId>(pluginHandle));
288 FeatureHandleListPtr handles(new FeatureHandleList);
289 FeatureHandleList ret =
290 select->GetValueList<FeaturesList::FeatureUUID>();
294 LogDebug("feature handle: " << *it);
295 handles->push_back(*it);
300 Catch(DPL::DB::SqlConnection::Exception::Base){
302 FeatureDAOReadOnly::Exception::DatabaseError,
303 "Failure during getting FeatureHandle Set for plugin handle");
307 FeatureDAOReadOnly::NameMap
308 FeatureDAOReadOnly::GetNames()
311 using namespace DPL::DB::ORM;
312 using namespace DPL::DB::ORM::wrt;
313 WRT_DB_SELECT(select, FeaturesList, &WrtDatabase::interface())
317 FeaturesList::Select::RowList rows = select->GetRowList();
320 nameMap.insert(std::pair<FeatureHandle,
321 std::string>(rowIt->Get_FeatureUUID(),
322 DPL::ToUTF8String(rowIt->
323 Get_FeatureName())));
328 Catch(DPL::DB::SqlConnection::Exception::Base){
329 ReThrowMsg(FeatureDAOReadOnly::Exception::DatabaseError,
330 "Failure during getting GetNames");
334 FeatureDAOReadOnly::DeviceCapabilitiesMap
335 FeatureDAOReadOnly::GetDevCapWithFeatureHandle()
338 using namespace DPL::DB::ORM;
339 using namespace DPL::DB::ORM::wrt;
341 DECLARE_COLUMN_TYPE_LIST()
342 SELECTED_COLUMN(FeatureDeviceCapProxy, FeatureUUID)
343 SELECTED_COLUMN(DeviceCapabilities, DeviceCapName)
344 DECLARE_COLUMN_TYPE_LIST_END(DevCapNameList)
346 WRT_DB_SELECT(select, FeatureDeviceCapProxy, &WrtDatabase::interface())
347 select->Join<DevCapNameList>(Equal<FeatureDeviceCapProxy::DeviceCapID,
348 DeviceCapabilities::DeviceCapID>());
350 DeviceCapabilitiesMap devCap;
352 std::list< CustomRow<DevCapNameList> > rowList =
353 select->GetCustomRowList< DevCapNameList, CustomRow<DevCapNameList> >();
354 FOREACH(rowIt, rowList)
356 FeatureHandle featureHandle =
357 (*rowIt).GetColumnData<FeatureDeviceCapProxy::FeatureUUID>();
358 std::string devName =
359 DPL::ToUTF8String((*rowIt).GetColumnData<DeviceCapabilities::
361 devCap.insert(std::pair<FeatureHandle, std::string>(featureHandle,
367 Catch(DPL::DB::SqlConnection::Exception::Base){
368 ReThrowMsg(FeatureDAOReadOnly::Exception::DatabaseError,
369 "Failure during getting DeviceCapabilities names");
373 FeatureDAOReadOnly::FeatureMap
374 FeatureDAOReadOnly::GetFeatures(const std::list<std::string>& featureNames)
377 using namespace DPL::DB::ORM;
378 using namespace DPL::DB::ORM::wrt;
380 std::set<typename FeaturesList::FeatureName::ColumnType> nameList;
381 FOREACH(nm, featureNames) {
382 nameList.insert(DPL::FromUTF8String(*nm));
385 WRT_DB_SELECT(select, FeaturesList, &WrtDatabase::interface())
386 select->Where(In<FeaturesList::FeatureName>(nameList));
388 FeatureMap featureMap;
389 FeatureData featureData;
390 FeaturesList::Select::RowList rows = select->GetRowList();
391 FOREACH(rowIt, rows) {
392 featureData.featureName = DPL::ToUTF8String(
393 rowIt->Get_FeatureName());
394 featureData.pluginHandle = rowIt->Get_PluginPropertiesId();
395 featureMap.insert(std::pair<FeatureHandle, FeatureData>(
396 rowIt->Get_FeatureUUID(), featureData));
401 Catch(DPL::DB::SqlConnection::Exception::Base){
402 ReThrowMsg(FeatureDAOReadOnly::Exception::DatabaseError,
403 "Failure during getting GetFeatures");