1 //******************************************************************
3 // Copyright 2016 Samsung Electronics All Rights Reserved.
5 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
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
11 // http://www.apache.org/licenses/LICENSE-2.0
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.
19 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
21 #include "SceneCollectionResource.h"
25 #include "RCSRequest.h"
26 #include "RCSSeparateResponse.h"
34 std::atomic_int g_numOfSceneCollection(0);
37 SceneCollectionResource::SceneCollectionResource()
38 : m_uri(PREFIX_SCENE_COLLECTION_URI + "/" + std::to_string(g_numOfSceneCollection++)),
39 m_address(), m_sceneCollectionResourceObject(), m_requestHandler()
41 m_sceneCollectionResourceObject = createResourceObject();
44 SceneCollectionResource::Ptr SceneCollectionResource::create()
46 SceneCollectionResource::Ptr sceneCollectionResource(new SceneCollectionResource());
48 sceneCollectionResource->setDefaultAttributes();
50 sceneCollectionResource->initSetRequestHandler();
52 sceneCollectionResource->m_address = SceneUtils::getNetAddress();
54 return sceneCollectionResource;
57 SceneCollectionResource::Ptr SceneCollectionResource::create(
58 const RCSResourceAttributes & inputAttr)
60 auto sceneCollectionResource = SceneCollectionResource::create();
61 if (inputAttr.contains(SCENE_KEY_NAME))
63 sceneCollectionResource->setName(inputAttr.at(SCENE_KEY_NAME).get<std::string>());
66 if (inputAttr.contains(SCENE_KEY_SCENEVALUES))
68 auto sceneValues = inputAttr.at(SCENE_KEY_SCENEVALUES).
69 get<std::vector<std::string>>();
70 sceneCollectionResource->getRCSResourceObject()->setAttribute(
71 SCENE_KEY_SCENEVALUES, sceneValues);
74 if (inputAttr.contains(SCENE_KEY_LAST_SCENE))
76 auto sceneValues = inputAttr.at(SCENE_KEY_LAST_SCENE).get<std::string>();
77 sceneCollectionResource->getRCSResourceObject()->setAttribute(
78 SCENE_KEY_LAST_SCENE, sceneValues);
81 return sceneCollectionResource;
84 RCSResourceObject::Ptr SceneCollectionResource::createResourceObject()
86 return RCSResourceObject::Builder(
87 m_uri, SCENE_COLLECTION_RT, BASELINE_IF).
88 addInterface(OC::BATCH_INTERFACE).
89 addInterface(LINK_BATCH).
90 setDiscoverable(true).setObservable(false).build();
93 void SceneCollectionResource::setDefaultAttributes()
95 m_sceneCollectionResourceObject->setAttribute(SCENE_KEY_LAST_SCENE, std::string());
96 m_sceneCollectionResourceObject->setAttribute(SCENE_KEY_NAME, std::string());
97 m_sceneCollectionResourceObject->setAttribute(
98 SCENE_KEY_ID, SceneUtils::OICGenerateUUIDStr());
99 m_sceneCollectionResourceObject->setAttribute(SCENE_KEY_RTS, SCENE_MEMBER_RT);
100 m_sceneCollectionResourceObject->setAttribute(
101 SCENE_KEY_SCENEVALUES, std::vector<std::string>());
102 m_sceneCollectionResourceObject->setAttribute(SCENE_KEY_URI, m_uri);
105 void SceneCollectionResource::initSetRequestHandler()
107 m_requestHandler.m_owner
108 = std::weak_ptr<SceneCollectionResource>(shared_from_this());
110 m_sceneCollectionResourceObject->setSetRequestHandler(std::bind(
111 &SceneCollectionResource::SceneCollectionRequestHandler::onSetRequest,
112 m_requestHandler, std::placeholders::_1, std::placeholders::_2));
115 void SceneCollectionResource::addScene(const std::string & newScene)
117 addScene(std::string(newScene));
120 void SceneCollectionResource::addScene(std::string && newScene)
122 auto sceneValues = m_sceneCollectionResourceObject->getAttributeValue(
123 SCENE_KEY_SCENEVALUES).get< std::vector< std::string > >();
126 = std::find(sceneValues.begin(), sceneValues.end(), newScene);
127 if (foundScene == sceneValues.end())
129 sceneValues.push_back(std::move(newScene));
131 m_sceneCollectionResourceObject->setAttribute(SCENE_KEY_SCENEVALUES, sceneValues);
135 throw RCSInvalidParameterException("Scene name is duplicate!");
139 void SceneCollectionResource::addSceneMember(
140 SceneMemberResource::Ptr newMember)
142 std::lock_guard<std::mutex> memberlock(m_sceneMemberLock);
144 auto foundmember = std::find_if(m_sceneMembers.begin(), m_sceneMembers.end(),
145 [& newMember](const SceneMemberResource::Ptr & ptr) -> bool
147 return ptr->getTargetUri() == newMember->getTargetUri();
150 if (foundmember != m_sceneMembers.end())
152 throw RCSBadRequestException("It is already registered member.");
155 m_sceneMembers.push_back(newMember);
156 m_sceneCollectionResourceObject->bindResource(newMember->getRCSResourceObject());
159 void SceneCollectionResource::execute(std::string && sceneName)
161 execute(std::move(sceneName), nullptr);
164 void SceneCollectionResource::execute(const std::string & sceneName)
166 execute(std::string(sceneName));
169 void SceneCollectionResource::execute(
170 const std::string & sceneName, SceneExecuteCallback executeCB)
172 execute(std::string(sceneName), std::move(executeCB));
175 void SceneCollectionResource::execute(
176 std::string && sceneName, SceneExecuteCallback executeCB)
178 auto sceneValues = m_sceneCollectionResourceObject->getAttributeValue(
179 SCENE_KEY_SCENEVALUES).get< std::vector< std::string > >();
182 = std::find(sceneValues.begin(), sceneValues.end(), sceneName);
183 if (foundSceneValue == sceneValues.end() && executeCB && !m_sceneMembers.size())
185 std::thread(std::move(executeCB), SCENE_CLIENT_BADREQUEST).detach();
189 m_sceneCollectionResourceObject->setAttribute(
190 SCENE_KEY_LAST_SCENE, sceneName);
193 std::lock_guard<std::mutex> memberlock(m_sceneMemberLock);
195 = SceneExecuteResponseHandler::createExecuteHandler(
196 shared_from_this(), std::move(executeCB));
197 for (auto & it : m_sceneMembers)
199 it->execute(std::move(sceneName), std::bind(
200 &SceneExecuteResponseHandler::onResponse, executeHandler,
201 std::placeholders::_1, std::placeholders::_2));
206 std::string SceneCollectionResource::getId() const
208 return m_sceneCollectionResourceObject->getAttributeValue(
209 SCENE_KEY_ID).get<std::string>();
212 std::string SceneCollectionResource::getUri() const
217 std::string SceneCollectionResource::getAddress() const
222 std::vector<std::string> SceneCollectionResource::getSceneValues() const
224 return m_sceneCollectionResourceObject->getAttributeValue(
225 SCENE_KEY_SCENEVALUES).get<std::vector<std::string>>();
228 std::vector<SceneMemberResource::Ptr> SceneCollectionResource::getSceneMembers() const
230 std::lock_guard<std::mutex> memberlock(m_sceneMemberLock);
231 return m_sceneMembers;
234 std::vector<SceneMemberResource::Ptr> SceneCollectionResource::findSceneMembers(
235 const std::string & sceneName) const
237 std::lock_guard<std::mutex> memberlock(m_sceneMemberLock);
238 std::vector<SceneMemberResource::Ptr> retMembers;
239 std::for_each(m_sceneMembers.begin(), m_sceneMembers.end(),
240 [& retMembers, & sceneName](SceneMemberResource::Ptr pMember)
242 if(pMember->hasSceneValue(sceneName))
244 retMembers.push_back(pMember);
250 RCSResourceObject::Ptr SceneCollectionResource::getRCSResourceObject() const
252 return m_sceneCollectionResourceObject;
255 void SceneCollectionResource::setName(std::string && sceneCollectionName)
257 m_sceneCollectionResourceObject->setAttribute(
258 SCENE_KEY_NAME, std::move(sceneCollectionName));
261 void SceneCollectionResource::setName(const std::string & sceneCollectionName)
263 setName(std::string(sceneCollectionName));
266 std::string SceneCollectionResource::getName() const
268 return m_sceneCollectionResourceObject->getAttributeValue(
269 SCENE_KEY_NAME).get<std::string>();
272 RCSSetResponse SceneCollectionResource::SceneCollectionRequestHandler::
273 onSetRequest(const RCSRequest & request, RCSResourceAttributes & attributes)
275 if (request.getInterface() == LINK_BATCH)
277 return createSceneMemberRequest(request, attributes);
280 if (attributes.contains(SCENE_KEY_SCENEVALUES))
282 return addSceneRequest(request, attributes);
285 if (attributes.contains(SCENE_KEY_LAST_SCENE))
287 return executeSceneRequest(request, attributes);
290 if (attributes.contains(SCENE_KEY_NAME))
292 return setSceneCollectionName(request, attributes);
295 return RCSSetResponse::create(attributes, (int)SCENE_CLIENT_BADREQUEST).
296 setAcceptanceMethod(RCSSetResponse::AcceptanceMethod::IGNORE);
299 RCSSetResponse SceneCollectionResource::SceneCollectionRequestHandler::
300 addSceneRequest(const RCSRequest & /*request*/, RCSResourceAttributes & attributes)
302 SceneCollectionResource::Ptr ptr = m_owner.lock();
305 return RCSSetResponse::create(attributes, SCENE_CLIENT_BADREQUEST).
306 setAcceptanceMethod(RCSSetResponse::AcceptanceMethod::IGNORE);
309 auto values = attributes.at(SCENE_KEY_SCENEVALUES).get<std::vector<std::string>>();
311 auto sizeofValues = values.size();
312 unsigned int sameSize = 0;
313 std::for_each(values.begin(), values.end(),
314 [& ptr, & sameSize](const std::string & value)
318 ptr->addScene(value);
325 int eCode = SCENE_RESPONSE_SUCCESS;
326 if (sameSize == sizeofValues)
328 eCode = SCENE_CLIENT_BADREQUEST;
331 return RCSSetResponse::create(attributes, eCode).
332 setAcceptanceMethod(RCSSetResponse::AcceptanceMethod::IGNORE);
335 RCSSetResponse SceneCollectionResource::SceneCollectionRequestHandler::
336 executeSceneRequest(const RCSRequest & request, RCSResourceAttributes & attributes)
338 SceneCollectionResource::Ptr ptr = m_owner.lock();
341 return RCSSetResponse::create(attributes, SCENE_CLIENT_BADREQUEST).
342 setAcceptanceMethod(RCSSetResponse::AcceptanceMethod::IGNORE);
345 auto requestKey = attributes.at(SCENE_KEY_LAST_SCENE).get<std::string>();
347 RCSRequest req(request.getResourceObject().lock(), request.getOCRequest());
349 ptr->execute(std::string(requestKey),
352 // TODO need to set error code.
353 // and need to set specific attr' but this attr not to be apply to RCSResourceObject.
354 RCSSeparateResponse(req).set();
357 return RCSSetResponse::separate();
360 RCSSetResponse SceneCollectionResource::SceneCollectionRequestHandler::
361 createSceneMemberRequest(const RCSRequest & /*request*/, RCSResourceAttributes & attributes)
363 int eCode = SCENE_CLIENT_BADREQUEST;
364 SceneCollectionResource::Ptr ptr = m_owner.lock();
367 return RCSSetResponse::create(attributes, eCode).
368 setAcceptanceMethod(RCSSetResponse::AcceptanceMethod::IGNORE);
371 RCSResourceAttributes responseAtt(attributes);
372 if (attributes.contains(SCENE_KEY_PAYLOAD_LINK))
374 auto linkAtt = attributes.at(SCENE_KEY_PAYLOAD_LINK).get<RCSResourceAttributes>();
375 if (linkAtt.contains(SCENE_KEY_HREF) &&
376 linkAtt.contains(SCENE_KEY_RT) && linkAtt.contains(SCENE_KEY_IF))
378 auto memberObj = SceneMemberResource::createSceneMemberResource(linkAtt);
381 ptr->addSceneMember(memberObj);
385 return RCSSetResponse::create(responseAtt, eCode).
386 setAcceptanceMethod(RCSSetResponse::AcceptanceMethod::IGNORE);
388 eCode = SCENE_RESPONSE_SUCCESS;
390 if (attributes.contains(SCENE_KEY_SCENEMAPPINGS))
392 addMemberInfoFromRemote(memberObj, attributes.at(
393 SCENE_KEY_SCENEMAPPINGS).get<std::vector<RCSResourceAttributes>>());
395 responseAtt[SCENE_KEY_ID] = RCSResourceAttributes::Value(memberObj->getId());
396 responseAtt[SCENE_KEY_CREATEDLINK]
397 = RCSResourceAttributes::Value(memberObj->getFullUri());
401 return RCSSetResponse::create(responseAtt, eCode).
402 setAcceptanceMethod(RCSSetResponse::AcceptanceMethod::IGNORE);
406 SceneCollectionResource::SceneCollectionRequestHandler::setSceneCollectionName(
407 const RCSRequest & /*request*/, RCSResourceAttributes & attr)
409 int eCode = SCENE_CLIENT_BADREQUEST;
410 SceneCollectionResource::Ptr ptr = m_owner.lock();
413 eCode = SCENE_RESPONSE_SUCCESS;
414 ptr->setName(attr.at(SCENE_KEY_NAME).get<std::string>());
417 return RCSSetResponse::create(attr, eCode).
418 setAcceptanceMethod(RCSSetResponse::AcceptanceMethod::IGNORE);
421 void SceneCollectionResource::SceneCollectionRequestHandler::addMemberInfoFromRemote(
422 SceneMemberResource::Ptr memberObj, std::vector<RCSResourceAttributes> mInfo)
424 std::for_each(mInfo.begin(), mInfo.end(),
425 [& memberObj](const RCSResourceAttributes & att)
427 memberObj->addMappingInfo(SceneMemberResource::MappingInfo::create(att));
431 void SceneCollectionResource::SceneExecuteResponseHandler::
432 onResponse(const RCSResourceAttributes & /*attributes*/, int errorCode)
435 if (errorCode != SCENE_RESPONSE_SUCCESS && m_errorCode != errorCode)
437 m_errorCode = errorCode;
439 if (m_responseMembers == m_numOfMembers)
445 SceneCollectionResource::SceneExecuteResponseHandler::Ptr
446 SceneCollectionResource::SceneExecuteResponseHandler::createExecuteHandler(
447 const SceneCollectionResource::Ptr ptr, SceneExecuteCallback executeCB)
449 auto executeHandler = std::make_shared<SceneExecuteResponseHandler>();
451 executeHandler->m_numOfMembers = ptr->m_sceneMembers.size();
452 executeHandler->m_responseMembers = 0;
454 executeHandler->m_cb =
455 [executeCB](int eCode)
457 std::thread(std::move(executeCB), eCode).detach();
460 executeHandler->m_owner
461 = std::weak_ptr<SceneCollectionResource>(ptr);
462 executeHandler->m_errorCode = SCENE_RESPONSE_SUCCESS;
464 return executeHandler;