service/scene-manager/src/SceneMemberResourceRequestor.cpp

   1 //******************************************************************
   2 //
   3 // Copyright 2016 Samsung Electronics All Rights Reserved.
   4 //
   5 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
   6 //
   7 // Licensed under the Apache License, Version 2.0 (the "License");
   8 // you may not use this file except in compliance with the License.
   9 // You may obtain a copy of the License at
  10 //
  11 //      http://www.apache.org/licenses/LICENSE-2.0
  12 //
  13 // Unless required by applicable law or agreed to in writing, software
  14 // distributed under the License is distributed on an "AS IS" BASIS,
  15 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16 // See the License for the specific language governing permissions and
  17 // limitations under the License.
  18 //
  19 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  20
  21 #include "SceneMemberResourceRequestor.h"
  22 #include "RemoteSceneUtils.h"
  23
  24 namespace OIC
  25 {
  26     namespace Service
  27     {
  28
  29         SceneMemberResourceRequestor::SceneMemberResourceRequestor(
  30             RCSRemoteResourceObject::Ptr memberResource, const std::string &id)
  31                 : m_id{ id }, m_sceneMemberResource{ memberResource }
  32         {
  33             SCENE_CLIENT_ASSERT_NOT_NULL(memberResource);
  34         }
  35
  36         void SceneMemberResourceRequestor::requestSceneActionCreation(
  37             const std::string &sceneName, const RCSResourceAttributes &attr,
  38             InternalAddSceneActionCallback internalCB)
  39         {
  40             RCSResourceAttributes attributesToSet;
  41             std::vector< RCSResourceAttributes > vecSceneMappings;
  42
  43             for (const auto &itr : attr)
  44             {
  45                 RCSResourceAttributes sceneMappingAttrs;
  46                 sceneMappingAttrs[SCENE_KEY_SCENE] = sceneName;
  47                 sceneMappingAttrs[SCENE_KEY_MEMBERPROPERTY] = itr.key();
  48                 sceneMappingAttrs[SCENE_KEY_MEMBERVALUE] = itr.value();
  49
  50                 vecSceneMappings.push_back(sceneMappingAttrs);
  51             }
  52
  53             attributesToSet[SCENE_KEY_SCENEMAPPINGS] = vecSceneMappings;
  54
  55             RCSRemoteResourceObject::RemoteAttributesSetCallback setRequestCB
  56                 = std::bind(&SceneMemberResourceRequestor::onSceneActionCreated,
  57                             std::placeholders::_1, std::placeholders::_2,
  58                             sceneName, attr, std::move(internalCB),
  59                             SceneMemberResourceRequestor::wPtr(shared_from_this()));
  60
  61             m_sceneMemberResource->setRemoteAttributes(
  62                 std::move(attributesToSet), std::move(setRequestCB));
  63         }
  64
  65         void SceneMemberResourceRequestor::requestGet(
  66             const std::string &ifType, RCSRemoteResourceObject::GetCallback cb)
  67         {
  68             RCSQueryParams params;
  69             params.setResourceInterface(ifType);
  70
  71             m_sceneMemberResource->get(params, cb);
  72         }
  73
  74         void SceneMemberResourceRequestor::setRemoteResourceObject(
  75             RCSRemoteResourceObject::Ptr target)
  76         {
  77             m_remoteResource = target;
  78         }
  79
  80         RCSRemoteResourceObject::Ptr SceneMemberResourceRequestor::getRemoteResourceObject() const
  81         {
  82             return m_remoteResource;
  83         }
  84
  85         void SceneMemberResourceRequestor::onSceneActionCreated(
  86             const RCSResourceAttributes &attrs, int eCode, const std::string &sceneName,
  87             const RCSResourceAttributes &requestedAttrs, const InternalAddSceneActionCallback &cb,
  88             SceneMemberResourceRequestor::wPtr ptr)
  89         {
  90             SceneMemberResourceRequestor::Ptr member = ptr.lock();
  91
  92             if (member)
  93             {
  94                 member->onSceneActionCreated_impl(
  95                     std::move(attrs), eCode, sceneName, std::move(requestedAttrs), std::move(cb));
  96             }
  97         }
  98
  99         void SceneMemberResourceRequestor::onSceneActionCreated_impl(
 100             const RCSResourceAttributes &attrs, int eCode, const std::string &sceneName,
 101             const RCSResourceAttributes &requestedAttrs,
 102             const InternalAddSceneActionCallback &internalCB)
 103         {
 104             // TODO error code
 105             int result = SCENE_CLIENT_BADREQUEST;
 106
 107             if (eCode == OC_STACK_OK)
 108             {
 109                 try
 110                 {
 111                     auto mappings
 112                         = attrs.at(SCENE_KEY_SCENEMAPPINGS).get
 113                           < std::vector< RCSResourceAttributes > >();
 114
 115                     // check if the SCENE_MAPPINGS contains requested scene action
 116                     int uncreatedActionNum = requestedAttrs.size();
 117                     for (const auto &itr : mappings)
 118                     {
 119                         if (itr.at(SCENE_KEY_SCENE).get< std::string >().compare(sceneName) == 0)
 120                         {
 121                             std::string key
 122                                 = itr.at(SCENE_KEY_MEMBERPROPERTY).get< std::string >();
 123
 124                             if (requestedAttrs.contains(key)
 125                                 && requestedAttrs.at(key) == itr.at(SCENE_KEY_MEMBERVALUE))
 126                             {
 127                                 uncreatedActionNum--;
 128                             }
 129                         }
 130
 131                         if (uncreatedActionNum == 0)
 132                         {
 133                             result = SCENE_RESPONSE_SUCCESS;
 134                             break;
 135                         }
 136                     }
 137                 }
 138                 catch (const std::exception &e)
 139                 {
 140                     SCENE_CLIENT_PRINT_LOG(e.what());
 141                     result = SCENE_SERVER_INTERNALSERVERERROR;
 142                 }
 143             }
 144
 145             internalCB(result);
 146         }
 147
 148     }
 149 }