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