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