service/simulator/ramlparser/raml/model/Action.cpp

   1 /******************************************************************\r
   2  *\r
   3  * Copyright 2015 Samsung Electronics All Rights Reserved.\r
   4  *\r
   5  *\r
   6  *\r
   7  * Licensed under the Apache License, Version 2.0 (the "License");\r
   8  * you may not use this file except in compliance with the License.\r
   9  * You may obtain a copy of the License at\r
  10  *\r
  11  *              http://www.apache.org/licenses/LICENSE-2.0\r
  12  *\r
  13  * Unless required by applicable law or agreed to in writing, software\r
  14  * distributed under the License is distributed on an "AS IS" BASIS,\r
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
  16  * See the License for the specific language governing permissions and\r
  17  * limitations under the License.\r
  18  *\r
  19  ******************************************************************/\r
  20 \r
  21 #include "Action.h"\r
  22 \r
  23 namespace RAML\r
  24 {\r
  25     ActionType Action::getType() const\r
  26     {\r
  27         return m_type;\r
  28     }\r
  29     void Action::setType(const ActionType &type)\r
  30     {\r
  31         m_type = type;\r
  32     }\r
  33     std::string Action::getDescription() const\r
  34     {\r
  35         return m_description;\r
  36     }\r
  37     void Action::setDescription(const std::string &description)\r
  38     {\r
  39         m_description = description;\r
  40     }\r
  41     std::map<std::string, Header> Action::getHeaders() const\r
  42     {\r
  43         return m_headers;\r
  44     }\r
  45     void Action::setHeader(const std::string &headerName, const Header &header)\r
  46     {\r
  47         m_headers[headerName] = header;\r
  48     }\r
  49     std::map<std::string, QueryParameter> Action::getQueryParameters()const\r
  50     {\r
  51         return m_queryParameters;\r
  52     }\r
  53     void Action::setQueryParameter(const std::string &paramName, const QueryParameter &queryParameter)\r
  54     {\r
  55         m_queryParameters[paramName] = queryParameter;\r
  56     }\r
  57     RequestResponseBody &Action::getRequestBody(std::string bodyType)\r
  58     {\r
  59         return m_requestBody[bodyType];\r
  60     }\r
  61 \r
  62     std::map<std::string, RequestResponseBody> Action::getRequestBody() const\r
  63     {\r
  64         return m_requestBody;\r
  65     }\r
  66     void Action::setRequestBody(const std::string &typeName)\r
  67     {\r
  68         m_requestBody[typeName] = *(new RequestResponseBody(typeName));\r
  69     }\r
  70 \r
  71     void Action::setRequestBody(const std::string &typeName , const RequestResponseBody &body)\r
  72     {\r
  73         m_requestBody[typeName] = body;\r
  74     }\r
  75     Response &Action::getResponse(std::string responseCode)\r
  76     {\r
  77         return m_responses[responseCode];\r
  78     }\r
  79 \r
  80     std::map<std::string, Response> Action::getResponses() const\r
  81     {\r
  82         return m_responses;\r
  83     }\r
  84     void Action::setResponse(const std::string &responseCode, const Response &response)\r
  85     {\r
  86         m_responses[responseCode] = response;\r
  87     }\r
  88 \r
  89     std::list<std::string> Action::getProtocols() const\r
  90     {\r
  91         return m_protocols;\r
  92     }\r
  93     void Action::setProtocol(const std::string &protocol)\r
  94     {\r
  95         m_protocols.push_back(protocol);\r
  96     }\r
  97     std::map<std::string, UriParameter > Action::getBaseUriParameters() const\r
  98     {\r
  99         return m_baseUriParameters;\r
 100     }\r
 101     void Action::setBaseUriParameter(const std::string &paramName ,\r
 102                                      const UriParameter  &baseUriParameter)\r
 103     {\r
 104         m_baseUriParameters[paramName] = baseUriParameter;\r
 105     }\r
 106 \r
 107     std::list<std::string> Action::getTraits() const\r
 108     {\r
 109         return m_trait;\r
 110     }\r
 111     void Action::setTrait(const std::string &trait)\r
 112     {\r
 113         m_trait.push_back(trait);\r
 114     }\r
 115     void Action::readAction(const ActionType actionType, const YAML::Node &yamlNode,\r
 116                             IncludeResolver *includeResolver)\r
 117     {\r
 118         m_includeResolver = includeResolver;\r
 119         m_type = actionType;\r
 120         for ( YAML::const_iterator it = yamlNode.begin(); it != yamlNode.end(); ++it )\r
 121         {\r
 122             std::string key = READ_NODE_AS_STRING(it->first);\r
 123 \r
 124             if (key == Keys::Description)\r
 125                 setDescription(READ_NODE_AS_STRING(it->second));\r
 126             else if (key == Keys::Responses)\r
 127             {\r
 128                 YAML::Node responseNode = it->second;\r
 129                 for ( YAML::const_iterator tt = responseNode.begin(); tt != responseNode.end(); ++tt )\r
 130                 {\r
 131                     std::string responseCode = READ_NODE_AS_STRING(tt->first);\r
 132                     setResponse(responseCode, *(new Response(tt->second, m_includeResolver)));\r
 133                 }\r
 134             }\r
 135             else if (key == Keys::Headers)\r
 136             {\r
 137                 YAML::Node paramNode = it->second;\r
 138                 for ( YAML::const_iterator tt = paramNode.begin(); tt != paramNode.end(); ++tt )\r
 139                 {\r
 140                     Header *header = new Header(tt->second);\r
 141                     setHeader(READ_NODE_AS_STRING(tt->first), *header);\r
 142                 }\r
 143             }\r
 144             else if (key == Keys::QueryParameters)\r
 145             {\r
 146                 YAML::Node paramNode = it->second;\r
 147                 for ( YAML::const_iterator tt = paramNode.begin(); tt != paramNode.end(); ++tt )\r
 148                 {\r
 149                     QueryParameter *queryParameter = new QueryParameter(tt->second);\r
 150                     setQueryParameter(READ_NODE_AS_STRING(tt->first), *queryParameter);\r
 151                 }\r
 152             }\r
 153             else if (key == Keys::Protocols)\r
 154             {\r
 155                 YAML::Node protocolNode = it->second;\r
 156                 for ( YAML::const_iterator tt = protocolNode.begin(); tt != protocolNode.end(); ++tt )\r
 157                 {\r
 158                     setProtocol(READ_NODE_AS_STRING(*tt));\r
 159                 }\r
 160             }\r
 161             else if (key == Keys::BaseUriParameters)\r
 162             {\r
 163                 YAML::Node paramNode = it->second;\r
 164                 for ( YAML::const_iterator tt = paramNode.begin(); tt != paramNode.end(); ++tt )\r
 165                 {\r
 166                     UriParameter *uriParameter = new UriParameter(tt->second);\r
 167                     setBaseUriParameter(READ_NODE_AS_STRING(tt->first), *uriParameter);\r
 168                 }\r
 169             }\r
 170             else if (key == Keys::Body)\r
 171             {\r
 172                 YAML::Node responseBody = it->second;\r
 173 \r
 174                 for ( YAML::const_iterator tt = responseBody.begin(); tt != responseBody.end(); ++tt )\r
 175                 {\r
 176                     std::string type = READ_NODE_AS_STRING(tt->first);\r
 177                     setRequestBody(type, *(new RequestResponseBody(type, tt->second, m_includeResolver)));\r
 178                 }\r
 179             }\r
 180             else if (key == Keys::IsTrait)\r
 181             {\r
 182                 YAML::Node traitNode = it->second;\r
 183                 for ( YAML::const_iterator tt = traitNode.begin(); tt != traitNode.end(); ++tt )\r
 184                 {\r
 185                     setTrait(READ_NODE_AS_STRING(*tt));\r
 186                 }\r
 187             }\r
 188         }\r
 189     }\r
 190 \r
 191 };\r
 192 \r