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