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