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