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