modules_wearable/widget_dao/dao/widget_dao_read_only.cpp

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