service/scene-manager/src/SceneListResource.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 "SceneListResource.h"
  22
  23 #include "RCSRequest.h"
  24 #include "OCApi.h"
  25
  26 namespace OIC
  27 {
  28     namespace Service
  29     {
  30         SceneListResource::SceneListResource()
  31         : m_sceneListObj(createResourceObject())
  32         {
  33             m_sceneListObj->setAttribute(SCENE_KEY_NAME, SCENE_LIST_DEFAULT_NAME);
  34             m_sceneListObj->setAttribute(SCENE_KEY_RTS, SCENE_LIST_RT);
  35
  36             m_sceneListObj->setSetRequestHandler(&SceneListRequestHandler::onSetRequest);
  37             m_sceneListObj->setGetRequestHandler(&SceneListRequestHandler::onGetRequest);
  38         }
  39
  40         SceneListResource * SceneListResource::getInstance()
  41         {
  42             static SceneListResource instance;
  43             return & instance;
  44         }
  45
  46         RCSResourceObject::Ptr SceneListResource::createResourceObject()
  47         {
  48             return RCSResourceObject::Builder(
  49                     SCENE_LIST_URI, SCENE_LIST_RT, BASELINE_IF).
  50                             addInterface(OC::BATCH_INTERFACE).
  51                             addInterface(LINK_BATCH).
  52                             setDiscoverable(true).setObservable(false).build();
  53         }
  54
  55         void SceneListResource::addSceneCollectionResource(
  56                 SceneCollectionResource::Ptr newObject)
  57         {
  58             std::lock_guard<std::mutex> collectionlock(m_sceneCollectionLock);
  59             m_sceneCollections.push_back(newObject);
  60             m_sceneListObj->bindResource(newObject->getRCSResourceObject());
  61         }
  62
  63         std::string SceneListResource::getName() const
  64         {
  65             return m_sceneListObj->getAttributeValue(SCENE_KEY_NAME).get<std::string>();
  66         }
  67
  68         void SceneListResource::setName(std::string && newName)
  69         {
  70             m_sceneListObj->setAttribute(SCENE_KEY_NAME, std::move(newName));
  71         }
  72
  73         void SceneListResource::setName(const std::string & newName)
  74         {
  75             setName(std::string(newName));
  76         }
  77
  78         std::vector<SceneCollectionResource::Ptr> SceneListResource::getSceneCollections() const
  79         {
  80             std::lock_guard<std::mutex> collectionlock(m_sceneCollectionLock);
  81             return m_sceneCollections;
  82         }
  83
  84         RCSResourceObject::Ptr SceneListResource::getResourceObject() const
  85         {
  86             return m_sceneListObj;
  87         }
  88
  89         std::vector<RCSResourceAttributes> SceneListResource::getChildrenAttributes() const
  90         {
  91             std::vector<RCSResourceAttributes> childrenAttrs;
  92
  93             auto sceneCollections = getSceneCollections();
  94
  95             std::for_each(sceneCollections.begin(), sceneCollections.end(),
  96                     [& childrenAttrs](const SceneCollectionResource::Ptr & pCollection)
  97                     {
  98                         RCSResourceAttributes collectionAttr;
  99                         {
 100                             RCSResourceObject::LockGuard guard(
 101                                     pCollection->getRCSResourceObject());
 102                             collectionAttr = pCollection->getRCSResourceObject()->getAttributes();
 103                         }
 104
 105                         auto sceneMembers = pCollection->getSceneMembers();
 106                         std::vector<RCSResourceAttributes> membersAttrs;
 107
 108                         std::for_each(sceneMembers.begin(), sceneMembers.end(),
 109                                 [& membersAttrs](const SceneMemberResource::Ptr & pMember)
 110                                 {
 111                                     RCSResourceObject::LockGuard guard(pMember->getRCSResourceObject());
 112                                     membersAttrs.push_back(pMember->getRCSResourceObject()->getAttributes());
 113                                 });
 114
 115                         if (membersAttrs.size())
 116                         {
 117                             collectionAttr[SCENE_KEY_CHILD] = membersAttrs;
 118                         }
 119
 120                         childrenAttrs.push_back(collectionAttr);
 121                     });
 122
 123             return childrenAttrs;
 124         }
 125
 126         RCSSetResponse SceneListResource::SceneListRequestHandler::onSetRequest(
 127                 const RCSRequest & request, RCSResourceAttributes & attributes)
 128         {
 129             RCSResourceAttributes responseAttr;
 130             int eCode = SCENE_CLIENT_BADREQUEST;
 131
 132             if(request.getInterface() == LINK_BATCH)
 133             {
 134                 auto newObject
 135                     = SceneCollectionResource::create(attributes);
 136
 137                 SceneListResource::getInstance()->addSceneCollectionResource(newObject);
 138
 139                 auto responseAtt = attributes;
 140                 responseAtt[SCENE_KEY_NAME] = RCSResourceAttributes::Value(newObject->getName());
 141                 responseAtt[SCENE_KEY_ID] = RCSResourceAttributes::Value(newObject->getId());
 142
 143                 auto uri = COAP_TAG + newObject->getAddress() + newObject->getUri();
 144                 responseAtt[SCENE_KEY_PAYLOAD_LINK]
 145                             = RCSResourceAttributes::Value(uri);
 146
 147                 responseAttr = responseAtt;
 148                 eCode = SCENE_RESPONSE_SUCCESS;
 149             }
 150
 151             else if (attributes.contains(SCENE_KEY_NAME))
 152             {
 153                 SceneListResource::getInstance()->setName(
 154                         attributes.at(SCENE_KEY_NAME).get<std::string>());
 155
 156                 responseAttr = attributes;
 157                 eCode = SCENE_RESPONSE_SUCCESS;
 158             }
 159             else
 160             {
 161                 responseAttr = attributes;
 162                 eCode = SCENE_CLIENT_BADREQUEST;
 163             }
 164
 165             return RCSSetResponse::create(responseAttr, eCode).
 166                     setAcceptanceMethod(RCSSetResponse::AcceptanceMethod::IGNORE);
 167         }
 168
 169         RCSGetResponse SceneListResource::SceneListRequestHandler::onGetRequest(
 170                 const RCSRequest & request, RCSResourceAttributes & /*attributes*/)
 171         {
 172
 173             if(request.getInterface() != OC::DEFAULT_INTERFACE)
 174             {
 175                 return RCSGetResponse::defaultAction();
 176             }
 177
 178             auto childrenAttrs = SceneListResource::getInstance()->getChildrenAttributes();
 179
 180             RCSResourceAttributes retAttr;
 181
 182             {
 183                 RCSResourceObject::LockGuard lock(
 184                         SceneListResource::getInstance()->getResourceObject());
 185                 retAttr = SceneListResource::getInstance()->getResourceObject()->getAttributes();
 186             }
 187
 188             if (childrenAttrs.size())
 189             {
 190                 retAttr[SCENE_KEY_CHILD] = childrenAttrs;
 191             }
 192
 193             return RCSGetResponse::create(retAttr);
 194         }
 195
 196     }
 197 }