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 WidgetPkgNameList_TEMPORARY_API WidgetDAOReadOnly::getPkgnameList_TEMPORARY_API()
 417 {
 418     LogDebug("Getting Pkgname List ");
 419     SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
 420     {
 421         WRT_DB_SELECT(select, WidgetInfo, &WrtDatabase::interface())
 422         return select->GetValueList<WidgetInfo::pkgname>();
 423     }
 424     SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to get Pkgname list")
 425 }
 426
 427 DbWidgetDAOReadOnlyList WidgetDAOReadOnly::getWidgetList()
 428 {
 429     LogDebug("Getting DbWidget List");
 430     DbWidgetDAOReadOnlyList list;
 431     FOREACH(iterator, getHandleList()) {
 432         list.push_back(WidgetDAOReadOnlyPtr(new WidgetDAOReadOnly(*iterator)));
 433     }
 434     return list;
 435 }
 436
 437 bool WidgetDAOReadOnly::isWidgetInstalled(DbWidgetHandle handle)
 438 {
 439     LogDebug("Checking if widget exist. Handle: " << handle);
 440     SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
 441     {
 442         WRT_DB_SELECT(select, WidgetInfo, &WrtDatabase::interface())
 443         select->Where(Equals<WidgetInfo::app_id>(handle));
 444
 445         WidgetInfo::Select::RowList rows = select->GetRowList();
 446
 447         return !rows.empty();
 448     }
 449     SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to check if widget exist")
 450 }
 451
 452 bool WidgetDAOReadOnly::isWidgetInstalled(const WidgetPkgName & pkgName)
 453 {
 454     LogDebug("Checking if widget exist. package name " << pkgName);
 455     SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
 456     {
 457         WRT_DB_SELECT(select, WidgetInfo, &WrtDatabase::interface())
 458         select->Where(Equals<WidgetInfo::pkgname>(pkgName));
 459
 460         WidgetInfo::Select::RowList rows = select->GetRowList();
 461
 462         return !rows.empty();
 463     }
 464     SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to check if widget exist")
 465 }
 466
 467 ExternalLocationList WidgetDAOReadOnly::getWidgetExternalLocations() const
 468 {
 469     LogDebug("Getting WidgetExtranalFiles List");
 470     ExternalLocationList result;
 471     SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
 472     {
 473         WRT_DB_SELECT(select, WidgetExternalLocations, &WrtDatabase::interface());
 474         select->Where(Equals<WidgetExternalLocations::app_id>(m_widgetHandle));
 475         WidgetExternalLocations::Select::RowList rows = select->GetRowList();
 476         FOREACH(it, rows)
 477         {
 478             result.push_back(DPL::ToUTF8String(it->Get_path()));
 479         }
 480     }
 481     SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to get handle list")
 482     return result;
 483 }
 484
 485 CertificateChainList WidgetDAOReadOnly::getWidgetCertificate(
 486         CertificateSource source) const
 487 {
 488     WRT_DB_SELECT(select, WidgetCertificate, &WrtDatabase::interface())
 489     select->Where(
 490         And(
 491             Equals<WidgetCertificate::app_id>(m_widgetHandle),
 492             Equals<WidgetCertificate::cert_source>(source)));
 493
 494     std::list<WidgetCertificate::Row> chainList = select->GetRowList();
 495
 496     CertificateChainList result;
 497
 498     FOREACH(iter, chainList)
 499         result.push_back(DPL::ToUTF8String(iter->Get_encoded_chain()));
 500     return result;
 501 }
 502
 503 DbWidgetSize WidgetDAOReadOnly::getPreferredSize() const
 504 {
 505     WidgetInfoRow row = getWidgetInfoRow(m_widgetHandle);
 506
 507     DbWidgetSize size;
 508     size.width = row.Get_widget_width();
 509     size.height = row.Get_widget_height();
 510
 511     LogDebug("Return size wxh = " <<
 512              (!!size.width ? *size.width : -1) << " x " <<
 513              (!!size.height ? *size.height : -1));
 514
 515     return size;
 516 }
 517
 518 WidgetType WidgetDAOReadOnly::getWidgetType() const
 519 {
 520     WidgetInfoRow row = getWidgetInfoRow(m_widgetHandle);
 521     DPL::OptionalInt result = row.Get_widget_type();
 522     return WidgetType(static_cast<AppType>(*result));
 523 }
 524
 525 WidgetGUID WidgetDAOReadOnly::getGUID() const
 526 {
 527     WidgetInfoRow row = getWidgetInfoRow(m_widgetHandle);
 528     return row.Get_widget_id();
 529 }
 530
 531 DPL::OptionalString WidgetDAOReadOnly::getPkgname() const
 532 {
 533     return DPL::OptionalString(getPkgName());
 534 }
 535
 536 DPL::OptionalString WidgetDAOReadOnly::getDefaultlocale() const
 537 {
 538     WidgetInfoRow row = getWidgetInfoRow(m_widgetHandle);
 539     return row.Get_defaultlocale();
 540 }
 541
 542 DPL::Optional<DPL::String> WidgetDAOReadOnly::getVersion() const
 543 {
 544     WidgetInfoRow row = getWidgetInfoRow(m_widgetHandle);
 545     return row.Get_widget_version();
 546 }
 547
 548 DPL::Optional<DPL::String> WidgetDAOReadOnly::getAuthorName() const
 549 {
 550     WidgetInfoRow row = getWidgetInfoRow(m_widgetHandle);
 551     return row.Get_author_name();
 552 }
 553
 554 DPL::Optional<DPL::String> WidgetDAOReadOnly::getAuthorEmail() const
 555 {
 556     WidgetInfoRow row = getWidgetInfoRow(m_widgetHandle);
 557     return row.Get_author_email();
 558 }
 559
 560 DPL::Optional<DPL::String> WidgetDAOReadOnly::getAuthorHref() const
 561 {
 562     WidgetInfoRow row = getWidgetInfoRow(m_widgetHandle);
 563     return row.Get_author_href();
 564 }
 565
 566 DPL::Optional<DPL::String> WidgetDAOReadOnly::getMinimumWacVersion() const
 567 {
 568     WidgetInfoRow row = getWidgetInfoRow(m_widgetHandle);
 569     return row.Get_min_version();
 570 }
 571
 572 std::string WidgetDAOReadOnly::getShareHref() const
 573 {
 574     SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
 575     {
 576         WRT_DB_SELECT(select, WidgetExtendedInfo, &WrtDatabase::interface())
 577         select->Where(Equals<WidgetExtendedInfo::app_id>(m_widgetHandle));
 578         WidgetExtendedInfo::Select::RowList rows = select->GetRowList();
 579
 580         if (rows.empty()) {
 581             ThrowMsg(WidgetDAOReadOnly::Exception::WidgetNotExist,
 582                      "Cannot find widget. Handle: " << m_widgetHandle);
 583         }
 584
 585         DPL::Optional<DPL::String> value = rows.front().Get_share_href();
 586         std::string ret = "";
 587         if (!value.IsNull()) {
 588             ret = DPL::ToUTF8String(*value);
 589         }
 590         return ret;
 591     }
 592     SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to get share HREF")
 593 }
 594
 595 bool WidgetDAOReadOnly::getBackSupported() const
 596 {
 597     WidgetInfoRow row = getWidgetInfoRow(m_widgetHandle);
 598     return row.Get_back_supported();
 599 }
 600
 601 bool WidgetDAOReadOnly::isRecognized() const
 602 {
 603     WidgetInfoRow row = getWidgetInfoRow(m_widgetHandle);
 604     DPL::OptionalInt result = row.Get_recognized();
 605     if (result.IsNull()) {
 606         return false;
 607     }
 608     return static_cast<bool>(*result);
 609 }
 610
 611 bool WidgetDAOReadOnly::isWacSigned() const
 612 {
 613     WidgetInfoRow row = getWidgetInfoRow(m_widgetHandle);
 614     DPL::OptionalInt result = row.Get_wac_signed();
 615     if (result.IsNull()) {
 616         return false;
 617     }
 618     return static_cast<bool>(*result);
 619 }
 620
 621 bool WidgetDAOReadOnly::isDistributorSigned() const
 622 {
 623     WidgetInfoRow row = getWidgetInfoRow(m_widgetHandle);
 624     DPL::OptionalInt result = row.Get_distributor_signed();
 625     if (result.IsNull()) {
 626         return false;
 627     }
 628     return static_cast<bool>(*result);
 629 }
 630
 631 bool WidgetDAOReadOnly::isTrusted() const
 632 {
 633     // SP-2100
 634     // widget with verified distributor signature is trusted
 635     return isDistributorSigned();
 636 }
 637
 638 bool WidgetDAOReadOnly::isTestWidget() const
 639 {
 640     Try {
 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         return static_cast<bool>(rows.front().Get_test_widget());
 651     }
 652     Catch(DPL::DB::SqlConnection::Exception::Base){
 653         ReThrowMsg(WidgetDAOReadOnly::Exception::DatabaseError,
 654                    "Failed to check IsTestWidget");
 655     }
 656 }
 657
 658 bool WidgetDAOReadOnly::getWebkitPluginsRequired() const
 659 {
 660     WidgetInfoRow row = getWidgetInfoRow(m_widgetHandle);
 661     DPL::OptionalInt ret = row.Get_webkit_plugins_required();
 662
 663     if (ret.IsNull() || *ret == 0) { return false; } else { return true; }
 664 }
 665
 666 time_t WidgetDAOReadOnly::getInstallTime() const
 667 {
 668     SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
 669     {
 670         WRT_DB_SELECT(select, WidgetExtendedInfo, &WrtDatabase::interface())
 671         select->Where(Equals<WidgetExtendedInfo::app_id>(m_widgetHandle));
 672
 673         WidgetExtendedInfo::Select::RowList rows = select->GetRowList();
 674         if (rows.empty()) {
 675             ThrowMsg(WidgetDAOReadOnly::Exception::WidgetNotExist,
 676                      "Cannot find widget. Handle: " << m_widgetHandle);
 677         }
 678
 679         return static_cast<time_t>(*rows.front().Get_install_time());
 680     }
 681     SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to get widdget install time")
 682 }
 683
 684 DPL::OptionalString WidgetDAOReadOnly::getSplashImgSrc() const
 685 {
 686     SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
 687     {
 688         WRT_DB_SELECT(select, WidgetExtendedInfo, &WrtDatabase::interface())
 689         select->Where(Equals<WidgetExtendedInfo::app_id>(m_widgetHandle));
 690
 691         WidgetExtendedInfo::Select::RowList rows = select->GetRowList();
 692         if (rows.empty()) {
 693             ThrowMsg(WidgetDAOReadOnly::Exception::WidgetNotExist,
 694                      "Cannot find widget. Handle: " << m_widgetHandle);
 695         }
 696
 697         DPL::OptionalString value = rows.front().Get_splash_img_src();
 698         if (value.IsNull()) {
 699             return DPL::OptionalString::Null;
 700         }
 701
 702         return DPL::OptionalString(getPath() + *value);
 703     }
 704     SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to get splash image path")
 705 }
 706
 707 WidgetDAOReadOnly::WidgetLocalizedIconList WidgetDAOReadOnly::getLocalizedIconList() const
 708 {
 709     //TODO check widget existance??
 710     SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
 711     {
 712         WRT_DB_SELECT(select, WidgetLocalizedIcon, &WrtDatabase::interface())
 713         select->Where(Equals<WidgetLocalizedIcon::app_id>(m_widgetHandle));
 714
 715         std::list<WidgetLocalizedIcon::Row> list =
 716                 select->GetRowList();
 717         WidgetLocalizedIconList ret;
 718         FOREACH(it,list)
 719         {
 720             WidgetLocalizedIconRow icon = {it->Get_app_id(),
 721                                            it->Get_icon_id(),
 722                                            it->Get_widget_locale()};
 723             ret.push_back(icon);
 724         }
 725         return ret;
 726     }
 727     SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to get icon data")
 728 }
 729
 730 WidgetDAOReadOnly::WidgetIconList WidgetDAOReadOnly::getIconList() const
 731 {
 732     //TODO check widget existance
 733     SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
 734     {
 735         WRT_DB_SELECT(select, wrt::WidgetIcon, &WrtDatabase::interface())
 736         select->Where(Equals<wrt::WidgetIcon::app_id>(m_widgetHandle));
 737
 738         std::list<WidgetIcon::Row> list =
 739                 select->GetRowList();
 740         WidgetIconList ret;
 741         FOREACH(it,list)
 742         {
 743             WidgetIconRow icon = {it->Get_icon_id(),
 744                                   it->Get_app_id(),
 745                                   it->Get_icon_src(),
 746                                   it->Get_icon_width(),
 747                                   it->Get_icon_height()};
 748             ret.push_back(icon);
 749         }
 750         return ret;
 751     }
 752     SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to get icon data")
 753 }
 754
 755 WidgetDAOReadOnly::LocalizedStartFileList WidgetDAOReadOnly::getLocalizedStartFileList() const
 756 {
 757     //TODO check widget existance
 758     SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
 759     {
 760         WRT_DB_SELECT(select, WidgetLocalizedStartFile, &WrtDatabase::interface())
 761         select->Where(Equals<WidgetLocalizedStartFile::app_id>(
 762                           m_widgetHandle));
 763         select->OrderBy("start_file_id ASC");
 764
 765         std::list<WidgetLocalizedStartFile::Row> list =
 766                 select->GetRowList();
 767         LocalizedStartFileList ret;
 768         FOREACH(it,list)
 769         {
 770             WidgetLocalizedStartFileRow file = {it->Get_start_file_id(),
 771                                                 it->Get_app_id(),
 772                                                 it->Get_widget_locale(),
 773                                                 it->Get_type(),
 774                                                 it->Get_encoding()};
 775             ret.push_back(file);
 776         }
 777         return ret;
 778     }
 779     SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to get start file list data")
 780 }
 781
 782 WidgetDAOReadOnly::WidgetStartFileList WidgetDAOReadOnly::getStartFileList() const
 783 {
 784     //TODO check widget existance
 785     SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
 786     {
 787         WRT_DB_SELECT(select, WidgetStartFile, &WrtDatabase::interface())
 788         select->Where(Equals<WidgetStartFile::app_id>(m_widgetHandle));
 789         select->OrderBy("start_file_id ASC");
 790
 791         std::list<WidgetStartFile::Row> list =
 792                 select->GetRowList();
 793         WidgetStartFileList ret;
 794         FOREACH(it,list)
 795         {
 796             WidgetStartFileRow file = {it->Get_start_file_id(),
 797                                        it->Get_app_id(),
 798                                        it->Get_src()};
 799             ret.push_back(file);
 800         }
 801         return ret;
 802     }
 803     SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to get start file list data")
 804 }
 805
 806 WindowModeList WidgetDAOReadOnly::getWindowModes() const
 807 {
 808     //TODO check widget existance
 809     SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
 810     {
 811         WRT_DB_SELECT(select, WidgetWindowModes, &WrtDatabase::interface())
 812         select->Where(Equals<WidgetWindowModes::app_id>(m_widgetHandle));
 813
 814         return select->GetValueList<WidgetWindowModes::window_mode>();
 815     }
 816     SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to get window modes")
 817 }
 818
 819 std::string WidgetDAOReadOnly::getBaseFolder() const
 820 {
 821     WidgetInfoRow row = getWidgetInfoRow(m_widgetHandle);
 822     DPL::Optional<DPL::String> ret = row.Get_base_folder();
 823     std::string baseFolder;
 824     if (!ret.IsNull()) {
 825         baseFolder = DPL::ToUTF8String(*ret);
 826     }
 827
 828     if (!baseFolder.empty()) {
 829         baseFolder += "/";
 830     }
 831
 832     return baseFolder;
 833 }
 834
 835 WidgetCertificateDataList WidgetDAOReadOnly::getCertificateDataList() const
 836 {
 837     //TODO check widget existance
 838     SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
 839     {
 840         WRT_DB_SELECT(select, WidgetCertificateFingerprint, &WrtDatabase::interface())
 841         select->Where(Equals<WidgetCertificateFingerprint::app_id>(
 842                           m_widgetHandle));
 843         select->OrderBy("chainid");
 844         WidgetCertificateFingerprint::Select::RowList rows =
 845             select->GetRowList();
 846
 847         WidgetCertificateDataList outlCertificateData;
 848         FOREACH(it, rows)
 849         {
 850             WidgetCertificateData data;
 851
 852             data.owner =
 853                 static_cast <WidgetCertificateData::Owner>(it->Get_owner());
 854             data.type =
 855                 static_cast <WidgetCertificateData::Type>(it->Get_type());
 856             data.chainId = it->Get_chainid();
 857             DPL::Optional<DPL::String> md5 = it->Get_md5_fingerprint();
 858             data.strMD5Fingerprint =
 859                 md5.IsNull() ? "" : DPL::ToUTF8String(*md5);
 860             DPL::Optional<DPL::String> sha1 = it->Get_sha1_fingerprint();
 861             data.strSHA1Fingerprint =
 862                 sha1.IsNull() ? "" : DPL::ToUTF8String(*sha1);
 863             DPL::Optional<DPL::String> cname = it->Get_common_name();
 864             data.strCommonName =
 865                 cname.IsNull() ? DPL::FromUTF8String("") : *cname;
 866
 867             outlCertificateData.push_back(data);
 868         }
 869         return outlCertificateData;
 870     }
 871     SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to get fingerprint list")
 872 }
 873
 874 FingerPrintList WidgetDAOReadOnly::getKeyFingerprints(
 875         WidgetCertificateData::Owner owner,
 876         WidgetCertificateData::Type type) const
 877 {
 878     //TODO check widget existance
 879     SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
 880     {
 881         WRT_DB_SELECT(select, WidgetCertificateFingerprint, &WrtDatabase::interface())
 882         select->Where(And(And(
 883             Equals<WidgetCertificateFingerprint::app_id>(m_widgetHandle),
 884             Equals<WidgetCertificateFingerprint::owner>(owner)),
 885             Equals<WidgetCertificateFingerprint::type>(type)));
 886
 887         WidgetCertificateFingerprint::Select::RowList rows =
 888             select->GetRowList();
 889
 890         FingerPrintList keys;
 891         FOREACH(it, rows)
 892         {
 893             DPL::Optional<DPL::String> sha1 = it->Get_sha1_fingerprint();
 894             if (!sha1.IsNull()) {
 895                 keys.push_back(DPL::ToUTF8String(*sha1));
 896             }
 897             DPL::Optional<DPL::String> md5 = it->Get_md5_fingerprint();
 898             if (!md5.IsNull()) {
 899                 keys.push_back(DPL::ToUTF8String(*md5));
 900             }
 901         }
 902         return keys;
 903     }
 904     SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to get fingerprint list")
 905 }
 906
 907 WidgetCertificateCNList WidgetDAOReadOnly::getKeyCommonNameList(
 908         WidgetCertificateData::Owner owner,
 909         WidgetCertificateData::Type type) const
 910 {
 911     //TODO check widget existance
 912     SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
 913     {
 914         WRT_DB_SELECT(select, WidgetCertificateFingerprint, &WrtDatabase::interface())
 915         select->Where(And(And(
 916             Equals<WidgetCertificateFingerprint::app_id>(m_widgetHandle),
 917             Equals<WidgetCertificateFingerprint::owner>(owner)),
 918             Equals<WidgetCertificateFingerprint::type>(type)));
 919
 920         WidgetCertificateFingerprint::Select::RowList rows =
 921             select->GetRowList();
 922
 923         WidgetCertificateCNList out;
 924         FOREACH(it, rows)
 925         {
 926             DPL::Optional<DPL::String> cname = it->Get_common_name();
 927             out.push_back(cname.IsNull() ? "" : DPL::ToUTF8String(*cname));
 928         }
 929         return out;
 930     }
 931     SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to get key common name")
 932 }
 933
 934 ResourceAttributeList WidgetDAOReadOnly::getResourceAttribute(
 935         const std::string &resourceId) const
 936 {
 937     WRT_DB_SELECT(select, WidgetFeature, &WrtDatabase::interface())
 938     select->Where(And(Equals<WidgetFeature::app_id>(m_widgetHandle),
 939                       Equals<WidgetFeature::name>(
 940                           DPL::FromUTF8String(resourceId))));
 941
 942     std::list<WidgetFeature::Row> list = select->GetRowList();
 943     ResourceAttributeList result;
 944     if (!list.empty()) {
 945         int widgetFeatureId = list.begin()->Get_widget_feature_id();
 946         WidgetParamMap map = getFeatureParams(widgetFeatureId);
 947
 948         FOREACH(i, map)
 949             result.push_back(DPL::ToUTF8String(i->first));
 950     }
 951     return result;
 952 }
 953
 954 void WidgetDAOReadOnly::getWidgetAccessInfo(
 955         WidgetAccessInfoList& outAccessInfoList) const
 956 {
 957     //TODO check widget existance
 958     SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
 959     {
 960         WRT_DB_SELECT(select, WidgetWARPInfo, &WrtDatabase::interface())
 961         select->Where(Equals<WidgetWARPInfo::app_id>(m_widgetHandle));
 962
 963         WidgetWARPInfo::Select::RowList rows = select->GetRowList();
 964
 965         FOREACH(it, rows)
 966         {
 967             WidgetAccessInfo info;
 968
 969             info.strIRI = it->Get_iri();
 970             DPL::OptionalInt access = it->Get_subdomain_access();
 971             if (access.IsNull() || 0 == *access) {
 972                 info.bSubDomains = false;
 973             } else if (1 == *access) {
 974                 info.bSubDomains = true;
 975             }
 976
 977             outAccessInfoList.push_back(info);
 978         }
 979     }
 980     SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to get accessinfo list")
 981 }
 982
 983 LanguageTags WidgetDAOReadOnly::getLanguageTags() const
 984 {
 985     //TODO check widget existance
 986     SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
 987     {
 988         WRT_DB_SELECT(select, LocalizedWidgetInfo, &WrtDatabase::interface())
 989         select->Where(Equals<LocalizedWidgetInfo::app_id>(m_widgetHandle));
 990         return select->GetValueList<LocalizedWidgetInfo::widget_locale>();
 991     }
 992     SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to get language tags")
 993 }
 994
 995 LanguageTags WidgetDAOReadOnly::getIconLanguageTags() const
 996 {
 997     //TODO check widget existance
 998     WRT_DB_SELECT(select, WidgetLocalizedIcon, &WrtDatabase::interface())
 999     select->Where(Equals<WidgetLocalizedIcon::app_id>(m_widgetHandle));
1000     select->Distinct();
1001     return select->GetValueList<WidgetLocalizedIcon::widget_locale>();
1002 }
1003
1004 std::string WidgetDAOReadOnly::getCookieDatabasePath() const
1005 {
1006     using namespace WrtDB::WidgetConfig;
1007     std::ostringstream path;
1008
1009     WidgetPkgName pkgname = getPkgName();
1010
1011     path << GetWidgetPersistentStoragePath(pkgname);
1012     path << "/";
1013     path << GlobalConfig::GetCookieDatabaseFile();
1014
1015     return path.str();
1016 }
1017
1018 std::string WidgetDAOReadOnly::getPrivateLocalStoragePath() const
1019 {
1020     std::ostringstream path;
1021     WidgetPkgName pkgname = getPkgName();
1022     path << WidgetConfig::GetWidgetWebLocalStoragePath(pkgname);
1023     path << "/";
1024
1025     return path.str();
1026 }
1027
1028 void WidgetDAOReadOnly::getWidgetSettings(
1029         WidgetSettings& outWidgetSettings) const
1030 {
1031     //TODO check widget existance
1032     SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
1033     {
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         ScopedTransaction transaction(&WrtDatabase::interface());
1058         CHECK_WIDGET_EXISTENCE(transaction, m_widgetHandle)
1059
1060         WRT_DB_SELECT(select, ApplicationServiceInfo, &WrtDatabase::interface())
1061         select->Where(Equals<ApplicationServiceInfo::app_id>(m_widgetHandle));
1062
1063         ApplicationServiceInfo::Select::RowList rows = select->GetRowList();
1064
1065         if (rows.empty()) {
1066             LogDebug("Application Service list is empty. Handle: " <<
1067                      m_widgetHandle);
1068         }
1069
1070         FOREACH(it, rows) {
1071             WidgetApplicationService ret;
1072             ret.src = it->Get_src();
1073             ret.operation = it->Get_operation();
1074             ret.scheme = it->Get_scheme();
1075             ret.mime = it->Get_mime();
1076             outAppServiceList.push_back(ret);
1077         }
1078
1079         transaction.Commit();
1080     }
1081     SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to get access host list")
1082 }
1083
1084 PackagingType WidgetDAOReadOnly::getPackagingType() const
1085 {
1086     WidgetInfoRow row = getWidgetInfoRow(m_widgetHandle);
1087     DPL::OptionalInt result = row.Get_pkg_type();
1088     return PackagingType(static_cast<PkgType>(*result));
1089 }
1090
1091 void WidgetDAOReadOnly::getEncryptedFileList(EncryptedFileList& filesList) const
1092 {
1093     //TODO check widget existance
1094     WRT_DB_SELECT(select, EncryptedResourceList, &WrtDatabase::interface())
1095     select->Where(Equals<EncryptedResourceList::app_id>(m_widgetHandle));
1096
1097     typedef std::list<EncryptedResourceList::Row> RowList;
1098     RowList list = select->GetRowList();
1099
1100     FOREACH(it, list) {
1101         EncryptedFileInfo info;
1102         info.fileName = it->Get_resource();
1103         info.fileSize = it->Get_size();
1104         filesList.insert(info);
1105     }
1106 }
1107
1108 DPL::OptionalString WidgetDAOReadOnly::getBackgroundPage() const
1109 {
1110     SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
1111     {
1112         WRT_DB_SELECT(select, WidgetExtendedInfo, &WrtDatabase::interface())
1113         select->Where(Equals<WidgetExtendedInfo::app_id>(m_widgetHandle));
1114
1115         WidgetExtendedInfo::Select::RowList rows = select->GetRowList();
1116         if (rows.empty()) {
1117             ThrowMsg(WidgetDAOReadOnly::Exception::WidgetNotExist,
1118                      "Cannot find widget. Handle: " << m_widgetHandle);
1119         }
1120
1121         return rows.front().Get_background_page();
1122     }
1123     SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to get background page")
1124 }
1125
1126 WidgetPkgName WidgetDAOReadOnly::generateTizenId() {
1127     std::string allowed("0123456789"
1128         "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1129         "abcdefghijklmnopqrstuvwxyz");
1130     WidgetPkgName tizenId;
1131     tizenId.resize(MAX_TIZENID_LENGTH);
1132     do {
1133     for (int i = 0; i < MAX_TIZENID_LENGTH; ++i) {
1134         tizenId[i] = allowed[rand() % allowed.length()];
1135     }
1136     } while (isWidgetInstalled(tizenId));
1137     return tizenId;
1138 }
1139
1140 SettingsType WidgetDAOReadOnly::getSecurityPopupUsage(void) const
1141 {
1142     WidgetSecuritySettingsRow row =
1143         getWidgetSecuritySettingsRow(m_widgetHandle);
1144     DPL::OptionalInt result = row.Get_security_popup_usage();
1145     return static_cast<SettingsType>(*result);
1146 }
1147
1148 SettingsType WidgetDAOReadOnly::getGeolocationUsage(void) const
1149 {
1150     WidgetSecuritySettingsRow row =
1151         getWidgetSecuritySettingsRow(m_widgetHandle);
1152     DPL::OptionalInt result = row.Get_geolocation_usage();
1153     return static_cast<SettingsType>(*result);
1154 }
1155
1156 SettingsType WidgetDAOReadOnly::getWebNotificationUsage(void) const
1157 {
1158     WidgetSecuritySettingsRow row =
1159         getWidgetSecuritySettingsRow(m_widgetHandle);
1160     DPL::OptionalInt result = row.Get_web_notification_usage();
1161     return static_cast<SettingsType>(*result);
1162 }
1163
1164 SettingsType WidgetDAOReadOnly::getWebDatabaseUsage(void) const
1165 {
1166     WidgetSecuritySettingsRow row =
1167         getWidgetSecuritySettingsRow(m_widgetHandle);
1168     DPL::OptionalInt result = row.Get_web_database_usage();
1169     return static_cast<SettingsType>(*result);
1170 }
1171
1172 SettingsType WidgetDAOReadOnly::getFileSystemUsage(void) const
1173 {
1174     WidgetSecuritySettingsRow row =
1175         getWidgetSecuritySettingsRow(m_widgetHandle);
1176     DPL::OptionalInt result = row.Get_file_system_usage();
1177     return static_cast<SettingsType>(*result);
1178 }
1179
1180 DPL::OptionalString WidgetDAOReadOnly::getWidgetInstalledPath() const
1181 {
1182     SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
1183     {
1184         using namespace DPL::DB::ORM;
1185         using namespace DPL::DB::ORM::wrt;
1186         WRT_DB_SELECT(select, WidgetExtendedInfo, &WrtDatabase::interface())
1187         select->Where(Equals<WidgetExtendedInfo::app_id>(m_widgetHandle));
1188
1189         WidgetExtendedInfo::Select::RowList rows = select->GetRowList();
1190         if (rows.empty()) {
1191             ThrowMsg(WidgetDAOReadOnly::Exception::WidgetNotExist,
1192                      "Cannot find widget. Handle: " << m_widgetHandle);
1193         }
1194
1195         return rows.front().Get_installed_path();
1196     }
1197     SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to get widdget installed path")
1198 }
1199 #undef SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
1200 #undef SQL_CONNECTION_EXCEPTION_HANDLER_END
1201 #undef CHECK_WIDGET_EXISTENCE
1202
1203 } // namespace WrtDB