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