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