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