modules/widget_dao/dao/widget_dao_read_only.cpp

   1 /*
   2  * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   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
   7  *
   8  *        http://www.apache.org/licenses/LICENSE-2.0
   9  *
  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.
  15  */
  16 /**
  17  * This file contains the declaration of widget dao class.
  18  *
  19  * @file    widget_dao_read_only.cpp
  20  * @author  Yang Jie (jie2.yang@samsung.com)
  21  * @author  Przemyslaw Dobrowolski (p.dobrowolsk@samsung.com)
  22  * @author  Pawel Sikorski (p.sikorski@samsung.com)
  23  * @version 1.0
  24  * @brief   This file contains the declaration of widget dao
  25  */
  26 #include <stddef.h>
  27 #include <dpl/wrt-dao-ro/widget_dao_read_only.h>
  28
  29 #include <sstream>
  30 #include <dpl/foreach.h>
  31 #include <dpl/sstream.h>
  32 #include <dpl/wrt-dao-ro/global_config.h>
  33 #include <dpl/wrt-dao-ro/webruntime_database.h>
  34 #include <dpl/wrt-dao-ro/WrtDatabase.h>
  35 #include <dpl/wrt-dao-ro/widget_config.h>
  36 #include <dpl/wrt-dao-ro/feature_dao_read_only.h>
  37 #include <orm_generator_wrt.h>
  38 #include <LanguageTagsProvider.h>
  39
  40 namespace {
  41     unsigned int seed = time(NULL);
  42 }
  43
  44 namespace WrtDB {
  45 //TODO in current solution in each getter there exists a check
  46 //"IsWidgetInstalled". Maybe it should be verified, if it could be done
  47 //differently  (check in WidgetDAOReadOnly constructor)
  48
  49 #define SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN          Try
  50
  51 #define SQL_CONNECTION_EXCEPTION_HANDLER_END(message)                    \
  52     Catch(DPL::DB::SqlConnection::Exception::Base) {                     \
  53         WrtLogE(message);                                                \
  54         ReThrowMsg(WidgetDAOReadOnly::Exception::DatabaseError,          \
  55                    message);                                             \
  56     }
  57
  58 #define CHECK_WIDGET_EXISTENCE(macro_transaction, macro_handle)          \
  59     if (!WidgetDAOReadOnly::isWidgetInstalled(macro_handle))             \
  60     {                                                                    \
  61         macro_transaction.Commit();                                      \
  62         WrtLogW("Cannot find widget. Handle: %i", macro_handle);         \
  63         ThrowMsg(WidgetDAOReadOnly::Exception::WidgetNotExist,           \
  64                  "Cannot find widget. Handle: " << macro_handle);        \
  65     }
  66
  67 typedef DPL::DB::ORM::wrt::WidgetInfo::Row WidgetInfoRow;
  68 typedef DPL::DB::ORM::wrt::WidgetFeature::widget_feature_id::ColumnType
  69 WidgetFeatureId;
  70
  71 namespace {
  72 using namespace DPL::DB::ORM;
  73 using namespace DPL::DB::ORM::wrt;
  74
  75 WidgetInfoRow getWidgetInfoRow(int widgetHandle)
  76 {
  77     WrtLogD("Getting WidgetInfo row. Handle: %i", widgetHandle);
  78     SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
  79     {
  80         WRT_DB_SELECT(select, WidgetInfo, &WrtDatabase::interface())
  81         select->Where(Equals<WidgetInfo::app_id>(widgetHandle));
  82
  83         WidgetInfo::Select::RowList rows = select->GetRowList();
  84         if (rows.empty()) {
  85             ThrowMsg(WidgetDAOReadOnly::Exception::WidgetNotExist,
  86                      "Cannot find widget. Handle: " << widgetHandle);
  87         }
  88         return rows.front();
  89     }
  90     SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed in GetWidgetInfoRow")
  91 }
  92
  93 const int MAX_TIZENID_LENGTH = 10;
  94
  95 TizenAppId getTizenAppIdByHandle(const DbWidgetHandle handle)
  96 {
  97     WrtLogD("Getting TizenAppId by DbWidgetHandle: %i", handle);
  98
  99     SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
 100     {
 101         WRT_DB_SELECT(select, WidgetInfo, &WrtDatabase::interface())
 102         select->Where(Equals<WidgetInfo::app_id>(handle));
 103         WidgetInfo::Select::RowList rowList = select->GetRowList();
 104
 105         if (rowList.empty()) {
 106             ThrowMsg(WidgetDAOReadOnly::Exception::WidgetNotExist,
 107                      "Failed to get widget by handle");
 108         }
 109         TizenAppId tzAppid = rowList.front().Get_tizen_appid();
 110
 111         return tzAppid;
 112     }
 113     SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed in getHandle")
 114 }
 115
 116 TizenAppId getTizenAppIdByPkgId(const TizenPkgId tzPkgid)
 117 {
 118     WrtLogD("Getting TizenAppId by pkgid : %ls", tzPkgid.c_str());
 119     SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
 120     {
 121         WRT_DB_SELECT(select, WidgetInfo, &WrtDatabase::interface())
 122         select->Where(Equals<WidgetInfo::tizen_pkgid>(tzPkgid));
 123         WidgetInfo::Select::RowList rowList = select->GetRowList();
 124
 125         if (rowList.empty()) {
 126             ThrowMsg(WidgetDAOReadOnly::Exception::WidgetNotExist,
 127                      "Failed to get widget by handle");
 128         }
 129         TizenAppId tzAppid = rowList.front().Get_tizen_appid();
 130
 131         return tzAppid;
 132     }
 133     SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed in getHandle")
 134 }
 135
 136 void getTizenAppIdListByPkgId(const TizenPkgId tzPkgid, std::list<TizenAppId>& idList)
 137 {
 138     WrtLogD("Getting TizenAppId by pkgid : %ls", tzPkgid.c_str());
 139     SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
 140     {
 141         WRT_DB_SELECT(select, WidgetInfo, &WrtDatabase::interface())
 142         select->Where(Equals<WidgetInfo::tizen_pkgid>(tzPkgid));
 143         WidgetInfo::Select::RowList rowList = select->GetRowList();
 144
 145         for (WidgetInfo::Select::RowList::iterator i = rowList.begin(); i != rowList.end(); ++i) {
 146             TizenAppId tzAppid = i->Get_tizen_appid();
 147             idList.push_back(tzAppid);
 148         }
 149     }
 150     SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed in getHandle")
 151 }
 152
 153 TizenPkgId getTizenPkgIdByHandle(const DbWidgetHandle handle)
 154 {
 155     WrtLogD("Getting TizenPkgId by DbWidgetHandle: %i", handle);
 156
 157     SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
 158     {
 159         WRT_DB_SELECT(select, WidgetInfo, &WrtDatabase::interface())
 160         select->Where(Equals<WidgetInfo::app_id>(handle));
 161         WidgetInfo::Select::RowList rowList = select->GetRowList();
 162
 163         if (rowList.empty()) {
 164             ThrowMsg(WidgetDAOReadOnly::Exception::WidgetNotExist,
 165                      "Failed to get widget by handle");
 166         }
 167         TizenPkgId tzPkgid = rowList.front().Get_tizen_pkgid();
 168
 169         return tzPkgid;
 170     }
 171     SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed in getHandle")
 172 }
 173
 174 TizenPkgId getTizenPkgIdByAppId(const TizenAppId tzAppid)
 175 {
 176     WrtLogD("Getting TizenPkgId by TizenAppId: %ls", tzAppid.c_str());
 177
 178     SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
 179     {
 180         WRT_DB_SELECT(select, WidgetInfo, &WrtDatabase::interface())
 181         select->Where(Equals<WidgetInfo::tizen_appid>(tzAppid));
 182         WidgetInfo::Select::RowList rowList = select->GetRowList();
 183
 184         if (rowList.empty()) {
 185             ThrowMsg(WidgetDAOReadOnly::Exception::WidgetNotExist,
 186                      "Failed to get widget by tizen appId");
 187         }
 188         TizenPkgId tzPkgid = rowList.front().Get_tizen_pkgid();
 189
 190         return tzPkgid;
 191     }
 192     SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed get pkgId")
 193 }
 194 } // namespace
 195
 196 WidgetDAOReadOnly::WidgetDAOReadOnly(DbWidgetHandle widgetHandle) :
 197     m_widgetHandle(widgetHandle)
 198 {}
 199
 200 WidgetDAOReadOnly::WidgetDAOReadOnly(DPL::OptionalString widgetGUID) :
 201     m_widgetHandle(WidgetDAOReadOnly::getHandle(widgetGUID))
 202 {}
 203
 204 WidgetDAOReadOnly::WidgetDAOReadOnly(TizenAppId tzAppid) :
 205     m_widgetHandle(WidgetDAOReadOnly::getHandle(tzAppid))
 206 {}
 207
 208 WidgetDAOReadOnly::~WidgetDAOReadOnly()
 209 {}
 210
 211 DbWidgetHandle WidgetDAOReadOnly::getHandle() const
 212 {
 213     return m_widgetHandle;
 214 }
 215
 216 DbWidgetHandle WidgetDAOReadOnly::getHandle(const WidgetGUID GUID)
 217 {
 218     WrtLogD("Getting WidgetHandle by GUID [%ls]", GUID.get_value_or(DPL::String()).c_str());
 219
 220     SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
 221     {
 222         WRT_DB_SELECT(select, WidgetInfo, &WrtDatabase::interface())
 223         select->Where(Equals<WidgetInfo::widget_id>(GUID));
 224         WidgetInfo::Select::RowList rowList = select->GetRowList();
 225
 226         if (rowList.empty()) {
 227             ThrowMsg(WidgetDAOReadOnly::Exception::WidgetNotExist,
 228                      "Failed to get widget by guid");
 229         }
 230         return rowList.front().Get_app_id();
 231     }
 232     SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed in getHandle")
 233 }
 234
 235 DbWidgetHandle WidgetDAOReadOnly::getHandle(const DPL::String tzAppId)
 236 {
 237     WrtLogD("Getting WidgetHandle by tizen app id [%ls]", tzAppId.c_str());
 238
 239     SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
 240     {
 241         WRT_DB_SELECT(select, WidgetInfo, &WrtDatabase::interface())
 242         select->Where(Equals<WidgetInfo::tizen_appid>(tzAppId));
 243         WidgetInfo::Select::RowList rowList = select->GetRowList();
 244
 245         if (rowList.empty()) {
 246             ThrowMsg(WidgetDAOReadOnly::Exception::WidgetNotExist,
 247                      "Failed to get widget by package name");
 248         }
 249         return rowList.front().Get_app_id();
 250     }
 251     SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed in getHandle")
 252 }
 253
 254 DbWidgetHandle WidgetDAOReadOnly::getHandleByPkgId(const DPL::String pkgId)
 255 {
 256     WrtLogD("Getting WidgetHandle by tizen package id [%ls]", pkgId.c_str());
 257
 258     SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
 259     {
 260         WRT_DB_SELECT(select, WidgetInfo, &WrtDatabase::interface())
 261         select->Where(Equals<WidgetInfo::tizen_pkgid>(pkgId));
 262         WidgetInfo::Select::RowList rowList = select->GetRowList();
 263
 264         if (rowList.empty()) {
 265             ThrowMsg(WidgetDAOReadOnly::Exception::WidgetNotExist,
 266                      "Failed to get widget by package id");
 267         }
 268         return rowList.front().Get_app_id();
 269     }
 270     SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed in getHandle")
 271 }
 272
 273
 274 TizenAppId WidgetDAOReadOnly::getTzAppId() const
 275 {
 276     return getTizenAppIdByHandle(m_widgetHandle);
 277 }
 278
 279 TizenAppId WidgetDAOReadOnly::getTzAppId(const WidgetGUID GUID)
 280 {
 281     return getTizenAppIdByHandle(getHandle(GUID));
 282 }
 283
 284 TizenAppId WidgetDAOReadOnly::getTzAppId(const DbWidgetHandle handle)
 285 {
 286     return getTizenAppIdByHandle(handle);
 287 }
 288
 289 TizenAppId WidgetDAOReadOnly::getTzAppId(const TizenPkgId tzPkgid)
 290 {
 291     return getTizenAppIdByPkgId(tzPkgid);
 292 }
 293
 294 TizenAppId WidgetDAOReadOnly::getTizenAppId() const
 295 {
 296     return getTizenAppIdByHandle(m_widgetHandle);
 297 }
 298
 299 TizenAppId WidgetDAOReadOnly::getTizenAppId(const WidgetGUID GUID)
 300 {
 301     return getTizenAppIdByHandle(getHandle(GUID));
 302 }
 303
 304 TizenAppId WidgetDAOReadOnly::getTizenAppId(const DbWidgetHandle handle)
 305 {
 306     return getTizenAppIdByHandle(handle);
 307 }
 308
 309 TizenAppId WidgetDAOReadOnly::getTizenAppId(const TizenPkgId tzPkgid)
 310 {
 311     return getTizenAppIdByPkgId(tzPkgid);
 312 }
 313
 314 TizenAppIdList WidgetDAOReadOnly::getTizenAppidList()
 315 {
 316     SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
 317     {
 318         WRT_DB_SELECT(select, WidgetInfo, &WrtDatabase::interface())
 319         return select->GetValueList<WidgetInfo::tizen_appid>();
 320     }
 321     SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to get TizenAppIdList")
 322 }
 323
 324 TizenAppIdList WidgetDAOReadOnly::getTizenAppIdList()
 325 {
 326     SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
 327     {
 328         WRT_DB_SELECT(select, WidgetInfo, &WrtDatabase::interface())
 329         return select->GetValueList<WidgetInfo::tizen_appid>();
 330     }
 331     SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to get TizenAppIdList")
 332 }
 333
 334 std::list<TizenAppId> WidgetDAOReadOnly::getTzAppIdList(const TizenPkgId tzPkgid){
 335     std::list<TizenAppId> result;
 336     getTizenAppIdListByPkgId(tzPkgid, result);
 337     return result;
 338 }
 339
 340 TizenPkgId WidgetDAOReadOnly::getTizenPkgId() const
 341 {
 342     return getTizenPkgIdByHandle(m_widgetHandle);
 343 }
 344
 345 TizenPkgId WidgetDAOReadOnly::getTizenPkgId(const DbWidgetHandle handle)
 346 {
 347     return getTizenPkgIdByHandle(handle);
 348 }
 349
 350 TizenPkgId WidgetDAOReadOnly::getTizenPkgId(const TizenAppId tzAppid)
 351 {
 352     return getTizenPkgIdByAppId(tzAppid);
 353 }
 354
 355 TizenPkgIdList WidgetDAOReadOnly::getTizenPkgIdList()
 356 {
 357     WrtLogD("Getting TizenPkgId List ");
 358     SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
 359     {
 360         WRT_DB_SELECT(select, WidgetInfo, &WrtDatabase::interface())
 361         return select->GetValueList<WidgetInfo::tizen_pkgid>();
 362     }
 363     SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to get Pkgid list")
 364 }
 365
 366 PropertyDAOReadOnly::WidgetPropertyKeyList
 367 WidgetDAOReadOnly::getPropertyKeyList() const
 368 {
 369     return PropertyDAOReadOnly::GetPropertyKeyList(getTizenAppId());
 370 }
 371
 372 PropertyDAOReadOnly::WidgetPreferenceList
 373 WidgetDAOReadOnly::getPropertyList() const
 374 {
 375     return PropertyDAOReadOnly::GetPropertyList(getTizenAppId());
 376 }
 377
 378 PropertyDAOReadOnly::WidgetPropertyValue WidgetDAOReadOnly::getPropertyValue(
 379     const PropertyDAOReadOnly::WidgetPropertyKey &key) const
 380 {
 381     return PropertyDAOReadOnly::GetPropertyValue(getTizenAppId(), key);
 382 }
 383
 384 DPL::OptionalInt WidgetDAOReadOnly::checkPropertyReadFlag(
 385     const PropertyDAOReadOnly::WidgetPropertyKey &key) const
 386 {
 387     return PropertyDAOReadOnly::CheckPropertyReadFlag(getTizenAppId(), key);
 388 }
 389
 390 DPL::String WidgetDAOReadOnly::getPath() const
 391 {
 392     DPL::String path = *getWidgetInstalledPath();
 393     DPL::String srcPath = DPL::FromUTF8String(GlobalConfig::GetWidgetSrcPath());
 394
 395     path += srcPath + L"/";
 396
 397     return path;
 398 }
 399
 400 DPL::String WidgetDAOReadOnly::getFullPath() const
 401 {
 402     return L"file://" + getPath();
 403 }
 404
 405 WidgetLocalizedInfo
 406 WidgetDAOReadOnly::getLocalizedInfo(const DPL::String& languageTag)
 407 const
 408 {
 409     WrtLogD("Getting Localized Info. Handle: %i", m_widgetHandle);
 410     SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
 411     {
 412         ScopedTransaction transaction(&WrtDatabase::interface());
 413         CHECK_WIDGET_EXISTENCE(transaction, m_widgetHandle)
 414
 415         WRT_DB_SELECT(select, LocalizedWidgetInfo, &WrtDatabase::interface())
 416         select->Where(
 417             And(Equals<LocalizedWidgetInfo::app_id>(m_widgetHandle),
 418                 Equals<LocalizedWidgetInfo::widget_locale>(languageTag)));
 419         LocalizedWidgetInfo::Row info = select->GetSingleRow();
 420         WidgetLocalizedInfo result;
 421
 422         result.name = info.Get_widget_name();
 423         result.shortName = info.Get_widget_shortname();
 424         result.description = info.Get_widget_description();
 425         result.license = info.Get_widget_license();
 426         result.licenseHref = info.Get_widget_license_href();
 427
 428         transaction.Commit();
 429         return result;
 430     }
 431     SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to get localized info")
 432 }
 433
 434 DbWidgetFeatureSet WidgetDAOReadOnly::getFeaturesList() const
 435 {
 436     WrtLogD("Getting FeaturesList. Handle: %i", m_widgetHandle);
 437     SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
 438     {
 439         ScopedTransaction transaction(&WrtDatabase::interface());
 440         CHECK_WIDGET_EXISTENCE(transaction, m_widgetHandle)
 441
 442         WRT_DB_SELECT(select, WidgetFeature, &WrtDatabase::interface())
 443         select->Where(Equals<WidgetFeature::app_id>(m_widgetHandle));
 444
 445         DbWidgetFeatureSet resultSet;
 446         typedef std::list<WidgetFeature::Row> RowList;
 447         RowList list = select->GetRowList();
 448
 449         for (RowList::iterator i = list.begin(); i != list.end(); ++i) {
 450             DbWidgetFeature feature;
 451             feature.name = i->Get_name();
 452             feature.rejected = i->Get_rejected();
 453             FeatureDAOReadOnly featureDao(DPL::ToUTF8String(i->Get_name()));
 454             feature.pluginId = featureDao.GetPluginHandle();
 455             resultSet.insert(feature);
 456         }
 457         transaction.Commit();
 458         return resultSet;
 459     }
 460     SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to get features list")
 461 }
 462
 463 bool WidgetDAOReadOnly::hasFeature(const std::string& featureName) const
 464 {
 465     WrtLogD("Checking if widget has feature: %s. Handle: %i",
 466             featureName.c_str(), m_widgetHandle);
 467     SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
 468     {
 469         ScopedTransaction transaction(&WrtDatabase::interface());
 470         CHECK_WIDGET_EXISTENCE(transaction, m_widgetHandle)
 471
 472         WRT_DB_SELECT(select, wrt::WidgetFeature, &WrtDatabase::interface())
 473         select->Where(And(Equals<wrt::WidgetFeature::app_id>(m_widgetHandle),
 474                           Equals<wrt::WidgetFeature::name>(
 475                               DPL::FromUTF8String(featureName))));
 476
 477         wrt::WidgetFeature::Select::RowList rows = select->GetRowList();
 478         transaction.Commit();
 479         return !rows.empty();
 480     }
 481     SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to check for feature")
 482 }
 483
 484 DbWidgetDAOReadOnlyList WidgetDAOReadOnly::getWidgetList()
 485 {
 486     WrtLogD("Getting DbWidget List");
 487     DbWidgetDAOReadOnlyList list;
 488     FOREACH(iterator, getTizenAppIdList()) {
 489         list.push_back(WidgetDAOReadOnlyPtr(new WidgetDAOReadOnly(*iterator)));
 490     }
 491     return list;
 492 }
 493
 494 bool WidgetDAOReadOnly::isWidgetInstalled(DbWidgetHandle handle)
 495 {
 496     WrtLogD("Checking if widget exist. Handle: %i", handle);
 497     SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
 498     {
 499         WRT_DB_SELECT(select, WidgetInfo, &WrtDatabase::interface())
 500         select->Where(Equals<WidgetInfo::app_id>(handle));
 501
 502         WidgetInfo::Select::RowList rows = select->GetRowList();
 503
 504         return !rows.empty();
 505     }
 506     SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to check if widget exist")
 507 }
 508
 509 bool WidgetDAOReadOnly::isWidgetInstalled(const TizenAppId &tzAppId)
 510 {
 511     WrtLogD("Checking if widget exist. tizen app id %ls", tzAppId.c_str());
 512     SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
 513     {
 514         WRT_DB_SELECT(select, WidgetInfo, &WrtDatabase::interface())
 515         select->Where(Equals<WidgetInfo::tizen_appid>(tzAppId));
 516
 517         WidgetInfo::Select::RowList rows = select->GetRowList();
 518
 519         return !rows.empty();
 520     }
 521     SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to check if widget exist")
 522 }
 523
 524 ExternalLocationList WidgetDAOReadOnly::getWidgetExternalLocations() const
 525 {
 526     WrtLogD("Getting WidgetExtranalFiles List");
 527     ExternalLocationList result;
 528     SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
 529     {
 530         WRT_DB_SELECT(select, WidgetExternalLocations, &WrtDatabase::interface());
 531         select->Where(Equals<WidgetExternalLocations::app_id>(m_widgetHandle));
 532         WidgetExternalLocations::Select::RowList rows = select->GetRowList();
 533         FOREACH(it, rows)
 534         {
 535             result.push_back(DPL::ToUTF8String(it->Get_path()));
 536         }
 537     }
 538     SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to get handle list")
 539     return result;
 540 }
 541
 542 CertificateChainList WidgetDAOReadOnly::getWidgetCertificate(
 543     CertificateSource source) const
 544 {
 545     WRT_DB_SELECT(select, WidgetCertificate, &WrtDatabase::interface())
 546     select->Where(
 547         And(
 548             Equals<WidgetCertificate::app_id>(m_widgetHandle),
 549             Equals<WidgetCertificate::cert_source>(source)));
 550
 551     std::list<WidgetCertificate::Row> chainList = select->GetRowList();
 552
 553     CertificateChainList result;
 554
 555     FOREACH(iter, chainList)
 556     result.push_back(DPL::ToUTF8String(iter->Get_encoded_chain()));
 557     return result;
 558 }
 559
 560 DbWidgetSize WidgetDAOReadOnly::getPreferredSize() const
 561 {
 562     WidgetInfoRow row = getWidgetInfoRow(m_widgetHandle);
 563
 564     DbWidgetSize size;
 565     size.width = row.Get_widget_width();
 566     size.height = row.Get_widget_height();
 567
 568     WrtLogD("Return size wxh = %i x %i",
 569              (!!size.width ? *size.width : -1),
 570              (!!size.height ? *size.height : -1));
 571
 572     return size;
 573 }
 574
 575 WidgetType WidgetDAOReadOnly::getWidgetType() const
 576 {
 577     WidgetInfoRow row = getWidgetInfoRow(m_widgetHandle);
 578     DPL::OptionalInt result = row.Get_widget_type();
 579     return WidgetType(static_cast<AppType>(*result));
 580 }
 581
 582 WidgetGUID WidgetDAOReadOnly::getGUID() const
 583 {
 584     WidgetInfoRow row = getWidgetInfoRow(m_widgetHandle);
 585     return row.Get_widget_id();
 586 }
 587
 588 DPL::OptionalString WidgetDAOReadOnly::getDefaultlocale() const
 589 {
 590     WidgetInfoRow row = getWidgetInfoRow(m_widgetHandle);
 591     return row.Get_defaultlocale();
 592 }
 593
 594 DPL::OptionalString WidgetDAOReadOnly::getVersion() const
 595 {
 596     WidgetInfoRow row = getWidgetInfoRow(m_widgetHandle);
 597     return row.Get_widget_version();
 598 }
 599
 600 DPL::OptionalString WidgetDAOReadOnly::getAuthorName() const
 601 {
 602     WidgetInfoRow row = getWidgetInfoRow(m_widgetHandle);
 603     return row.Get_author_name();
 604 }
 605
 606 DPL::OptionalString WidgetDAOReadOnly::getAuthorEmail() const
 607 {
 608     WidgetInfoRow row = getWidgetInfoRow(m_widgetHandle);
 609     return row.Get_author_email();
 610 }
 611
 612 DPL::OptionalString WidgetDAOReadOnly::getAuthorHref() const
 613 {
 614     WidgetInfoRow row = getWidgetInfoRow(m_widgetHandle);
 615     return row.Get_author_href();
 616 }
 617
 618 DPL::OptionalString WidgetDAOReadOnly::getMinimumWacVersion() const
 619 {
 620     WidgetInfoRow row = getWidgetInfoRow(m_widgetHandle);
 621     return row.Get_min_version();
 622 }
 623
 624 bool WidgetDAOReadOnly::getBackSupported() const
 625 {
 626     WidgetInfoRow row = getWidgetInfoRow(m_widgetHandle);
 627     return row.Get_back_supported();
 628 }
 629
 630 DPL::OptionalString WidgetDAOReadOnly::getCspPolicy() const
 631 {
 632     WidgetInfoRow row = getWidgetInfoRow(m_widgetHandle);
 633     return row.Get_csp_policy();
 634 }
 635
 636 DPL::OptionalString WidgetDAOReadOnly::getCspPolicyReportOnly() const
 637 {
 638     WidgetInfoRow row = getWidgetInfoRow(m_widgetHandle);
 639     return row.Get_csp_policy_report_only();
 640 }
 641
 642 time_t WidgetDAOReadOnly::getInstallTime() const
 643 {
 644     SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
 645     {
 646         WRT_DB_SELECT(select, WidgetExtendedInfo, &WrtDatabase::interface())
 647         select->Where(Equals<WidgetExtendedInfo::app_id>(m_widgetHandle));
 648
 649         WidgetExtendedInfo::Select::RowList rows = select->GetRowList();
 650         if (rows.empty()) {
 651             ThrowMsg(WidgetDAOReadOnly::Exception::WidgetNotExist,
 652                      "Cannot find widget. Handle: " << m_widgetHandle);
 653         }
 654
 655         return static_cast<time_t>(*rows.front().Get_install_time());
 656     }
 657     SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to get widdget install time")
 658 }
 659
 660 DPL::OptionalString WidgetDAOReadOnly::getSplashImgSrc() const
 661 {
 662     SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
 663     {
 664         WRT_DB_SELECT(select, WidgetExtendedInfo, &WrtDatabase::interface())
 665         select->Where(Equals<WidgetExtendedInfo::app_id>(m_widgetHandle));
 666
 667         WidgetExtendedInfo::Select::RowList rows = select->GetRowList();
 668         if (rows.empty()) {
 669             ThrowMsg(WidgetDAOReadOnly::Exception::WidgetNotExist,
 670                      "Cannot find widget. Handle: " << m_widgetHandle);
 671         }
 672
 673         DPL::OptionalString value = rows.front().Get_splash_img_src();
 674         if (!value) {
 675             return DPL::OptionalString();
 676         }
 677
 678         return DPL::OptionalString(getPath() + *value);
 679     }
 680     SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to get splash image path")
 681 }
 682
 683 WidgetDAOReadOnly::WidgetLocalizedIconList WidgetDAOReadOnly::
 684     getLocalizedIconList() const
 685 {
 686     //TODO check widget existance??
 687     SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
 688     {
 689         WRT_DB_SELECT(select, WidgetLocalizedIcon, &WrtDatabase::interface())
 690         select->Where(Equals<WidgetLocalizedIcon::app_id>(m_widgetHandle));
 691
 692         std::list<WidgetLocalizedIcon::Row> list =
 693             select->GetRowList();
 694         WidgetLocalizedIconList ret;
 695         FOREACH(it, list)
 696         {
 697             WidgetLocalizedIconRow icon = { it->Get_app_id(),
 698                                             it->Get_icon_id(),
 699                                             it->Get_widget_locale() };
 700             ret.push_back(icon);
 701         }
 702         return ret;
 703     }
 704     SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to get icon data")
 705 }
 706
 707 WidgetDAOReadOnly::WidgetIconList WidgetDAOReadOnly::getIconList() const
 708 {
 709     //TODO check widget existance
 710     SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
 711     {
 712         WRT_DB_SELECT(select, wrt::WidgetIcon, &WrtDatabase::interface())
 713         select->Where(Equals<wrt::WidgetIcon::app_id>(m_widgetHandle));
 714         select->OrderBy(DPL::TypeListDecl<OrderingAscending<wrt::WidgetIcon::
 715                                                                 icon_id> >());
 716
 717         std::list<WidgetIcon::Row> list =
 718             select->GetRowList();
 719         WidgetIconList ret;
 720         FOREACH(it, list)
 721         {
 722             WidgetIconRow icon = { it->Get_icon_id(),
 723                                    it->Get_app_id(),
 724                                    it->Get_icon_src(),
 725                                    it->Get_icon_width(),
 726                                    it->Get_icon_height() };
 727             ret.push_back(icon);
 728         }
 729         return ret;
 730     }
 731     SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to get icon data")
 732 }
 733
 734 WidgetDAOReadOnly::LocalizedStartFileList WidgetDAOReadOnly::
 735     getLocalizedStartFileList() const
 736 {
 737     //TODO check widget existance
 738     SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
 739     {
 740         WRT_DB_SELECT(select, WidgetLocalizedStartFile, &WrtDatabase::interface())
 741         select->Where(Equals<WidgetLocalizedStartFile::app_id>(
 742                           m_widgetHandle));
 743         select->OrderBy("start_file_id ASC");
 744
 745         std::list<WidgetLocalizedStartFile::Row> list =
 746             select->GetRowList();
 747         LocalizedStartFileList ret;
 748         FOREACH(it, list)
 749         {
 750             WidgetLocalizedStartFileRow file = { it->Get_start_file_id(),
 751                                                  it->Get_app_id(),
 752                                                  it->Get_widget_locale(),
 753                                                  it->Get_type(),
 754                                                  it->Get_encoding() };
 755             ret.push_back(file);
 756         }
 757         return ret;
 758     }
 759     SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to get start file list data")
 760 }
 761
 762 WidgetDAOReadOnly::WidgetStartFileList WidgetDAOReadOnly::getStartFileList()
 763 const
 764 {
 765     //TODO check widget existance
 766     SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
 767     {
 768         WRT_DB_SELECT(select, WidgetStartFile, &WrtDatabase::interface())
 769         select->Where(Equals<WidgetStartFile::app_id>(m_widgetHandle));
 770         select->OrderBy("start_file_id ASC");
 771
 772         std::list<WidgetStartFile::Row> list =
 773             select->GetRowList();
 774         WidgetStartFileList ret;
 775         FOREACH(it, list)
 776         {
 777             WidgetStartFileRow file = { it->Get_start_file_id(),
 778                                         it->Get_app_id(),
 779                                         it->Get_src() };
 780             ret.push_back(file);
 781         }
 782         return ret;
 783     }
 784     SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to get start file list data")
 785 }
 786
 787 WindowModeList WidgetDAOReadOnly::getWindowModes() const
 788 {
 789     //TODO check widget existance
 790     SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
 791     {
 792         WRT_DB_SELECT(select, WidgetWindowModes, &WrtDatabase::interface())
 793         select->Where(Equals<WidgetWindowModes::app_id>(m_widgetHandle));
 794
 795         return select->GetValueList<WidgetWindowModes::window_mode>();
 796     }
 797     SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to get window modes")
 798 }
 799
 800 WidgetCertificateDataList WidgetDAOReadOnly::getCertificateDataList() const
 801 {
 802     //TODO check widget existance
 803     SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
 804     {
 805         WRT_DB_SELECT(select,
 806                       WidgetCertificateFingerprint,
 807                       &WrtDatabase::interface())
 808         select->Where(Equals<WidgetCertificateFingerprint::app_id>(
 809                           m_widgetHandle));
 810         select->OrderBy("chainid");
 811         WidgetCertificateFingerprint::Select::RowList rows =
 812             select->GetRowList();
 813
 814         WidgetCertificateDataList outlCertificateData;
 815         FOREACH(it, rows)
 816         {
 817             WidgetCertificateData data;
 818
 819             data.owner =
 820                 static_cast <WidgetCertificateData::Owner>(it->Get_owner());
 821             data.type =
 822                 static_cast <WidgetCertificateData::Type>(it->Get_type());
 823             data.chainId = it->Get_chainid();
 824             DPL::OptionalString md5 = it->Get_md5_fingerprint();
 825             data.strMD5Fingerprint =
 826                 (!md5) ? "" : DPL::ToUTF8String(*md5);
 827             DPL::OptionalString sha1 = it->Get_sha1_fingerprint();
 828             data.strSHA1Fingerprint =
 829                 (!sha1) ? "" : DPL::ToUTF8String(*sha1);
 830             DPL::OptionalString cname = it->Get_common_name();
 831             data.strCommonName =
 832                 (!cname) ? DPL::FromUTF8String("") : *cname;
 833
 834             outlCertificateData.push_back(data);
 835         }
 836         return outlCertificateData;
 837     }
 838     SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to get fingerprint list")
 839 }
 840
 841 FingerPrintList WidgetDAOReadOnly::getKeyFingerprints(
 842     WidgetCertificateData::Owner owner,
 843     WidgetCertificateData::Type type) const
 844 {
 845     //TODO check widget existance
 846     SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
 847     {
 848         WRT_DB_SELECT(select,
 849                       WidgetCertificateFingerprint,
 850                       &WrtDatabase::interface())
 851         select->Where(And(And(
 852                               Equals<WidgetCertificateFingerprint::app_id>(
 853                                   m_widgetHandle),
 854                               Equals<WidgetCertificateFingerprint::owner>(owner)),
 855                           Equals<WidgetCertificateFingerprint::type>(type)));
 856
 857         WidgetCertificateFingerprint::Select::RowList rows =
 858             select->GetRowList();
 859
 860         FingerPrintList keys;
 861         FOREACH(it, rows)
 862         {
 863             DPL::OptionalString sha1 = it->Get_sha1_fingerprint();
 864             if (!!sha1) {
 865                 keys.push_back(DPL::ToUTF8String(*sha1));
 866             }
 867             DPL::OptionalString md5 = it->Get_md5_fingerprint();
 868             if (!!md5) {
 869                 keys.push_back(DPL::ToUTF8String(*md5));
 870             }
 871         }
 872         return keys;
 873     }
 874     SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to get fingerprint list")
 875 }
 876
 877 WidgetCertificateCNList WidgetDAOReadOnly::getKeyCommonNameList(
 878     WidgetCertificateData::Owner owner,
 879     WidgetCertificateData::Type type) const
 880 {
 881     //TODO check widget existance
 882     SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
 883     {
 884         WRT_DB_SELECT(select,
 885                       WidgetCertificateFingerprint,
 886                       &WrtDatabase::interface())
 887         select->Where(And(And(
 888                               Equals<WidgetCertificateFingerprint::app_id>(
 889                                   m_widgetHandle),
 890                               Equals<WidgetCertificateFingerprint::owner>(owner)),
 891                           Equals<WidgetCertificateFingerprint::type>(type)));
 892
 893         WidgetCertificateFingerprint::Select::RowList rows =
 894             select->GetRowList();
 895
 896         WidgetCertificateCNList out;
 897         FOREACH(it, rows)
 898         {
 899             DPL::OptionalString cname = it->Get_common_name();
 900             out.push_back((!cname) ? "" : DPL::ToUTF8String(*cname));
 901         }
 902         return out;
 903     }
 904     SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to get key common name")
 905 }
 906
 907 void WidgetDAOReadOnly::getWidgetAccessInfo(
 908     WidgetAccessInfoList& outAccessInfoList) const
 909 {
 910     //TODO check widget existance
 911     SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
 912     {
 913         WRT_DB_SELECT(select, WidgetWARPInfo, &WrtDatabase::interface())
 914         select->Where(Equals<WidgetWARPInfo::app_id>(m_widgetHandle));
 915
 916         WidgetWARPInfo::Select::RowList rows = select->GetRowList();
 917
 918         FOREACH(it, rows)
 919         {
 920             WidgetAccessInfo info;
 921
 922             info.strIRI = it->Get_iri();
 923             DPL::OptionalInt access = it->Get_subdomain_access();
 924             if (!access || 0 == *access) {
 925                 info.bSubDomains = false;
 926             } else if (1 == *access) {
 927                 info.bSubDomains = true;
 928             }
 929
 930             outAccessInfoList.push_back(info);
 931         }
 932     }
 933     SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to get accessinfo list")
 934 }
 935
 936 void WidgetDAOReadOnly::getWidgetAllowNavigationInfo(
 937     WidgetAllowNavigationInfoList& allowNavigationList) const
 938 {
 939     SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
 940     {
 941         WRT_DB_SELECT(select, WidgetAllowNavigation, &WrtDatabase::interface())
 942         select->Where(Equals<WidgetAllowNavigation::app_id>(m_widgetHandle));
 943         WidgetAllowNavigation::Select::RowList rows = select->GetRowList();
 944
 945         FOREACH(it, rows) {
 946             WidgetAllowNavigationInfo info;
 947             info.scheme = it->Get_scheme();
 948             info.host = it->Get_host();
 949             allowNavigationList.push_back(info);
 950         }
 951     }
 952     SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to get allow-navigation info list")
 953 }
 954
 955 LanguageTags WidgetDAOReadOnly::getLanguageTags() const
 956 {
 957     //TODO check widget existance
 958     SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
 959     {
 960         WRT_DB_SELECT(select, LocalizedWidgetInfo, &WrtDatabase::interface())
 961         select->Where(Equals<LocalizedWidgetInfo::app_id>(m_widgetHandle));
 962         return select->GetValueList<LocalizedWidgetInfo::widget_locale>();
 963     }
 964     SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to get language tags")
 965 }
 966
 967 LanguageTags WidgetDAOReadOnly::getIconLanguageTags() const
 968 {
 969     //TODO check widget existance
 970     WRT_DB_SELECT(select, WidgetLocalizedIcon, &WrtDatabase::interface())
 971     select->Where(Equals<WidgetLocalizedIcon::app_id>(m_widgetHandle));
 972     select->Distinct();
 973     return select->GetValueList<WidgetLocalizedIcon::widget_locale>();
 974 }
 975
 976 void WidgetDAOReadOnly::getWidgetSettings(
 977     WidgetSettings& outWidgetSettings) const
 978 {
 979     //TODO check widget existance
 980     SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
 981     {
 982         WRT_DB_SELECT(select, SettingsList, &WrtDatabase::interface())
 983         select->Where(Equals<SettingsList::appId>(m_widgetHandle));
 984
 985         SettingsList::Select::RowList rows = select->GetRowList();
 986
 987         FOREACH(it, rows)
 988         {
 989             WidgetSetting info;
 990
 991             info.settingName = it->Get_settingName();
 992             info.settingValue = it->Get_settingValue();
 993             outWidgetSettings.push_back(info);
 994         }
 995     }
 996     SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to get settings list")
 997 }
 998
 999 void WidgetDAOReadOnly::getAppControlList(
1000     WidgetAppControlList& outAppControlList) const
1001 {
1002     WrtLogD("Getting getAppControlList. Handle: %i", m_widgetHandle);
1003     SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
1004     {
1005         ScopedTransaction transaction(&WrtDatabase::interface());
1006         CHECK_WIDGET_EXISTENCE(transaction, m_widgetHandle)
1007
1008         WRT_DB_SELECT(select, AppControlInfo, &WrtDatabase::interface())
1009         select->Where(Equals<AppControlInfo::app_id>(m_widgetHandle));
1010
1011         AppControlInfo::Select::RowList rows = select->GetRowList();
1012
1013         if (rows.empty()) {
1014             WrtLogD("AppControl list is empty. Handle: %i", m_widgetHandle);
1015         }
1016
1017         FOREACH(it, rows) {
1018             WidgetAppControl ret;
1019             ret.src = it->Get_src();
1020             ret.operation = it->Get_operation();
1021             ret.uri = it->Get_uri();
1022             ret.mime = it->Get_mime();
1023             ret.reset = it->Get_execute_index();
1024             outAppControlList.push_back(ret);
1025         }
1026
1027         transaction.Commit();
1028     }
1029     SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to get AppControl list")
1030 }
1031
1032 PackagingType WidgetDAOReadOnly::getPackagingType() const
1033 {
1034     WidgetInfoRow row = getWidgetInfoRow(m_widgetHandle);
1035     DPL::OptionalInt result = row.Get_pkg_type();
1036     return PackagingType(static_cast<PkgType>(*result));
1037 }
1038
1039 void WidgetDAOReadOnly::getEncryptedFileList(EncryptedFileList& filesList)
1040 const
1041 {
1042     //TODO check widget existance
1043     WRT_DB_SELECT(select, EncryptedResourceList, &WrtDatabase::interface())
1044     select->Where(Equals<EncryptedResourceList::app_id>(m_widgetHandle));
1045
1046     typedef std::list<EncryptedResourceList::Row> RowList;
1047     RowList list = select->GetRowList();
1048
1049     FOREACH(it, list) {
1050         EncryptedFileInfo info;
1051         info.fileName = it->Get_resource();
1052         info.fileSize = it->Get_size();
1053         filesList.insert(info);
1054     }
1055 }
1056
1057 DPL::OptionalString WidgetDAOReadOnly::getBackgroundPage() const
1058 {
1059     SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
1060     {
1061         WRT_DB_SELECT(select, WidgetExtendedInfo, &WrtDatabase::interface())
1062         select->Where(Equals<WidgetExtendedInfo::app_id>(m_widgetHandle));
1063
1064         WidgetExtendedInfo::Select::RowList rows = select->GetRowList();
1065         if (rows.empty()) {
1066             ThrowMsg(WidgetDAOReadOnly::Exception::WidgetNotExist,
1067                      "Cannot find widget. Handle: " << m_widgetHandle);
1068         }
1069
1070         return rows.front().Get_background_page();
1071     }
1072     SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to get background page")
1073 }
1074
1075 TizenPkgId WidgetDAOReadOnly::generatePkgId()
1076 {
1077     std::string allowed("0123456789"
1078                         "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1079                         "abcdefghijklmnopqrstuvwxyz");
1080     TizenPkgId pkgId;
1081     pkgId.resize(MAX_TIZENID_LENGTH);
1082     do {
1083         for (int i = 0; i < MAX_TIZENID_LENGTH; ++i) {
1084             pkgId[i] = allowed[rand_r(&seed) % allowed.length()];
1085         }
1086     } while (isWidgetInstalled(pkgId));
1087     return pkgId;
1088 }
1089
1090 DPL::OptionalString WidgetDAOReadOnly::getWidgetInstalledPath() const
1091 {
1092     SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
1093     {
1094         using namespace DPL::DB::ORM;
1095         using namespace DPL::DB::ORM::wrt;
1096         WRT_DB_SELECT(select, WidgetExtendedInfo, &WrtDatabase::interface())
1097         select->Where(Equals<WidgetExtendedInfo::app_id>(m_widgetHandle));
1098
1099         WidgetExtendedInfo::Select::RowList rows = select->GetRowList();
1100         if (rows.empty()) {
1101             ThrowMsg(WidgetDAOReadOnly::Exception::WidgetNotExist,
1102                      "Cannot find widget. Handle: " << m_widgetHandle);
1103         }
1104
1105         return rows.front().Get_installed_path();
1106     }
1107     SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to get widdget installed path")
1108 }
1109
1110 PrivilegeList WidgetDAOReadOnly::getWidgetPrivilege() const
1111 {
1112     //TODO check widget existance
1113     SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
1114     {
1115         WRT_DB_SELECT(select, WidgetPrivilege, &WrtDatabase::interface())
1116         select->Where(Equals<WidgetPrivilege::app_id>(m_widgetHandle));
1117
1118         return select->GetValueList<WidgetPrivilege::name>();
1119     }
1120     SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to get PrivilegeList")
1121 }
1122
1123 WidgetSecurityModelVersion WidgetDAOReadOnly::getSecurityModelVersion() const
1124 {
1125     WidgetInfoRow row = getWidgetInfoRow(m_widgetHandle);
1126     DPL::OptionalInt result = row.Get_security_model_version();
1127     return static_cast<WidgetSecurityModelVersion>(*result);
1128 }
1129
1130 #if USE(WEB_PROVIDER)
1131 void WidgetDAOReadOnly::getLiveBoxInfoList(LiveBoxIdList& outLiveBoxIdList) const
1132 {
1133     SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
1134     {
1135         WRT_DB_SELECT(select, LiveBoxInfo, &WrtDatabase::interface())
1136         select->Where(Equals<LiveBoxInfo::app_id>(m_widgetHandle));
1137         LiveBoxInfo::Select::RowList rowList = select->GetRowList();
1138         FOREACH(it, rowList){
1139             WrtLogD("liveBoxID: %ls", (*(it->Get_livebox_id())).c_str() );
1140             outLiveBoxIdList.push_back(it->Get_livebox_id());
1141         }
1142     }
1143     SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to get liveBox info")
1144 }
1145 #endif
1146
1147 #undef SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
1148 #undef SQL_CONNECTION_EXCEPTION_HANDLER_END
1149 #undef CHECK_WIDGET_EXISTENCE
1150 } // namespace WrtDB