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