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