modules/widget_dao/dao/widget_dao.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 definition of widget dao class.
  18  *
  19  * @file    widget_dao.cpp
  20  * @author  Przemyslaw Dobrowolski (p.dobrowolsk@samsung.com)
  21  * @author  Bartosz Janiak (b.janiak@samsung.com)
  22  * @author  Yang Jie (jie2.yang@samsung.com)
  23  * @author  Koeun Choi(koeun.choi@samsung.com)
  24  * @author  Pawel Sikorski(p.sikorski@samsung.com)
  25  * @version 1.0
  26  * @brief   This file contains the definition of Configuration.
  27  */
  28 #include <stddef.h>
  29 #include <dpl/wrt-dao-rw/widget_dao.h>
  30
  31 #include <sstream>
  32 #include <dpl/log/log.h>
  33 #include <dpl/foreach.h>
  34 #include <dpl/wrt-dao-ro/webruntime_database.h>
  35 #include <dpl/wrt-dao-rw/property_dao.h>
  36 #include <orm_generator_wrt.h>
  37 #include <dpl/wrt-dao-ro/WrtDatabase.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 WidgetDAO 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(WidgetDAO::Exception::DatabaseError, \
  51                    message);                            \
  52     }
  53
  54 WidgetDAO::WidgetDAO(DPL::OptionalString widgetGUID) :
  55     WidgetDAOReadOnly(WidgetDAOReadOnly::getHandle(widgetGUID))
  56 // TODO THIS WILL BE DELETED
  57 {
  58 }
  59
  60 WidgetDAO::WidgetDAO(DPL::String pkgName) :
  61     WidgetDAOReadOnly(WidgetDAOReadOnly::getHandle(pkgName))
  62 {
  63 }
  64
  65 WidgetDAO::WidgetDAO(DbWidgetHandle handle) :
  66     WidgetDAOReadOnly(handle)
  67 {
  68 }
  69
  70 WidgetDAO::~WidgetDAO()
  71 {
  72 }
  73
  74 void WidgetDAO::removeProperty(
  75         const PropertyDAOReadOnly::WidgetPropertyKey &key)
  76 {
  77     Try {
  78         PropertyDAO::RemoveProperty(m_widgetHandle, key);
  79     }
  80     Catch(PropertyDAOReadOnly::Exception::ReadOnlyProperty){
  81         ReThrowMsg(WidgetDAO::Exception::DatabaseError,
  82                    "Failure during removing property");
  83     }
  84 }
  85
  86 void WidgetDAO::setProperty(
  87         const PropertyDAOReadOnly::WidgetPropertyKey &key,
  88         const PropertyDAOReadOnly::WidgetPropertyValue &value,
  89         bool readOnly)
  90 {
  91     Try {
  92         PropertyDAO::SetProperty(m_widgetHandle, key, value, readOnly);
  93     }
  94     Catch(PropertyDAOReadOnly::Exception::ReadOnlyProperty){
  95         ReThrowMsg(WidgetDAO::Exception::DatabaseError,
  96                    "Failure during setting/updating property");
  97     }
  98 }
  99
 100 void WidgetDAO::setPkgName(const DPL::OptionalString& pkgName)
 101 {
 102     SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
 103     {
 104         using namespace DPL::DB::ORM;
 105         wrt::ScopedTransaction transaction(&WrtDatabase::interface());
 106
 107         isWidgetInstalled(getHandle());
 108
 109         wrt::WidgetInfo::Row row;
 110         row.Set_pkgname(pkgName);
 111
 112         WRT_DB_UPDATE(update, wrt::WidgetInfo, &WrtDatabase::interface())
 113         update->Where(
 114             Equals<wrt::WidgetInfo::app_id>(getHandle()));
 115
 116         update->Values(row);
 117         update->Execute();
 118         transaction.Commit();
 119     }
 120     SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to register widget")
 121 }
 122
 123 void WidgetDAO::setPkgName_NOTNULL(const DPL::String& pkgName)
 124 {
 125     SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
 126     {
 127         using namespace DPL::DB::ORM;
 128         wrt::ScopedTransaction transaction(&WrtDatabase::interface());
 129
 130         isWidgetInstalled(getHandle());
 131
 132         wrt::WidgetInfo::Row row;
 133         row.Set_pkgname(pkgName);
 134
 135         WRT_DB_UPDATE(update, wrt::WidgetInfo, &WrtDatabase::interface())
 136         update->Where(
 137             Equals<wrt::WidgetInfo::app_id>(getHandle()));
 138
 139         update->Values(row);
 140         update->Execute();
 141         transaction.Commit();
 142     }
 143     SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to register widget")
 144 }
 145
 146 void WidgetDAO::setSecurityPopupUsage(const SettingsType value)
 147 {
 148     SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
 149     {
 150         using namespace DPL::DB::ORM;
 151         using namespace DPL::DB::ORM::wrt;
 152
 153         ScopedTransaction transaction(&WrtDatabase::interface());
 154         if (!isWidgetInstalled(getHandle())) {
 155             ThrowMsg(WidgetDAOReadOnly::Exception::WidgetNotExist,
 156                 "Cannot find widget. Handle: " << getHandle());
 157         }
 158
 159         WidgetSecuritySettings::Row row;
 160         row.Set_security_popup_usage(value);
 161
 162         WRT_DB_UPDATE(update, WidgetSecuritySettings, &WrtDatabase::interface())
 163         update->Where(Equals<WidgetSecuritySettings::app_id>(getHandle()));
 164         update->Values(row);
 165         update->Execute();
 166
 167         transaction.Commit();
 168     }
 169     SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to set security popup usage")
 170 }
 171
 172 void WidgetDAO::setGeolocationUsage(const SettingsType value)
 173 {
 174     SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
 175     {
 176         using namespace DPL::DB::ORM;
 177         using namespace DPL::DB::ORM::wrt;
 178
 179         ScopedTransaction transaction(&WrtDatabase::interface());
 180         if (!isWidgetInstalled(getHandle())) {
 181             ThrowMsg(WidgetDAOReadOnly::Exception::WidgetNotExist,
 182                 "Cannot find widget. Handle: " << getHandle());
 183         }
 184
 185         WidgetSecuritySettings::Row row;
 186         row.Set_geolocation_usage(value);
 187
 188         WRT_DB_UPDATE(update, WidgetSecuritySettings, &WrtDatabase::interface())
 189         update->Where(Equals<WidgetSecuritySettings::app_id>(getHandle()));
 190         update->Values(row);
 191         update->Execute();
 192
 193         transaction.Commit();
 194     }
 195     SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to set geolocation usage")
 196 }
 197
 198 void WidgetDAO::setWebNotificationUsage(const SettingsType value)
 199 {
 200     SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
 201     {
 202         using namespace DPL::DB::ORM;
 203         using namespace DPL::DB::ORM::wrt;
 204
 205         ScopedTransaction transaction(&WrtDatabase::interface());
 206         if (!isWidgetInstalled(getHandle())) {
 207             ThrowMsg(WidgetDAOReadOnly::Exception::WidgetNotExist,
 208                 "Cannot find widget. Handle: " << getHandle());
 209         }
 210
 211         WidgetSecuritySettings::Row row;
 212         row.Set_web_notification_usage(value);
 213
 214         WRT_DB_UPDATE(update, WidgetSecuritySettings, &WrtDatabase::interface())
 215         update->Where(Equals<WidgetSecuritySettings::app_id>(getHandle()));
 216         update->Values(row);
 217         update->Execute();
 218
 219         transaction.Commit();
 220     }
 221     SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to set web notification usage")
 222 }
 223
 224 void WidgetDAO::setWebDatabaseUsage(const SettingsType value)
 225 {
 226     SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
 227     {
 228         using namespace DPL::DB::ORM;
 229         using namespace DPL::DB::ORM::wrt;
 230
 231         ScopedTransaction transaction(&WrtDatabase::interface());
 232         if (!isWidgetInstalled(getHandle())) {
 233             ThrowMsg(WidgetDAOReadOnly::Exception::WidgetNotExist,
 234                 "Cannot find widget. Handle: " << getHandle());
 235         }
 236
 237         WidgetSecuritySettings::Row row;
 238         row.Set_web_database_usage(value);
 239
 240         WRT_DB_UPDATE(update, WidgetSecuritySettings, &WrtDatabase::interface())
 241         update->Where(Equals<WidgetSecuritySettings::app_id>(getHandle()));
 242         update->Values(row);
 243         update->Execute();
 244
 245         transaction.Commit();
 246     }
 247     SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to set web database usage")
 248 }
 249
 250 void WidgetDAO::setFileSystemUsage(const SettingsType value)
 251 {
 252     SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
 253     {
 254         using namespace DPL::DB::ORM;
 255         using namespace DPL::DB::ORM::wrt;
 256
 257         ScopedTransaction transaction(&WrtDatabase::interface());
 258         if (!isWidgetInstalled(getHandle())) {
 259             ThrowMsg(WidgetDAOReadOnly::Exception::WidgetNotExist,
 260                 "Cannot find widget. Handle: " << getHandle());
 261         }
 262
 263         WidgetSecuritySettings::Row row;
 264         row.Set_file_system_usage(value);
 265
 266         WRT_DB_UPDATE(update, WidgetSecuritySettings, &WrtDatabase::interface())
 267         update->Where(Equals<WidgetSecuritySettings::app_id>(getHandle()));
 268         update->Values(row);
 269         update->Execute();
 270
 271         transaction.Commit();
 272     }
 273     SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to set filesystem usage")
 274 }
 275
 276 void WidgetDAO::registerWidget(
 277         const WidgetPkgName & widgetPkgname,
 278         const WidgetRegisterInfo &widgetRegInfo,
 279         const IWacSecurity &wacSecurity)
 280 {
 281     LogDebug("Registering widget");
 282     SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
 283     {
 284         DPL::DB::ORM::wrt::ScopedTransaction transaction(&WrtDatabase::interface());
 285         registerWidgetInternal(widgetPkgname, widgetRegInfo, wacSecurity);
 286         transaction.Commit();
 287     }
 288     SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to register widget")
 289 }
 290
 291 void WidgetDAO::registerWidget(
 292         WrtDB::DbWidgetHandle handle,
 293         const WidgetRegisterInfo &widgetRegInfo,
 294         const IWacSecurity &wacSecurity)
 295 {
 296     LogDebug("Registering widget");
 297     SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
 298     {
 299         DPL::DB::ORM::wrt::ScopedTransaction transaction(&WrtDatabase::interface());
 300         registerWidgetInternal(generateTizenId(), widgetRegInfo, wacSecurity, handle);
 301         transaction.Commit();
 302     }
 303     SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to register widget")
 304 }
 305
 306 DbWidgetHandle WidgetDAO::registerWidget(
 307             const WidgetRegisterInfo &pWidgetRegisterInfo,
 308             const IWacSecurity &wacSecurity)
 309 {
 310     //make it more precise due to very fast tests
 311     struct timeval tv;
 312     gettimeofday(&tv, NULL);
 313     srand(time(NULL) + tv.tv_usec);
 314     DbWidgetHandle widgetHandle;
 315     do {
 316         widgetHandle = rand();
 317     } while (isWidgetInstalled(widgetHandle));
 318
 319     registerWidget(widgetHandle, pWidgetRegisterInfo, wacSecurity);
 320     return widgetHandle;
 321 }
 322
 323 WidgetPkgName WidgetDAO::registerWidgetGenerateTizenId(
 324             const WidgetRegisterInfo &pWidgetRegisterInfo,
 325             const IWacSecurity &wacSecurity)
 326 {
 327     WidgetPkgName widgetPkgName = generateTizenId();
 328     registerWidget(widgetPkgName, pWidgetRegisterInfo, wacSecurity);
 329     return widgetPkgName;
 330 }
 331
 332 void WidgetDAO::registerWidgetInternal(
 333         const WidgetPkgName & widgetName,
 334         const WidgetRegisterInfo &widgetRegInfo,
 335         const IWacSecurity &wacSecurity,
 336         const DPL::Optional<DbWidgetHandle> handle)
 337 {
 338     //Register into WidgetInfo has to be first
 339     //as all other tables depend upon that
 340     DbWidgetHandle widgetHandle = registerWidgetInfo(widgetName, widgetRegInfo, wacSecurity, handle);
 341
 342     registerWidgetExtendedInfo(widgetHandle, widgetRegInfo);
 343
 344     registerWidgetLocalizedInfo(widgetHandle, widgetRegInfo);
 345
 346     registerWidgetIcons(widgetHandle, widgetRegInfo);
 347
 348     registerWidgetStartFile(widgetHandle, widgetRegInfo);
 349
 350     PropertyDAO::RegisterProperties(widgetHandle, widgetRegInfo);
 351
 352     registerWidgetFeatures(widgetHandle, widgetRegInfo);
 353
 354     registerWidgetWindowModes(widgetHandle, widgetRegInfo);
 355
 356     registerWidgetWarpInfo(widgetHandle, widgetRegInfo);
 357
 358     registerWidgetCertificates(widgetHandle, wacSecurity);
 359
 360     CertificateChainList list;
 361     wacSecurity.getCertificateChainList(list, SIGNATURE_DISTRIBUTOR);
 362     registerCertificatesChains(widgetHandle, SIGNATURE_DISTRIBUTOR, list);
 363
 364     list.clear();
 365     wacSecurity.getCertificateChainList(list, SIGNATURE_AUTHOR);
 366     registerCertificatesChains(widgetHandle, SIGNATURE_AUTHOR, list);
 367
 368     registerWidgetSettings(widgetHandle, widgetRegInfo);
 369
 370     registerAppService(widgetHandle, widgetRegInfo);
 371
 372     registerEncryptedResouceInfo(widgetHandle, widgetRegInfo);
 373
 374     registerExternalLocations(widgetHandle, widgetRegInfo.externalLocations);
 375
 376     registerWidgetSecuritySettings(widgetHandle);
 377 }
 378
 379 void WidgetDAO::registerOrUpdateWidget(
 380         const WidgetPkgName & widgetName,
 381         const WidgetRegisterInfo &widgetRegInfo,
 382         const IWacSecurity &wacSecurity)
 383 {
 384     LogDebug("Reregistering widget");
 385     SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
 386     {
 387         DPL::DB::ORM::wrt::ScopedTransaction transaction(&WrtDatabase::interface());
 388
 389         unregisterWidgetInternal(widgetName);
 390         registerWidgetInternal(widgetName, widgetRegInfo, wacSecurity);
 391         transaction.Commit();
 392     }
 393     SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to reregister widget")
 394 }
 395
 396 #define DO_INSERT(row, table)                              \
 397     {                                                      \
 398         WRT_DB_INSERT(insert, table, &WrtDatabase::interface()) \
 399         insert->Values(row);                               \
 400         insert->Execute();                                 \
 401     }
 402
 403 void WidgetDAO::registerWidgetExtendedInfo(DbWidgetHandle widgetHandle,
 404         const WidgetRegisterInfo &regInfo)
 405 {
 406     //Try and transaction not needed
 407     using namespace DPL::DB::ORM;
 408     using namespace DPL::DB::ORM::wrt;
 409
 410
 411     WidgetExtendedInfo::Row row;
 412     row.Set_app_id(widgetHandle);
 413     //    row.Set_share_href    (DPL::FromUTF8String(regInfo.shareHref));
 414     row.Set_signature_type(regInfo.signatureType);
 415     row.Set_test_widget(regInfo.isTestWidget);
 416     row.Set_install_time(regInfo.installedTime);
 417     row.Set_splash_img_src(regInfo.configInfo.splashImgSrc);
 418     row.Set_background_page(regInfo.configInfo.backgroundPage);
 419     row.Set_installed_path(regInfo.widgetInstalledPath);
 420
 421     DO_INSERT(row, WidgetExtendedInfo)
 422 }
 423
 424 DbWidgetHandle WidgetDAO::registerWidgetInfo(
 425         const WidgetPkgName & widgetName,
 426         const WidgetRegisterInfo &regInfo,
 427         const IWacSecurity &wacSecurity,
 428         const DPL::Optional<DbWidgetHandle> handle)
 429 {
 430     using namespace DPL::DB::ORM;
 431     using namespace DPL::DB::ORM::wrt;
 432     const ConfigParserData& widgetConfigurationInfo = regInfo.configInfo;
 433
 434     // TODO in wrt_db all Columns in WidgetInfo have DEFAULT VALUE set.
 435     // Because of that, "Optional" is not used there
 436
 437     WidgetInfo::Row row;
 438     if(!!handle)
 439     {
 440         row.Set_app_id(*handle);
 441     }
 442
 443     if (regInfo.webAppType == APP_TYPE_UNKNOWN && regInfo.type !=
 444             APP_TYPE_UNKNOWN) {
 445         // TODO : regInfo.type is temporary code for security.
 446         //        This code will be removed.
 447         row.Set_widget_type(regInfo.type.appType);
 448     } else {
 449         row.Set_widget_type(regInfo.webAppType.appType);
 450     }
 451     row.Set_widget_id(widgetConfigurationInfo.widget_id);
 452     row.Set_defaultlocale(widgetConfigurationInfo.defaultlocale);
 453     row.Set_widget_version(widgetConfigurationInfo.version);
 454     row.Set_widget_width(widgetConfigurationInfo.width);
 455     row.Set_widget_height(widgetConfigurationInfo.height);
 456     row.Set_author_name(widgetConfigurationInfo.authorName);
 457     row.Set_author_email(widgetConfigurationInfo.authorEmail);
 458     row.Set_author_href(widgetConfigurationInfo.authorHref);
 459     row.Set_base_folder(DPL::FromUTF8String(regInfo.baseFolder));
 460     row.Set_webkit_plugins_required(widgetConfigurationInfo.flashNeeded);
 461     row.Set_recognized(wacSecurity.isRecognized());
 462     row.Set_wac_signed(wacSecurity.isWacSigned());
 463     row.Set_distributor_signed(wacSecurity.isDistributorSigned());
 464     row.Set_pkgname(widgetName);
 465     {
 466         std::stringstream tmp;
 467         tmp << regInfo.minVersion;
 468         row.Set_min_version(DPL::FromUTF8String(tmp.str()));
 469     }
 470     row.Set_back_supported(widgetConfigurationInfo.backSupported);
 471     row.Set_access_network(widgetConfigurationInfo.accessNetwork);
 472     row.Set_pkg_type(regInfo.packagingType.pkgType);
 473
 474     Try
 475     {
 476         DO_INSERT(row, WidgetInfo);
 477     }
 478     Catch(DPL::DB::SqlConnection::Exception::Base)
 479     {
 480         ReThrowMsg(WidgetDAO::Exception::DatabaseError,
 481                    "Failed to register widget info.");
 482     }
 483
 484     if(!handle)
 485     {
 486         //get autoincremented value of widgetHandle
 487         WRT_DB_SELECT(select, WidgetInfo, &WrtDatabase::interface())
 488         select->Where(Equals<WidgetInfo::pkgname>(widgetName));
 489         return select->GetSingleValue<WidgetInfo::app_id>();
 490     }
 491     else
 492     {
 493         return *handle;
 494     }
 495 }
 496
 497 void WidgetDAO::registerWidgetLocalizedInfo(DbWidgetHandle widgetHandle,
 498         const WidgetRegisterInfo &regInfo)
 499 {
 500     using namespace DPL::DB::ORM;
 501     using namespace DPL::DB::ORM::wrt;
 502
 503     const ConfigParserData& widgetConfigurationInfo = regInfo.configInfo;
 504
 505     FOREACH(it, widgetConfigurationInfo.localizedDataSet)
 506     {
 507         const DPL::String& locale = it->first;
 508         const ConfigParserData::LocalizedData& data = it->second;
 509
 510         LocalizedWidgetInfo::Row row;
 511         row.Set_app_id(widgetHandle);
 512         row.Set_widget_locale(locale);
 513         row.Set_widget_name(data.name);
 514         row.Set_widget_shortname(data.shortName);
 515         row.Set_widget_description(data.description);
 516         row.Set_widget_license(data.license);
 517         row.Set_widget_license_file(data.licenseFile);
 518         row.Set_widget_license_href(data.licenseHref);
 519
 520         DO_INSERT(row, LocalizedWidgetInfo)
 521     }
 522 }
 523
 524 void WidgetDAO::registerWidgetIcons(DbWidgetHandle widgetHandle,
 525         const WidgetRegisterInfo &regInfo)
 526 {
 527     using namespace DPL::DB::ORM;
 528     using namespace DPL::DB::ORM::wrt;
 529
 530
 531     FOREACH(i, regInfo.localizationData.icons)
 532     {
 533         wrt::WidgetIcon::icon_id::ColumnType icon_id;
 534         {
 535             wrt::WidgetIcon::Row row;
 536             row.Set_app_id(widgetHandle);
 537             row.Set_icon_src(i->src);
 538             row.Set_icon_width(i->width);
 539             row.Set_icon_height(i->height);
 540
 541             WRT_DB_INSERT(insert, wrt::WidgetIcon, &WrtDatabase::interface())
 542             insert->Values(row);
 543             icon_id = insert->Execute();
 544         }
 545
 546         FOREACH(j, i->availableLocales)
 547         {
 548             WidgetLocalizedIcon::Row row;
 549             row.Set_app_id(widgetHandle);
 550             row.Set_icon_id(icon_id);
 551             row.Set_widget_locale(*j);
 552             WRT_DB_SELECT(select, WidgetLocalizedIcon, &WrtDatabase::interface())
 553             select->Where(And(Equals<WidgetLocalizedIcon::app_id>(widgetHandle),
 554                               Equals<WidgetLocalizedIcon::widget_locale>(*j)));
 555             WidgetLocalizedIcon::Select::RowList rows = select->GetRowList();
 556
 557             bool flag = !rows.empty();
 558
 559             if(flag == true)
 560             {
 561                 // already default icon value of same locale exists
 562                 WRT_DB_UPDATE(update, WidgetLocalizedIcon, &WrtDatabase::interface())
 563                 update->Where(And(Equals<WidgetLocalizedIcon::app_id>(widgetHandle),
 564                                   Equals<WidgetLocalizedIcon::widget_locale>(*j)));
 565                 update->Values(row);
 566                 update->Execute();
 567             }else{
 568                 // any icon value of same locale doesn't exist
 569                 DO_INSERT(row, WidgetLocalizedIcon)
 570             }
 571         }
 572     }
 573 }
 574
 575 void WidgetDAO::registerWidgetStartFile(DbWidgetHandle widgetHandle,
 576         const WidgetRegisterInfo &regInfo)
 577 {
 578     using namespace DPL::DB::ORM;
 579     using namespace DPL::DB::ORM::wrt;
 580
 581
 582     FOREACH(i, regInfo.localizationData.startFiles)
 583     {
 584         WidgetStartFile::start_file_id::ColumnType startFileID;
 585         {
 586             WidgetStartFile::Row row;
 587             row.Set_app_id(widgetHandle);
 588             row.Set_src(i->path);
 589
 590             WRT_DB_INSERT(insert, WidgetStartFile, &WrtDatabase::interface())
 591             insert->Values(row);
 592             startFileID = insert->Execute();
 593         }
 594
 595         FOREACH(j, i->propertiesForLocales)
 596         {
 597             WidgetLocalizedStartFile::Row row;
 598             row.Set_app_id(widgetHandle);
 599             row.Set_start_file_id(startFileID);
 600             row.Set_widget_locale(j->first);
 601             row.Set_type(j->second.type);
 602             row.Set_encoding(j->second.encoding);
 603
 604             DO_INSERT(row, WidgetLocalizedStartFile)
 605         }
 606     }
 607 }
 608
 609 void WidgetDAO::registerWidgetFeatures(DbWidgetHandle widgetHandle,
 610         const WidgetRegisterInfo &regInfo)
 611 {
 612     using namespace DPL::DB::ORM;
 613     const ConfigParserData& widgetConfigurationInfo = regInfo.configInfo;
 614
 615
 616     FOREACH(pWidgetFeature, widgetConfigurationInfo.featuresList)
 617     {
 618         wrt::WidgetFeature::Row widgetFeature;
 619         widgetFeature.Set_app_id(widgetHandle);
 620         widgetFeature.Set_name(pWidgetFeature->name);
 621         widgetFeature.Set_required(pWidgetFeature->required);
 622         widgetFeature.Set_rejected(false);
 623
 624         wrt::WidgetFeature::widget_feature_id::ColumnType widgetFeatureID;
 625         {
 626             WRT_DB_INSERT(insert, wrt::WidgetFeature, &WrtDatabase::interface())
 627             insert->Values(widgetFeature);
 628             widgetFeatureID = insert->Execute();
 629         }
 630
 631         // Insert into table FeatureParam
 632         wrt::FeatureParam::Row featureParam;
 633         featureParam.Set_widget_feature_id(widgetFeatureID);
 634
 635         FOREACH(iter, pWidgetFeature->paramsList)
 636         {
 637             featureParam.Set_name(iter->name);
 638             featureParam.Set_value(iter->value);
 639
 640             DO_INSERT(featureParam, wrt::FeatureParam)
 641         }
 642     }
 643 }
 644
 645 void WidgetDAO::updateFeatureRejectStatus(const DbWidgetFeature &widgetFeature){
 646     // This function could be merged with registerWidgetFeature but it requires desing change:
 647     // 1. Check "ace step" in installer must be done before "update database step"
 648     // And:
 649     // ConfigurationParserData shouldn't be called "ParserData" any more.
 650     using namespace DPL::DB::ORM;
 651
 652     wrt::ScopedTransaction transaction(&WrtDatabase::interface());
 653     WRT_DB_SELECT(select, wrt::WidgetFeature, &WrtDatabase::interface())
 654     select->Where(And(Equals<wrt::WidgetFeature::app_id>(m_widgetHandle),
 655                       Equals<wrt::WidgetFeature::name>(widgetFeature.name)));
 656
 657     auto row = select->GetSingleRow();
 658     row.Set_rejected(widgetFeature.rejected);
 659
 660     WRT_DB_UPDATE(update, wrt::WidgetFeature, &WrtDatabase::interface())
 661     update->Where(And(Equals<wrt::WidgetFeature::app_id>(m_widgetHandle),
 662                       Equals<wrt::WidgetFeature::name>(widgetFeature.name)));
 663     update->Values(row);
 664     update->Execute();
 665     transaction.Commit();
 666 }
 667
 668 void WidgetDAO::registerWidgetWindowModes(DbWidgetHandle widgetHandle,
 669         const WidgetRegisterInfo &regInfo)
 670 {
 671     using namespace DPL::DB::ORM;
 672     using namespace DPL::DB::ORM::wrt;
 673     const ConfigParserData& widgetConfigurationInfo = regInfo.configInfo;
 674
 675
 676     FOREACH(i, widgetConfigurationInfo.windowModes)
 677     {
 678         wrt::WidgetWindowModes::Row windowMode;
 679         windowMode.Set_app_id(widgetHandle);
 680         windowMode.Set_window_mode(*i);
 681
 682         DO_INSERT(windowMode, wrt::WidgetWindowModes)
 683     }
 684 }
 685
 686 void WidgetDAO::registerWidgetWarpInfo(DbWidgetHandle widgetHandle,
 687         const WidgetRegisterInfo &regInfo)
 688 {
 689     using namespace DPL::DB::ORM;
 690     using namespace DPL::DB::ORM::wrt;
 691     const ConfigParserData& widgetConfigurationInfo = regInfo.configInfo;
 692
 693
 694     FOREACH(AccIt, widgetConfigurationInfo.accessInfoSet)
 695     {
 696         WidgetWARPInfo::Row row;
 697         row.Set_app_id(widgetHandle);
 698         row.Set_iri(AccIt->m_strIRI);
 699         row.Set_subdomain_access(static_cast <int>(
 700                                      AccIt->m_bSubDomainAccess));
 701
 702         DO_INSERT(row, WidgetWARPInfo)
 703     }
 704 }
 705
 706 void WidgetDAO::registerWidgetCertificates(DbWidgetHandle widgetHandle,
 707         const IWacSecurity &wacSecurity)
 708 {
 709     using namespace DPL::DB::ORM;
 710     using namespace DPL::DB::ORM::wrt;
 711
 712
 713     FOREACH(it, wacSecurity.getCertificateList())
 714     {
 715         WidgetCertificateFingerprint::Row row;
 716         row.Set_app_id(widgetHandle);
 717         row.Set_owner(it->owner);
 718         row.Set_chainid(it->chainId);
 719         row.Set_type(it->type);
 720         row.Set_md5_fingerprint(DPL::FromUTF8String(it->strMD5Fingerprint));
 721         row.Set_sha1_fingerprint(DPL::FromUTF8String(it->strSHA1Fingerprint));
 722         row.Set_common_name(it->strCommonName);
 723
 724         DO_INSERT(row, WidgetCertificateFingerprint)
 725     }
 726 }
 727
 728 void WidgetDAO::registerCertificatesChains(DbWidgetHandle widgetHandle,
 729         CertificateSource certificateSource,
 730         const CertificateChainList &certificateChainList)
 731 {
 732     using namespace DPL::DB::ORM;
 733     using namespace DPL::DB::ORM::wrt;
 734     FOREACH(certChain, certificateChainList)
 735     {
 736         WidgetCertificate::Row row;
 737         row.Set_app_id(widgetHandle);
 738         row.Set_cert_source(certificateSource);
 739         row.Set_encoded_chain(DPL::FromASCIIString(*certChain));
 740
 741         DO_INSERT(row, WidgetCertificate);
 742     }
 743 }
 744
 745 void WidgetDAO::registerWidgetSettings(DbWidgetHandle widgetHandle,
 746         const WidgetRegisterInfo &regInfo)
 747 {
 748     using namespace DPL::DB::ORM;
 749     using namespace DPL::DB::ORM::wrt;
 750
 751     const ConfigParserData& widgetConfigurationInfo = regInfo.configInfo;
 752
 753     FOREACH(pWidgetSetting, widgetConfigurationInfo.settingsList)
 754     {
 755         SettingsList::Row row;
 756         row.Set_appId(widgetHandle);
 757         row.Set_settingName(pWidgetSetting->m_name);
 758         row.Set_settingValue(pWidgetSetting->m_value);
 759
 760         DO_INSERT(row, SettingsList)
 761     }
 762 }
 763
 764 void WidgetDAO::registerAppService(DbWidgetHandle widgetHandle,
 765                                    const WidgetRegisterInfo &regInfo)
 766 {
 767     using namespace DPL::DB::ORM;
 768     using namespace DPL::DB::ORM::wrt;
 769     const ConfigParserData& widgetConfigurationInfo = regInfo.configInfo;
 770
 771     FOREACH(ASIt, widgetConfigurationInfo.appServiceList)
 772     {
 773         ApplicationServiceInfo::Row row;
 774         row.Set_app_id(widgetHandle);
 775         row.Set_src(ASIt->m_src);
 776         row.Set_operation(ASIt->m_operation);
 777         row.Set_scheme(ASIt->m_scheme);
 778         row.Set_mime(ASIt->m_mime);
 779
 780         DO_INSERT(row, ApplicationServiceInfo)
 781     }
 782 }
 783
 784 void WidgetDAO::registerEncryptedResouceInfo(DbWidgetHandle widgetHandle,
 785         const WidgetRegisterInfo &regInfo)
 786 {
 787     using namespace DPL::DB::ORM;
 788     using namespace DPL::DB::ORM::wrt;
 789
 790     FOREACH(it, regInfo.encryptedFiles)
 791     {
 792         EncryptedResourceList::Row row;
 793         row.Set_app_id(widgetHandle);
 794         row.Set_resource(it->fileName);
 795         row.Set_size(it->fileSize);
 796
 797         DO_INSERT(row, EncryptedResourceList)
 798     }
 799 }
 800
 801 void WidgetDAO::registerExternalLocations(DbWidgetHandle widgetHandle,
 802                                           const ExternalLocationList & externals)
 803 {
 804     SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
 805     {
 806         using namespace DPL::DB::ORM;
 807         using namespace DPL::DB::ORM::wrt;
 808         DPL::DB::ORM::wrt::ScopedTransaction transaction(&WrtDatabase::interface());
 809         LogDebug("Inserting external files for widgetHandle: " << widgetHandle);
 810         FOREACH(it, externals)
 811         {
 812             WidgetExternalLocations::Row row;
 813             row.Set_app_id(widgetHandle);
 814             row.Set_path(DPL::FromUTF8String(*it));
 815
 816             DO_INSERT(row, WidgetExternalLocations)
 817         }
 818         transaction.Commit();
 819     }
 820     SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to register external files");
 821 }
 822
 823 void WidgetDAO::registerWidgetSecuritySettings(DbWidgetHandle widgetHandle)
 824 {
 825     SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
 826     {
 827         using namespace DPL::DB::ORM;
 828         using namespace DPL::DB::ORM::wrt;
 829         DPL::DB::ORM::wrt::ScopedTransaction transaction(&WrtDatabase::interface());
 830
 831         WidgetSecuritySettings::Row row;
 832         row.Set_app_id(widgetHandle);
 833         row.Set_security_popup_usage(SETTINGS_TYPE_ON);
 834         row.Set_geolocation_usage(SETTINGS_TYPE_ON);
 835         row.Set_web_notification_usage(SETTINGS_TYPE_ON);
 836         row.Set_web_database_usage(SETTINGS_TYPE_ON);
 837         row.Set_file_system_usage(SETTINGS_TYPE_ON);
 838
 839         DO_INSERT(row, WidgetSecuritySettings)
 840         transaction.Commit();
 841     }
 842     SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to register external files");
 843 }
 844
 845 void WidgetDAO::unregisterAllExternalLocations()
 846 {
 847     using namespace DPL::DB::ORM;
 848     using namespace DPL::DB::ORM::wrt;
 849     LogDebug("Deleting external files for widgetHandle: " << m_widgetHandle);
 850     WRT_DB_DELETE(del, WidgetExternalLocations, &WrtDatabase::interface());
 851     del->Where(Equals<WidgetExternalLocations::app_id>(m_widgetHandle));
 852     del->Execute();
 853 }
 854
 855 void WidgetDAO::unregisterWidget(const WidgetPkgName & pkgName)
 856 {
 857     LogDebug("Unregistering widget from DB. PkgName: " << pkgName);
 858     SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
 859     {
 860         DPL::DB::ORM::wrt::ScopedTransaction transaction(&WrtDatabase::interface());
 861         unregisterWidgetInternal(pkgName);
 862         transaction.Commit();
 863     }
 864     SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to unregister widget")
 865 }
 866
 867 void WidgetDAO::unregisterWidget(WrtDB::DbWidgetHandle handle)
 868 {
 869     LogDebug("Unregistering widget from DB. Handle: " << handle);
 870     SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
 871     {
 872         using namespace DPL::DB::ORM;
 873         using namespace DPL::DB::ORM::wrt;
 874         ScopedTransaction transaction(&WrtDatabase::interface());
 875
 876         // Delete from table Widget Info
 877         WRT_DB_DELETE(del, WidgetInfo, &WrtDatabase::interface())
 878         del->Where(Equals<WidgetInfo::app_id>(handle));
 879         del->Execute();
 880
 881         transaction.Commit();
 882     }
 883     SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to unregister widget")
 884 }
 885
 886 void WidgetDAO::unregisterWidgetInternal(
 887         const WidgetPkgName & pkgName)
 888 {
 889     using namespace DPL::DB::ORM;
 890     using namespace DPL::DB::ORM::wrt;
 891
 892     DbWidgetHandle handle = getHandle(pkgName);
 893
 894     // Delete from table Widget Info
 895     WRT_DB_DELETE(del, WidgetInfo, &WrtDatabase::interface())
 896     del->Where(Equals<WidgetInfo::app_id>(handle));
 897     del->Execute();
 898
 899     // Deleting in other tables is done via "delete cascade" in SQL
 900 }
 901
 902 #undef DO_INSERT
 903
 904 #undef SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
 905 #undef SQL_CONNECTION_EXCEPTION_HANDLER_END
 906
 907 } // namespace WrtDB