service/notification/cpp-wrapper/unittest/NSProviderServiceSimulator.h

   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 #ifndef _NS_PROVIDER_SERVICE_SIMULATOR_H_
  22 #define _NS_PROVIDER_SERVICE_SIMULATOR_H_
  23
  24 #include <iostream>
  25 #include <memory>
  26
  27 #include "OCPlatform.h"
  28 #include "OCApi.h"
  29 #include "OCResourceResponse.h"
  30
  31 namespace
  32 {
  33     enum class requestType
  34     {
  35         NS_NOTIFICATION,
  36         NS_MESSAGE,
  37         NS_SYNC,
  38         NS_TOPIC,
  39     };
  40     enum class messageType
  41     {
  42         NS_ALLOW = 1,
  43         NS_DENY,
  44         NS_TOPIC,
  45     };
  46 }
  47
  48 class NSProviderSimulator
  49 {
  50     public:
  51         enum class TopicAllowState
  52         {
  53             DENY,
  54             ALLOW
  55         };
  56         typedef std::pair<std::string, TopicAllowState> NS_TopicState;
  57         typedef std::map<std::string, TopicAllowState> NS_TopicStateList;
  58
  59         typedef std::list<std::string> NS_TopicList;
  60     private:
  61         OCResourceHandle m_notificationHandle;
  62         OCResourceHandle m_messageHandle;
  63         OCResourceHandle m_syncHandle;
  64         OCResourceHandle m_topicHandle;
  65         OC::OCRepresentation m_syncRep;
  66         OC::OCRepresentation m_messageRep;
  67         int m_accepter;
  68
  69         std::string m_notificationUri;
  70         std::string m_messageUri;
  71         std::string m_syncUri;
  72         std::string m_topicUri;
  73         NS_TopicList m_topicList;
  74         NS_TopicStateList m_allowedTopicList;
  75
  76         OC::ObservationIds m_syncObservers;
  77
  78     public:
  79         NSProviderSimulator()
  80             : m_notificationHandle(), m_messageHandle(), m_syncHandle(), m_topicHandle(),
  81               m_syncRep(), m_messageRep(), m_accepter(0),
  82               m_notificationUri(std::string("/notification")),
  83               m_messageUri(std::string("/message")),
  84               m_syncUri(std::string("/sync")),
  85               m_topicUri(std::string("/topic")),
  86               m_topicList(),
  87               m_allowedTopicList(),
  88               m_syncObservers()
  89         {
  90
  91         };
  92
  93         ~NSProviderSimulator() = default;
  94
  95         NSProviderSimulator(const NSProviderSimulator &) = delete;
  96         NSProviderSimulator &operator = (const NSProviderSimulator &) = delete;
  97
  98         NSProviderSimulator(NSProviderSimulator &&) = delete;
  99         NSProviderSimulator &operator = (NSProviderSimulator &&) = delete;
 100
 101     private:
 102         std::shared_ptr<OC::OCResourceResponse> getResponse(
 103             std::shared_ptr< OC::OCResourceRequest > requests, requestType type)
 104         {
 105             auto response = std::make_shared<OC::OCResourceResponse>();
 106             response->setRequestHandle(requests->getRequestHandle());
 107             response->setResourceHandle(requests->getResourceHandle());
 108
 109             int requestFlag = requests->getRequestHandlerFlag();
 110             if (requestFlag == OC::RequestHandlerFlag::RequestFlag)
 111             {
 112                 std::string request = requests->getRequestType();
 113
 114             response->setErrorCode(200);
 115                 response->setResponseResult(OC_EH_OK);
 116
 117                 if (request == "GET")
 118                 {
 119                     OC::OCRepresentation rep;
 120
 121                     if (type == requestType::NS_NOTIFICATION)
 122                     {
 123                         std::string msgUri = m_notificationUri + m_messageUri;
 124                         std::string syncUri = m_notificationUri + m_syncUri;
 125                         std::string topicUri = m_notificationUri + m_topicUri;
 126                         std::string providerId = "123456789012345678901234567890123456";
 127                         rep.setValue("x.org.iotivity.ns.subcontrollability", m_accepter);
 128                         rep.setValue("x.org.iotivity.ns.messageuri", msgUri);
 129                         rep.setValue("x.org.iotivity.ns.syncuri", syncUri);
 130                         rep.setValue("x.org.iotivity.ns.topicuri", topicUri);
 131                         rep.setValue("x.org.iotivity.ns.providerid", providerId);
 132                     }
 133                     else if (type == requestType::NS_SYNC)
 134                     {
 135                         rep = m_syncRep;
 136                     }
 137                     else if (type == requestType::NS_MESSAGE)
 138                     {
 139                         rep = m_messageRep;
 140                     }
 141                     else if (type == requestType::NS_TOPIC)
 142                     {
 143                         if (m_allowedTopicList.empty())
 144                         {
 145                             std::for_each (m_topicList.begin(), m_topicList.end(),
 146                                            [this](const std::string & topic)
 147                             {
 148                                 m_allowedTopicList.insert(
 149                                     std::make_pair<std::string, TopicAllowState>(
 150                                         std::string(topic), TopicAllowState::DENY));
 151                             }
 152                                           );
 153                         }
 154
 155                         std::vector<OC::OCRepresentation> topicArr;
 156
 157                         std::for_each (m_allowedTopicList.begin(), m_allowedTopicList.end(),
 158                                        [& topicArr](const NS_TopicState & topicState)
 159                         {
 160                             OC::OCRepresentation topic;
 161                             topic.setValue("x.org.iotivity.ns.topicname", topicState.first);
 162                             topic.setValue("x.org.iotivity.ns.topicstate", (int) topicState.second);
 163                             topicArr.push_back(topic);
 164                         }
 165                                       );
 166
 167                         rep.setValue<std::vector<OC::OCRepresentation>>
 168                                 ("x.org.iotivity.ns.topiclist", topicArr);
 169                     }
 170                     else
 171                     {
 172                         return NULL;
 173                     }
 174
 175                     response->setResourceRepresentation(rep);
 176                     return response;
 177                 }
 178
 179                 else if (request == "POST")
 180                 {
 181                     if (type == requestType::NS_SYNC)
 182                     {
 183                         m_syncRep = requests->getResourceRepresentation();
 184
 185                         std::cout << "Receive POST for Sync" << std::endl;
 186                         std::cout << "provider Id : " << m_syncRep.getValueToString("x.org.iotivity.ns.providerid") << std::endl;
 187                         std::cout << "Sync State : " << m_syncRep.getValueToString("x.org.iotivity.ns.state") << std::endl;
 188
 189                         response->setResourceRepresentation(m_syncRep);
 190
 191                         OC::OCPlatform::notifyAllObservers(m_syncHandle);
 192
 193                         return response;
 194                     }
 195                     else if (type == requestType::NS_TOPIC)
 196                     {
 197                         auto receivePayload =
 198                             requests->getResourceRepresentation()
 199                             .getValue<std::vector<OC::OCRepresentation>>("x.org.iotivity.ns.topiclist");
 200
 201                         std::for_each (receivePayload.begin(), receivePayload.end(),
 202                                        [this](const OC::OCRepresentation & rep)
 203                         {
 204                             auto tmp = m_allowedTopicList.find(rep.getValueToString("x.org.iotivity.ns.topicname"));
 205                             if (tmp != m_allowedTopicList.end())
 206                             {
 207                                 tmp->second = (TopicAllowState) rep.getValue<int>("x.org.iotivity.ns.topicstate");
 208                             }
 209                         }
 210                                       );
 211                     }
 212                 }
 213             }
 214
 215             return NULL;
 216         }
 217
 218         void setObserver(std::shared_ptr< OC::OCResourceRequest > requests, requestType type)
 219         {
 220             if (type == requestType::NS_SYNC)
 221             {
 222                 OC::ObservationInfo observationInfo = requests->getObservationInfo();
 223                 if (OC::ObserveAction::ObserveRegister == observationInfo.action)
 224                 {
 225                     m_syncObservers.push_back(observationInfo.obsId);
 226                 }
 227                 else if (OC::ObserveAction::ObserveUnregister == observationInfo.action)
 228                 {
 229                     m_syncObservers.erase(std::remove(
 230                                               m_syncObservers.begin(), m_syncObservers.end(),
 231                                               observationInfo.obsId), m_syncObservers.end());
 232                 }
 233             }
 234             else if (type == requestType::NS_MESSAGE)
 235             {
 236                 OC::OCRepresentation rep;
 237                 std::string providerId = "123456789012345678901234567890123456";
 238                 rep.setValue<int>("x.org.iotivity.ns.messageid", (int)messageType::NS_ALLOW);
 239                 rep.setValue("x.org.iotivity.ns.providerid", providerId);
 240
 241                 auto response = std::make_shared<OC::OCResourceResponse>();
 242                 response->setRequestHandle(requests->getRequestHandle());
 243                 response->setResourceHandle(requests->getResourceHandle());
 244             response->setErrorCode(200);
 245                 response->setResponseResult(OC_EH_OK);
 246                 response->setResourceRepresentation(rep);
 247
 248                 OC::ObservationIds ids;
 249                 ids.push_back(requests->getObservationInfo().obsId);
 250
 251                 OC::OCPlatform::notifyListOfObservers(m_messageHandle, ids, response);
 252             }
 253         }
 254
 255         OCEntityHandlerResult entityHandler(
 256             std::shared_ptr< OC::OCResourceRequest > request, requestType type)
 257         {
 258             if (!request)
 259             {
 260                 return OC_EH_ERROR;
 261             }
 262
 263             std::cout << "Provider : Income request : " << request->getRequestHandlerFlag() << std::endl;
 264             if ((request->getRequestHandlerFlag() & OC::RequestHandlerFlag::ObserverFlag))
 265             {
 266                 std::cout << "Provider : Income Observe : " << std::endl;
 267                 setObserver(request, type);
 268                 return OC_EH_OK;
 269             }
 270
 271             auto pResponse = getResponse(request, type);
 272             if (pResponse == nullptr)
 273             {
 274                 return OC_EH_ERROR;
 275             }
 276
 277             try
 278             {
 279                 OC::OCPlatform::sendResponse(pResponse);
 280             }
 281             catch (std::exception &e)
 282             {
 283                 return OC_EH_ERROR;
 284             }
 285
 286             return OC_EH_OK;
 287         }
 288
 289     public:
 290
 291         void setAccepter(int accepter)
 292         {
 293             m_accepter = accepter;
 294         }
 295
 296         void notifyMessage()
 297         {
 298             std::cout << "Provider : notify~" << std::endl;
 299             OC::OCPlatform::notifyAllObservers(m_messageHandle);
 300         }
 301
 302         void notifyMessage(const uint64_t &id, const std::string &title, const std::string &content)
 303         {
 304             setMessage(id, title, content);
 305             notifyMessage();
 306         }
 307
 308         void sendRead(const uint64_t &id)
 309         {
 310             std::string providerId = "123456789012345678901234567890123456";
 311             m_syncRep.setValue<int>("x.org.iotivity.ns.messageid", id);
 312             m_syncRep.setValue("x.org.iotivity.ns.state", (int)1);
 313             m_syncRep.setValue("x.org.iotivity.ns.providerid", providerId);
 314             OC::OCPlatform::notifyAllObservers(m_syncHandle);
 315         }
 316         void sendDismiss(const uint64_t &id)
 317         {
 318             std::string providerId = "123456789012345678901234567890123456";
 319             m_syncRep.setValue<int>("x.org.iotivity.ns.messageid", id);
 320             m_syncRep.setValue("x.org.iotivity.ns.state", (int)2);
 321             m_syncRep.setValue("x.org.iotivity.ns.providerid", providerId);
 322             OC::OCPlatform::notifyAllObservers(m_syncHandle);
 323         }
 324
 325         void setMessage(const uint64_t &id, const std::string &title, const std::string &content)
 326         {
 327             std::string providerId = "123456789012345678901234567890123456";
 328             m_messageRep.setValue<int>("x.org.iotivity.ns.messageid", id);
 329             m_messageRep.setValue("x.org.iotivity.ns.title", title);
 330             m_messageRep.setValue("x.org.iotivity.ns.contenttext", content);
 331             m_messageRep.setValue("x.org.iotivity.ns.providerid", providerId);
 332         }
 333
 334         void setTopics(const NS_TopicList &topics)
 335         {
 336             bool isChanged = false;
 337             std::for_each (topics.begin(), topics.end(),
 338                            [this, & isChanged](const std::string & topic)
 339             {
 340                 auto found = std::find(
 341                                  this->m_topicList.begin(), this->m_topicList.end(), topic);
 342                 if (found == this->m_topicList.end())
 343                 {
 344                     this->m_topicList.push_back(topic);
 345                     isChanged = true;
 346                 }
 347             });
 348
 349             if (isChanged)
 350             {
 351                 this->notifyMessage((uint64_t)messageType::NS_TOPIC, "", "");
 352             }
 353         }
 354
 355         NS_TopicList getTopics() const
 356         {
 357             return m_topicList;
 358         }
 359
 360         void updateTopicState(const NS_TopicStateList &allowedTopics)
 361         {
 362             std::for_each (allowedTopics.begin(), allowedTopics.end(),
 363                            [this](const NS_TopicState & allowedTopic)
 364             {
 365                 auto found = this->m_allowedTopicList.find(allowedTopic.first);
 366                 if (found != this->m_allowedTopicList.end())
 367                 {
 368                     found->second = allowedTopic.second;
 369                 }
 370             });
 371         }
 372
 373         NS_TopicStateList getTopicAllowState() const
 374         {
 375             return m_allowedTopicList;
 376         }
 377
 378         void deleteNotificationResource()
 379         {
 380             OC::OCPlatform::unregisterResource(m_notificationHandle);
 381             OC::OCPlatform::unregisterResource(m_messageHandle);
 382             OC::OCPlatform::unregisterResource(m_syncHandle);
 383             OC::OCPlatform::unregisterResource(m_topicHandle);
 384             m_allowedTopicList.clear();
 385             m_topicList.clear();
 386         }
 387
 388         void createNotificationResource()
 389         {
 390             createNotificationResource(m_notificationUri);
 391         }
 392
 393         void createNotificationResource(const std::string &uri)
 394         {
 395             if (m_notificationUri != uri)
 396             {
 397                 m_notificationUri = uri;
 398             }
 399
 400             OC::OCPlatform::startPresence(30);
 401
 402             std::string notificationUri = m_notificationUri;
 403             std::string resourceTypeName = "x.org.iotivity.notification.topic";
 404             std::string resourceInterface = OC::DEFAULT_INTERFACE;
 405
 406             uint8_t resourceProperty = OC_OBSERVABLE;
 407             std::string childUri = uri + m_topicUri;
 408             try
 409             {
 410                 OC::OCPlatform::registerResource(
 411                     m_topicHandle, childUri,
 412                     resourceTypeName, resourceInterface,
 413                     std::bind(& NSProviderSimulator::entityHandler, this,
 414                               std::placeholders::_1, requestType::NS_TOPIC),
 415                     resourceProperty);
 416             }
 417             catch (std::exception &e)
 418             {
 419                 std::cout << e.what() << std::endl;
 420             }
 421
 422             //resourceProperty |= OC_OBSERVABLE;
 423             resourceTypeName = "x.org.iotivity.notification.message";
 424             childUri = uri + m_messageUri;
 425             try
 426             {
 427                 OC::OCPlatform::registerResource(
 428                     m_messageHandle, childUri,
 429                     resourceTypeName, resourceInterface,
 430                     std::bind(& NSProviderSimulator::entityHandler, this,
 431                               std::placeholders::_1, requestType::NS_MESSAGE),
 432                     resourceProperty);
 433             }
 434             catch (std::exception &e)
 435             {
 436                 std::cout << e.what() << std::endl;
 437             }
 438
 439             resourceTypeName = "x.org.iotivity.notification.sync";
 440             childUri = uri + m_syncUri;
 441             try
 442             {
 443                 OC::OCPlatform::registerResource(
 444                     m_syncHandle, childUri,
 445                     resourceTypeName, resourceInterface,
 446                     std::bind(& NSProviderSimulator::entityHandler, this,
 447                               std::placeholders::_1, requestType::NS_SYNC),
 448                     resourceProperty);
 449             }
 450             catch (std::exception &e)
 451             {
 452                 std::cout << e.what() << std::endl;
 453             }
 454
 455             resourceProperty |= OC_DISCOVERABLE;
 456             resourceTypeName = "x.org.iotivity.notification";
 457             try
 458             {
 459                 OC::OCPlatform::registerResource(
 460                     m_notificationHandle, notificationUri,
 461                     resourceTypeName, resourceInterface,
 462                     std::bind(& NSProviderSimulator::entityHandler, this,
 463                               std::placeholders::_1, requestType::NS_NOTIFICATION),
 464                     resourceProperty);
 465             }
 466             catch (std::exception &e)
 467             {
 468                 std::cout << e.what() << std::endl;
 469             }
 470         }
 471 };
 472
 473 #endif /* _NS_PROVIDER_SERVICE_SIMULATOR_H_ */