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 WidgetDAOReadOnly::WidgetLocalizedIconList WidgetDAOReadOnly::getLocalizedIconList() const
 639 {
 640     //TODO check widget existance??
 641     SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
 642     {
 643         using namespace DPL::DB::ORM;
 644         using namespace DPL::DB::ORM::wrt;
 645         WRT_DB_SELECT(select, WidgetLocalizedIcon, &WrtDatabase::interface())
 646         select->Where(Equals<WidgetLocalizedIcon::app_id>(m_widgetHandle));
 647
 648         std::list<DPL::DB::ORM::wrt::WidgetLocalizedIcon::Row> list =
 649                 select->GetRowList();
 650         WidgetLocalizedIconList ret;
 651         FOREACH(it,list)
 652         {
 653             WidgetLocalizedIconRow icon = {it->Get_app_id(),
 654                                            it->Get_icon_id(),
 655                                            it->Get_widget_locale()};
 656             ret.push_back(icon);
 657         }
 658         return ret;
 659     }
 660     SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to get icon data")
 661 }
 662
 663 WidgetDAOReadOnly::WidgetIconList WidgetDAOReadOnly::getIconList() 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, wrt::WidgetIcon, &WrtDatabase::interface())
 671         select->Where(Equals<wrt::WidgetIcon::app_id>(m_widgetHandle));
 672
 673         std::list<DPL::DB::ORM::wrt::WidgetIcon::Row> list =
 674                 select->GetRowList();
 675         WidgetIconList ret;
 676         FOREACH(it,list)
 677         {
 678             WidgetIconRow icon = {it->Get_icon_id(),
 679                                   it->Get_app_id(),
 680                                   it->Get_icon_src(),
 681                                   it->Get_icon_width(),
 682                                   it->Get_icon_height()};
 683             ret.push_back(icon);
 684         }
 685         return ret;
 686     }
 687     SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to get icon data")
 688 }
 689
 690 WidgetDAOReadOnly::LocalizedStartFileList WidgetDAOReadOnly::getLocalizedStartFileList() const
 691 {
 692     //TODO check widget existance
 693     SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
 694     {
 695         using namespace DPL::DB::ORM;
 696         using namespace DPL::DB::ORM::wrt;
 697         WRT_DB_SELECT(select, WidgetLocalizedStartFile, &WrtDatabase::interface())
 698         select->Where(Equals<WidgetLocalizedStartFile::app_id>(
 699                           m_widgetHandle));
 700         select->OrderBy("start_file_id ASC");
 701
 702         std::list<DPL::DB::ORM::wrt::WidgetLocalizedStartFile::Row> list =
 703                 select->GetRowList();
 704         LocalizedStartFileList ret;
 705         FOREACH(it,list)
 706         {
 707             WidgetLocalizedStartFileRow file = {it->Get_start_file_id(),
 708                                                 it->Get_app_id(),
 709                                                 it->Get_widget_locale(),
 710                                                 it->Get_type(),
 711                                                 it->Get_encoding()};
 712             ret.push_back(file);
 713         }
 714         return ret;
 715     }
 716     SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to get start file list data")
 717 }
 718
 719 WidgetDAOReadOnly::WidgetStartFileList WidgetDAOReadOnly::getStartFileList() const
 720 {
 721     //TODO check widget existance
 722     SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
 723     {
 724         using namespace DPL::DB::ORM;
 725         using namespace DPL::DB::ORM::wrt;
 726         WRT_DB_SELECT(select, WidgetStartFile, &WrtDatabase::interface())
 727         select->Where(Equals<WidgetStartFile::app_id>(m_widgetHandle));
 728         select->OrderBy("start_file_id ASC");
 729
 730         std::list<DPL::DB::ORM::wrt::WidgetStartFile::Row> list =
 731                 select->GetRowList();
 732         WidgetStartFileList ret;
 733         FOREACH(it,list)
 734         {
 735             WidgetStartFileRow file = {it->Get_start_file_id(),
 736                                        it->Get_app_id(),
 737                                        it->Get_src()};
 738             ret.push_back(file);
 739         }
 740         return ret;
 741     }
 742     SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to get start file list data")
 743 }
 744
 745 WindowModeList WidgetDAOReadOnly::getWindowModes() const
 746 {
 747     //TODO check widget existance
 748     SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
 749     {
 750         using namespace DPL::DB::ORM;
 751         using namespace DPL::DB::ORM::wrt;
 752         WRT_DB_SELECT(select, WidgetWindowModes, &WrtDatabase::interface())
 753         select->Where(Equals<WidgetWindowModes::app_id>(m_widgetHandle));
 754
 755         return select->GetValueList<WidgetWindowModes::window_mode>();
 756     }
 757     SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to get window modes")
 758 }
 759
 760 std::string WidgetDAOReadOnly::getBaseFolder() const
 761 {
 762     WidgetInfoRow row = getWidgetInfoRow(m_widgetHandle);
 763     DPL::Optional<DPL::String> ret = row.Get_base_folder();
 764     std::string baseFolder;
 765     if (!ret.IsNull()) {
 766         baseFolder = DPL::ToUTF8String(*ret);
 767     }
 768
 769     if (!baseFolder.empty()) {
 770         baseFolder += "/";
 771     }
 772
 773     return baseFolder;
 774 }
 775
 776 bool WidgetDAOReadOnly::isDeletable() const
 777 {
 778     return !WidgetDAOReadOnly::isFactory();
 779 }
 780
 781 WidgetCertificateDataList WidgetDAOReadOnly::getCertificateDataList() const
 782 {
 783     //TODO check widget existance
 784     SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
 785     {
 786         using namespace DPL::DB::ORM;
 787         using namespace DPL::DB::ORM::wrt;
 788         WRT_DB_SELECT(select, WidgetCertificateFingerprint, &WrtDatabase::interface())
 789         select->Where(Equals<WidgetCertificateFingerprint::app_id>(
 790                           m_widgetHandle));
 791         select->OrderBy("chainid");
 792         WidgetCertificateFingerprint::Select::RowList rows =
 793             select->GetRowList();
 794
 795         WidgetCertificateDataList outlCertificateData;
 796         FOREACH(it, rows)
 797         {
 798             WidgetCertificateData data;
 799
 800             data.owner =
 801                 static_cast <WidgetCertificateData::Owner>(it->Get_owner());
 802             data.type =
 803                 static_cast <WidgetCertificateData::Type>(it->Get_type());
 804             data.chainId = it->Get_chainid();
 805             DPL::Optional<DPL::String> md5 = it->Get_md5_fingerprint();
 806             data.strMD5Fingerprint =
 807                 md5.IsNull() ? "" : DPL::ToUTF8String(*md5);
 808             DPL::Optional<DPL::String> sha1 = it->Get_sha1_fingerprint();
 809             data.strSHA1Fingerprint =
 810                 sha1.IsNull() ? "" : DPL::ToUTF8String(*sha1);
 811             DPL::Optional<DPL::String> cname = it->Get_common_name();
 812             data.strCommonName =
 813                 cname.IsNull() ? DPL::FromUTF8String("") : *cname;
 814
 815             outlCertificateData.push_back(data);
 816         }
 817         return outlCertificateData;
 818     }
 819     SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to get fingerprint list")
 820 }
 821
 822 FingerPrintList WidgetDAOReadOnly::getKeyFingerprints(
 823         WidgetCertificateData::Owner owner,
 824         WidgetCertificateData::Type type) const
 825 {
 826     //TODO check widget existance
 827     SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
 828     {
 829         using namespace DPL::DB::ORM;
 830         using namespace DPL::DB::ORM::wrt;
 831         WRT_DB_SELECT(select, WidgetCertificateFingerprint, &WrtDatabase::interface())
 832         select->Where(And(And(
 833             Equals<WidgetCertificateFingerprint::app_id>(m_widgetHandle),
 834             Equals<WidgetCertificateFingerprint::owner>(owner)),
 835             Equals<WidgetCertificateFingerprint::type>(type)));
 836
 837         WidgetCertificateFingerprint::Select::RowList rows =
 838             select->GetRowList();
 839
 840         FingerPrintList keys;
 841         FOREACH(it, rows)
 842         {
 843             DPL::Optional<DPL::String> md5 = it->Get_md5_fingerprint();
 844             keys.push_back(md5.IsNull() ? "" : DPL::ToUTF8String(*md5));
 845             DPL::Optional<DPL::String> sha1 = it->Get_sha1_fingerprint();
 846             keys.push_back(sha1.IsNull() ? "" : DPL::ToUTF8String(*sha1));
 847         }
 848         return keys;
 849     }
 850     SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to get fingerprint list")
 851 }
 852
 853 WidgetCertificateCNList WidgetDAOReadOnly::getKeyCommonNameList(
 854         WidgetCertificateData::Owner owner,
 855         WidgetCertificateData::Type type) const
 856 {
 857     //TODO check widget existance
 858     SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
 859     {
 860         using namespace DPL::DB::ORM;
 861         using namespace DPL::DB::ORM::wrt;
 862         WRT_DB_SELECT(select, WidgetCertificateFingerprint, &WrtDatabase::interface())
 863         select->Where(And(And(
 864             Equals<WidgetCertificateFingerprint::app_id>(m_widgetHandle),
 865             Equals<WidgetCertificateFingerprint::owner>(owner)),
 866             Equals<WidgetCertificateFingerprint::type>(type)));
 867
 868         WidgetCertificateFingerprint::Select::RowList rows =
 869             select->GetRowList();
 870
 871         WidgetCertificateCNList out;
 872         FOREACH(it, rows)
 873         {
 874             DPL::Optional<DPL::String> cname = it->Get_common_name();
 875             out.push_back(cname.IsNull() ? "" : DPL::ToUTF8String(*cname));
 876         }
 877         return out;
 878     }
 879     SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to get key common name")
 880 }
 881
 882 ResourceAttributeList WidgetDAOReadOnly::getResourceAttribute(
 883         const std::string &resourceId) const
 884 {
 885     using namespace DPL::DB::ORM;
 886     using namespace DPL::DB::ORM::wrt;
 887     WRT_DB_SELECT(select, DPL::DB::ORM::wrt::WidgetFeature, &WrtDatabase::interface())
 888     select->Where(And(Equals<DPL::DB::ORM::wrt::WidgetFeature::app_id>(m_widgetHandle),
 889                       Equals<DPL::DB::ORM::wrt::WidgetFeature::name>(
 890                           DPL::FromUTF8String(resourceId))));
 891
 892     std::list<DPL::DB::ORM::wrt::WidgetFeature::Row> list = select->GetRowList();
 893     ResourceAttributeList result;
 894     if (!list.empty()) {
 895         int widgetFeatureId = list.begin()->Get_widget_feature_id();
 896         WidgetParamMap map = getFeatureParams(widgetFeatureId);
 897
 898         FOREACH(i, map)
 899             result.push_back(DPL::ToUTF8String(i->first));
 900     }
 901     return result;
 902 }
 903
 904 void WidgetDAOReadOnly::getWidgetAccessInfo(
 905         WidgetAccessInfoList& outAccessInfoList) const
 906 {
 907     //TODO check widget existance
 908     SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
 909     {
 910         using namespace DPL::DB::ORM;
 911         using namespace DPL::DB::ORM::wrt;
 912         WRT_DB_SELECT(select, WidgetWARPInfo, &WrtDatabase::interface())
 913         select->Where(Equals<WidgetWARPInfo::app_id>(m_widgetHandle));
 914
 915         WidgetWARPInfo::Select::RowList rows = select->GetRowList();
 916
 917         FOREACH(it, rows)
 918         {
 919             WidgetAccessInfo info;
 920
 921             info.strIRI = it->Get_iri();
 922             DPL::OptionalInt access = it->Get_subdomain_access();
 923             if (access.IsNull() || 0 == *access) {
 924                 info.bSubDomains = false;
 925             } else if (1 == *access) {
 926                 info.bSubDomains = true;
 927             }
 928
 929             outAccessInfoList.push_back(info);
 930         }
 931     }
 932     SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to get accessinfo list")
 933 }
 934
 935 LanguageTagList WidgetDAOReadOnly::getLanguageTags() const
 936 {
 937     //TODO check widget existance
 938     SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
 939     {
 940         using namespace DPL::DB::ORM;
 941         using namespace DPL::DB::ORM::wrt;
 942         WRT_DB_SELECT(select, LocalizedWidgetInfo, &WrtDatabase::interface())
 943         select->Where(Equals<LocalizedWidgetInfo::app_id>(m_widgetHandle));
 944         return select->GetValueList<LocalizedWidgetInfo::widget_locale>();
 945     }
 946     SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to get language tags")
 947 }
 948
 949 LanguageTagList WidgetDAOReadOnly::getIconLanguageTags() const
 950 {
 951     //TODO check widget existance
 952     using namespace DPL::DB::ORM;
 953     using namespace DPL::DB::ORM::wrt;
 954     WRT_DB_SELECT(select, WidgetLocalizedIcon, &WrtDatabase::interface())
 955     select->Where(Equals<WidgetLocalizedIcon::app_id>(m_widgetHandle));
 956     select->Distinct();
 957     return select->GetValueList<WidgetLocalizedIcon::widget_locale>();
 958 }
 959
 960 std::string WidgetDAOReadOnly::getCookieDatabasePath() const
 961 {
 962     using namespace WrtDB::WidgetConfig;
 963     std::ostringstream path;
 964
 965     DPL::OptionalString pkgname = getPkgname();
 966
 967     path << GetWidgetPersistentStoragePath(*pkgname);
 968     path << "/";
 969     path << GlobalConfig::GetCookieDatabaseFile();
 970
 971     return path.str();
 972 }
 973
 974 std::string WidgetDAOReadOnly::getPrivateLocalStoragePath() const
 975 {
 976     std::ostringstream path;
 977     DPL::OptionalString pkgname = getPkgname();
 978     path << WidgetConfig::GetWidgetWebLocalStoragePath(*pkgname);
 979     path << "/";
 980
 981     if (isFactory()) {
 982         WidgetGUID widgetGUID = getGUID();
 983         if (!widgetGUID) {
 984             Throw(WidgetDAOReadOnly::Exception::GUIDisNull);
 985         }
 986         path << DPL::ToUTF8String(*widgetGUID);
 987     }
 988
 989     return path.str();
 990 }
 991
 992 void WidgetDAOReadOnly::getWidgetSettings(
 993         WidgetSettings& outWidgetSettings) const
 994 {
 995     //TODO check widget existance
 996     SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
 997     {
 998         using namespace DPL::DB::ORM;
 999         using namespace DPL::DB::ORM::wrt;
1000         WRT_DB_SELECT(select, SettginsList, &WrtDatabase::interface())
1001         select->Where(Equals<SettginsList::appId>(m_widgetHandle));
1002
1003         SettginsList::Select::RowList rows = select->GetRowList();
1004
1005         FOREACH(it, rows)
1006         {
1007             WidgetSetting info;
1008
1009             info.settingName = it->Get_settingName();
1010             info.settingValue = it->Get_settingValue();
1011             outWidgetSettings.push_back(info);
1012         }
1013     }
1014     SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to get settings list")
1015 }
1016
1017 void WidgetDAOReadOnly::getAppServiceList(
1018         WidgetApplicationServiceList& outAppServiceList) const
1019 {
1020     LogDebug("Getting getAppServiceList. Handle: " << m_widgetHandle);
1021     SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
1022     {
1023         DPL::DB::ORM::wrt::ScopedTransaction transaction(&WrtDatabase::interface());
1024         CHECK_WIDGET_EXISTENCE(transaction, m_widgetHandle)
1025
1026         using namespace DPL::DB::ORM;
1027         using namespace DPL::DB::ORM::wrt;
1028         WRT_DB_SELECT(select, ApplicationServiceInfo, &WrtDatabase::interface())
1029         select->Where(Equals<ApplicationServiceInfo::app_id>(m_widgetHandle));
1030
1031         ApplicationServiceInfo::Select::RowList rows = select->GetRowList();
1032
1033         if (rows.empty()) {
1034             LogDebug("Application Service list is empty. Handle: " <<
1035                      m_widgetHandle);
1036         }
1037
1038         FOREACH(it, rows) {
1039             WidgetApplicationService ret;
1040             ret.src = it->Get_src();
1041             ret.operation = it->Get_operation();
1042             ret.scheme = it->Get_scheme();
1043             ret.mime = it->Get_mime();
1044             outAppServiceList.push_back(ret);
1045         }
1046
1047         transaction.Commit();
1048     }
1049     SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to get access host list")
1050 }
1051
1052 #undef SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
1053 #undef SQL_CONNECTION_EXCEPTION_HANDLER_END
1054 #undef CHECK_WIDGET_EXISTENCE
1055
1056 } // namespace WrtDB