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