modules/widget_dao/dao/widget_dao_read_only.cpp

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