ace/dao/AceDAO.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  *
  18  *
  19  * @file       AceDAO.cpp
  20  * @author     Krzysztof Jackiewicz (k.jackiewicz@samsung.com)
  21  * @version    0.1
  22  * @brief
  23  */
  24
  25 #include <ace-dao-rw/AceDAO.h>
  26
  27 #include <openssl/md5.h>
  28 #include <dpl/foreach.h>
  29 #include <dpl/string.h>
  30 #include <dpl/log/log.h>
  31 #include <dpl/db/orm.h>
  32 #include <ace-dao-ro/AceDAOUtilities.h>
  33 #include <ace-dao-ro/AceDAOConversions.h>
  34 #include <ace-dao-ro/AceDatabase.h>
  35
  36 using namespace DPL::DB::ORM;
  37 using namespace DPL::DB::ORM::ace;
  38 using namespace AceDB::AceDaoUtilities;
  39 using namespace AceDB::AceDaoConversions;
  40
  41 namespace {
  42 char const * const EMPTY_SESSION = "";
  43 } // namespace
  44
  45 namespace AceDB{
  46
  47 void AceDAO::setPromptDecision(
  48     WidgetHandle widgetHandle,
  49     int ruleId,
  50     const DPL::OptionalString &session,
  51     PromptDecision decision)
  52 {
  53     Try {
  54         ScopedTransaction transaction(&AceDaoUtilities::m_databaseInterface);
  55
  56         ACE_DB_DELETE(del, AcePromptDecision, &AceDaoUtilities::m_databaseInterface);
  57         del->Where(
  58             And(
  59                 Equals<AcePromptDecision::app_id>(widgetHandle),
  60                 Equals<AcePromptDecision::rule_id>(ruleId)));
  61         del->Execute();
  62
  63         AcePromptDecision::Row row;
  64         row.Set_rule_id(ruleId);
  65         row.Set_decision(promptDecisionToInt(decision));
  66         row.Set_app_id(widgetHandle);
  67         row.Set_session(session);
  68         ACE_DB_INSERT(insert, AcePromptDecision, &AceDaoUtilities::m_databaseInterface);
  69         insert->Values(row);
  70         insert->Execute();
  71
  72         transaction.Commit();
  73     }
  74     Catch(DPL::DB::SqlConnection::Exception::Base) {
  75         ReThrowMsg(Exception::DatabaseError, "Failed to setUserSetting");
  76     }
  77 }
  78
  79 void AceDAO::removePolicyResult(
  80         const BaseAttributeSet &attributes)
  81 {
  82     Try {
  83         ScopedTransaction transaction(&AceDaoUtilities::m_databaseInterface);
  84
  85         auto attrHash =  convertToHash(attributes);
  86
  87         ACE_DB_DELETE(del,
  88                       AcePolicyResult,
  89                       &AceDaoUtilities::m_databaseInterface);
  90         del->Where(Equals<AcePolicyResult::hash>(attrHash));
  91         del->Execute();
  92         transaction.Commit();
  93     }
  94     Catch(DPL::DB::SqlConnection::Exception::Base) {
  95         ReThrowMsg(Exception::DatabaseError, "Failed to removeVerdict");
  96     }
  97 }
  98
  99 void AceDAO::clearAllSettings(void)
 100 {
 101     clearWidgetDevCapSettings();
 102     clearDevCapSettings();
 103 }
 104
 105 void AceDAO::setDevCapSetting(const std::string &resource,
 106                               PreferenceTypes preference)
 107 {
 108     Try {
 109         ACE_DB_UPDATE(update, AceDevCap, &AceDaoUtilities::m_databaseInterface);
 110         AceDevCap::Row row;
 111         row.Set_general_setting(preferenceToInt(preference));
 112         update->Values(row);
 113         update->Where(
 114             Equals<AceDevCap::id_uri>(DPL::FromUTF8String(resource)));
 115         update->Execute();
 116     }
 117     Catch(DPL::DB::SqlConnection::Exception::Base) {
 118         ReThrowMsg(Exception::DatabaseError, "Failed to SetResourceSetting");
 119     }
 120 }
 121
 122 void AceDAO::removeDevCapSetting(const std::string &resource)
 123 {
 124     Try {
 125         ACE_DB_UPDATE(update, AceDevCap, &AceDaoUtilities::m_databaseInterface);
 126         AceDevCap::Row row;
 127         row.Set_general_setting(preferenceToInt(PreferenceTypes::PREFERENCE_DEFAULT));
 128         update->Values(row);
 129         update->Where(
 130             Equals<AceDevCap::id_uri>(DPL::FromUTF8String(resource)));
 131         update->Execute();
 132     }
 133     Catch(DPL::DB::SqlConnection::Exception::Base) {
 134         ReThrowMsg(Exception::DatabaseError, "Failed to removeResourceSetting");
 135     }
 136 }
 137
 138
 139 void AceDAO::setWidgetDevCapSetting(const std::string &resource,
 140                                     WidgetHandle handler,
 141                                     PreferenceTypes preference)
 142 {
 143     Try {
 144         ScopedTransaction transaction(&AceDaoUtilities::m_databaseInterface);
 145         // TODO JOIN
 146         AceDevCap::Row rrow;
 147         if (!getResourceByUri(resource, rrow)) {
 148             ThrowMsg(Exception::DatabaseError, "Resource not found");
 149         }
 150
 151         ACE_DB_INSERT(insert,
 152                       AceWidgetDevCapSetting,
 153                       &AceDaoUtilities::m_databaseInterface);
 154
 155         AceWidgetDevCapSetting::Row row;
 156         row.Set_app_id(handler);
 157         int rid = rrow.Get_resource_id();
 158         row.Set_resource_id(rid);
 159         row.Set_access_value(preferenceToInt(preference));
 160         insert->Values(row);
 161         insert->Execute();
 162
 163         transaction.Commit();
 164     }
 165     Catch(DPL::DB::SqlConnection::Exception::Base) {
 166         ReThrowMsg(Exception::DatabaseError, "Failed to setUserSetting");
 167     }
 168 }
 169
 170 void AceDAO::removeWidgetDevCapSetting(const std::string &resource,
 171                                        WidgetHandle handler)
 172 {
 173     Try {
 174         ScopedTransaction transaction(&AceDaoUtilities::m_databaseInterface);
 175         AceDevCap::Row rrow;
 176         if (!getResourceByUri(resource, rrow)) {
 177             ThrowMsg(Exception::DatabaseError, "resource not found");
 178         }
 179
 180         ACE_DB_DELETE(del,
 181                       AceWidgetDevCapSetting,
 182                       &AceDaoUtilities::m_databaseInterface);
 183
 184         Equals<AceWidgetDevCapSetting::app_id> e1(handler);
 185         Equals<AceWidgetDevCapSetting::resource_id> e2(rrow.Get_resource_id());
 186         del->Where(And(e1, e2));
 187         del->Execute();
 188         transaction.Commit();
 189     }
 190     Catch(DPL::DB::SqlConnection::Exception::Base) {
 191         ReThrowMsg(Exception::DatabaseError, "Failed to clearUserSettings");
 192     }
 193 }
 194
 195
 196 void AceDAO::setPolicyResult(const BaseAttributeSet &attributes,
 197                              const ExtendedPolicyResult &exResult)
 198 {
 199     Try {
 200         ScopedTransaction transaction(&AceDaoUtilities::m_databaseInterface);
 201
 202         // TODO: this call is connected with logic.
 203         // It should be moved to PolicyEvaluator
 204         addAttributes(attributes);
 205
 206         auto attrHash = convertToHash(attributes);
 207
 208         ACE_DB_DELETE(del, AcePolicyResult, &AceDaoUtilities::m_databaseInterface)
 209         del->Where(Equals<AcePolicyResult::hash>(attrHash));
 210         del->Execute();
 211
 212         ACE_DB_INSERT(insert, AcePolicyResult, &AceDaoUtilities::m_databaseInterface);
 213         AcePolicyResult::Row row;
 214         row.Set_decision(PolicyResult::serialize(exResult.policyResult));
 215         row.Set_hash(attrHash);
 216         row.Set_rule_id(exResult.ruleId);
 217         insert->Values(row);
 218         insert->Execute();
 219
 220         transaction.Commit();
 221     }
 222     Catch(DPL::DB::SqlConnection::Exception::Base) {
 223         ReThrowMsg(Exception::DatabaseError, "Failed to addVerdict");
 224     }
 225 }
 226
 227 void AceDAO::resetDatabase(void)
 228 {
 229     Try {
 230         ScopedTransaction transaction(&AceDaoUtilities::m_databaseInterface);
 231         ACE_DB_DELETE(del1, AcePolicyResult, &AceDaoUtilities::m_databaseInterface);
 232         del1->Execute();
 233         ACE_DB_DELETE(del2, AceWidgetDevCapSetting, &AceDaoUtilities::m_databaseInterface);
 234         del2->Execute();
 235         ACE_DB_DELETE(del3, AceDevCap, &AceDaoUtilities::m_databaseInterface);
 236         del3->Execute();
 237         ACE_DB_DELETE(del4, AceSubject, &AceDaoUtilities::m_databaseInterface);
 238         del4->Execute();
 239         ACE_DB_DELETE(del5, AceAttribute, &AceDaoUtilities::m_databaseInterface);
 240         del5->Execute();
 241         ACE_DB_DELETE(del6, AcePromptDecision, &AceDaoUtilities::m_databaseInterface);
 242         del6->Execute();
 243
 244         transaction.Commit();
 245
 246         // TODO there is no such query yet in ORM.
 247         //        GlobalConnection::DataCommandAutoPtr command =
 248         //                GlobalConnectionSingleton::Instance().PrepareDataCommand(
 249         //                        "VACUUM");
 250         //        command->Step();
 251     }
 252     Catch(DPL::DB::SqlConnection::Exception::Base) {
 253         ReThrowMsg(Exception::DatabaseError, "Failed to resetDatabase");
 254     }
 255 }
 256
 257 void AceDAO::clearPolicyCache(void)
 258 {
 259     Try {
 260         ScopedTransaction transaction(&AceDaoUtilities::m_databaseInterface);
 261         ACE_DB_DELETE(del1, AcePolicyResult, &AceDaoUtilities::m_databaseInterface);
 262         del1->Execute();
 263         ACE_DB_DELETE(del2, AceAttribute, &AceDaoUtilities::m_databaseInterface);
 264         del2->Execute();
 265         ACE_DB_DELETE(del3, AcePromptDecision, &AceDaoUtilities::m_databaseInterface);
 266         del3->Execute();
 267
 268         transaction.Commit();
 269     }
 270     Catch(DPL::DB::SqlConnection::Exception::Base) {
 271         ReThrowMsg(Exception::DatabaseError, "Failed to clearPolicyCache");
 272     }
 273 }
 274
 275 void AceDAO::clearDevCapSettings()
 276 {
 277     Try {
 278         ACE_DB_UPDATE(update, AceDevCap, &AceDaoUtilities::m_databaseInterface);
 279         AceDevCap::Row row;
 280         row.Set_general_setting(-1);
 281         update->Values(row);
 282         update->Execute();
 283     }
 284     Catch(DPL::DB::SqlConnection::Exception::Base) {
 285         ReThrowMsg(Exception::DatabaseError, "Failed to clearResourceSettings");
 286     }
 287 }
 288
 289 void AceDAO::clearWidgetDevCapSettings()
 290 {
 291     Try {
 292         ACE_DB_DELETE(del, AceWidgetDevCapSetting, &AceDaoUtilities::m_databaseInterface);
 293         del->Execute();
 294     }
 295     Catch(DPL::DB::SqlConnection::Exception::Base) {
 296         ReThrowMsg(Exception::DatabaseError, "Failed to clearUserSettings");
 297     }
 298 }
 299
 300 int AceDAO::addResource(const std::string &request)
 301 {
 302     LogDebug("addResource: " << request);
 303     Try {
 304         ScopedTransaction transaction(&AceDaoUtilities::m_databaseInterface);
 305         AceDevCap::Row rrow;
 306         if (getResourceByUri(request, rrow)) {
 307             transaction.Commit();
 308             return rrow.Get_resource_id();
 309         }
 310
 311         ACE_DB_INSERT(insert, AceDevCap, &AceDaoUtilities::m_databaseInterface);
 312         AceDevCap::Row row;
 313         row.Set_id_uri(DPL::FromUTF8String(request));
 314         row.Set_general_setting(-1);
 315         insert->Values(row);
 316         int id = insert->Execute();
 317         transaction.Commit();
 318         return id;
 319     }
 320     Catch(DPL::DB::SqlConnection::Exception::Base) {
 321         ReThrowMsg(Exception::DatabaseError, "Failed in addResource");
 322     }
 323 }
 324
 325 void AceDAO::addAttributes(const BaseAttributeSet &attributes)
 326 {
 327     Try {
 328         BaseAttributeSet::const_iterator iter;
 329
 330         for (iter = attributes.begin(); iter != attributes.end(); ++iter) {
 331             ACE_DB_SELECT(select, AceAttribute, &AceDaoUtilities::m_databaseInterface);
 332             select->Where(Equals<AceAttribute::name>(DPL::FromUTF8String(
 333                 *(*iter)->getName())));
 334             std::list<AceAttribute::Row> rows = select->GetRowList();
 335             if (!rows.empty()) {
 336                 continue;
 337             }
 338
 339             ACE_DB_INSERT(insert, AceAttribute, &AceDaoUtilities::m_databaseInterface);
 340             AceAttribute::Row row;
 341             row.Set_name(DPL::FromUTF8String(*(*iter)->getName()));
 342             row.Set_type(attributeTypeToInt((*iter)->getType()));
 343             insert->Values(row);
 344             insert->Execute();
 345         }
 346     }
 347     Catch(DPL::DB::SqlConnection::Exception::Base) {
 348         ReThrowMsg(Exception::DatabaseError, "Failed in addAttributes");
 349     }
 350 }
 351
 352 void AceDAO::setRequestedDevCaps(
 353     WidgetHandle widgetHandle,
 354     const RequestedDevCapsMap &permissions)
 355 {
 356     Try {
 357         FOREACH(it, permissions) {
 358           ACE_DB_INSERT(insert, AceRequestedDevCaps,
 359                         &AceDaoUtilities::m_databaseInterface);
 360           AceRequestedDevCaps::Row row;
 361           row.Set_app_id(widgetHandle);
 362           row.Set_dev_cap(it->first);
 363           row.Set_grant_smack(it->second ? 1 : 0);
 364           insert->Values(row);
 365           insert->Execute();
 366         }
 367     } Catch(DPL::DB::SqlConnection::Exception::Base) {
 368         ReThrowMsg(Exception::DatabaseError, "Failed in setStaticDevCapPermissions");
 369     }
 370 }
 371
 372 void AceDAO::setAcceptedFeature(
 373     WidgetHandle widgetHandle,
 374     const FeatureNameVector &vector)
 375 {
 376     Try {
 377         ScopedTransaction transaction(&AceDaoUtilities::m_databaseInterface);
 378         FOREACH(it, vector) {
 379             ACE_DB_INSERT(insert, AceAcceptedFeature,
 380                           &AceDaoUtilities::m_databaseInterface);
 381             AceAcceptedFeature::Row row;
 382             row.Set_app_id(widgetHandle);
 383             row.Set_feature(*it);
 384             insert->Values(row);
 385             insert->Execute();
 386         }
 387         transaction.Commit();
 388     } Catch(DPL::DB::SqlConnection::Exception::Base) {
 389         ReThrowMsg(Exception::DatabaseError, "Failed in setAcceptedFeature");
 390     }
 391 }
 392
 393 void AceDAO::removeAcceptedFeature(
 394     WidgetHandle widgetHandle)
 395 {
 396     Try
 397     {
 398         ACE_DB_DELETE(del, AceAcceptedFeature,
 399                       &AceDaoUtilities::m_databaseInterface);
 400         del->Where(Equals<AceAcceptedFeature::app_id>(widgetHandle));
 401         del->Execute();
 402     } Catch(DPL::DB::SqlConnection::Exception::Base) {
 403         ReThrowMsg(Exception::DatabaseError, "Failed in removeAcceptedFeature");
 404     }
 405 }
 406
 407 void AceDAO::registerWidgetInfo(WidgetHandle handle,
 408                                 const WidgetRegisterInfo& info,
 409                                 const WidgetCertificateDataList& dataList)
 410 {
 411     Try
 412     {
 413         ScopedTransaction transaction(&AceDaoUtilities::m_databaseInterface);
 414
 415         ACE_DB_INSERT(insert, WidgetInfo, &AceDaoUtilities::m_databaseInterface);
 416         WidgetInfo::Row wi;
 417         wi.Set_app_id(handle);
 418         wi.Set_widget_type(static_cast<int>(info.type));
 419         wi.Set_widget_id(info.widget_id);
 420         wi.Set_widget_version(info.version);
 421         wi.Set_author_name(info.authorName);
 422         wi.Set_share_href(info.shareHref);
 423         insert->Values(wi);
 424         insert->Execute();
 425
 426         WidgetCertificateDataList::const_iterator it;
 427         for (it = dataList.begin(); it != dataList.end(); ++it)
 428         {
 429             WidgetCertificateFingerprint::Row wcf;
 430             wcf.Set_app_id(handle);
 431             wcf.Set_owner(it->owner);
 432             wcf.Set_chainid(it->chainId);
 433             wcf.Set_type(it->type);
 434             wcf.Set_md5_fingerprint(DPL::FromUTF8String(it->strMD5Fingerprint));
 435             wcf.Set_sha1_fingerprint(DPL::FromUTF8String(it->strSHA1Fingerprint));
 436             wcf.Set_common_name(it->strCommonName);
 437             ACE_DB_INSERT(insert, WidgetCertificateFingerprint, &AceDaoUtilities::m_databaseInterface);
 438             insert->Values(wcf);
 439             insert->Execute();
 440         }
 441         transaction.Commit();
 442     } Catch(DPL::DB::SqlConnection::Exception::Base) {
 443         ReThrowMsg(Exception::DatabaseError, "Failed in registerWidgetInfo");
 444     }
 445 }
 446
 447 void AceDAO::unregisterWidgetInfo(WidgetHandle handle)
 448 {
 449     if(AceDAO::isWidgetInstalled(handle)) {
 450         Try
 451         {
 452             ACE_DB_DELETE(del, WidgetInfo, &AceDaoUtilities::m_databaseInterface);
 453             del->Where(Equals<WidgetInfo::app_id>(handle));
 454             del->Execute();
 455         } Catch(DPL::DB::SqlConnection::Exception::Base) {
 456             ReThrowMsg(Exception::DatabaseError, "Failed in unregisterWidgetInfo");
 457         }
 458     }
 459 }
 460
 461 }