RAML::RequestResponseBodyPtr SimulatorResourceFactory::getRAMLResponseBody(
    std::shared_ptr<RAML::RamlResource> ramlResource, RAML::ActionType type, std::string responseCode)
{
    // Get the resource representation schema from response body
    RAML::ActionPtr action = ramlResource->getAction(type);
    if (!action)
    {
        OIC_LOG(ERROR, TAG, "Resource does not possess the request!");
        return nullptr;
    }

    RAML::ResponsePtr response = action->getResponse(responseCode);
    if (!response)
    {
        OIC_LOG(ERROR, TAG, "Resource does not provide valid GET response!");
        return nullptr;
    }

    RAML::RequestResponseBodyPtr responseBody = response->getResponseBody("application/json");
    if (!responseBody)
    {
        OIC_LOG(ERROR, TAG, "GET response is not of type \"application/json\" ");
        return nullptr;
    }

    return responseBody;
}
예제 #2
0
RequestModelSP RequestModelBuilder::createRequestModel(const RAML::ActionPtr &action)
{
    OIC_LOG(DEBUG, TAG, "Creating request model");

    // Validate the action type. Only GET, PUT, POST and DELETE are supported.
    RAML::ActionType actionType = action->getType();
    if (actionType != RAML::ActionType::GET
        && actionType != RAML::ActionType::PUT
        && actionType != RAML::ActionType::POST
        && actionType != RAML::ActionType::DELETE)
    {
        OIC_LOG(ERROR, TAG, "Failed to create request model as it is of unknown type!");
        return nullptr;
    }

    // Construct RequestModel
    RequestModelSP requestModel(new RequestModel(getRequestType(actionType)));

    // Get the allowed query parameters of the request
    for (auto &qpEntry : action->getQueryParameters())
    {
        for (auto &value :  (qpEntry.second)->getEnumeration())
        {
            requestModel->addQueryParam(qpEntry.first, value);
        }
    }

    RAML::RequestResponseBodyPtr requestBody = action->getRequestBody("application/json");
    SimulatorResourceModelSP repSchema = createRepSchema(requestBody);
    requestModel->setRepSchema(repSchema);

    // Corresponsing responses
    for (auto   &responseEntry :  action->getResponses())
    {
        std::string codeStr = responseEntry.first;
        int code = boost::lexical_cast<int>(codeStr);
        ResponseModelSP responseModel = createResponseModel(code, responseEntry.second);
        if (nullptr != responseModel)
        {
            requestModel->addResponseModel(code, responseModel);
        }
    }

    return requestModel;
}
SimulatorResourceServerImplSP SimulatorResourceCreator::createResource(
    const std::string &configPath)
{
    RAML::RamlPtr raml;

    try
    {
        std::shared_ptr<RAML::RamlParser> ramlParser = std::make_shared<RAML::RamlParser>(configPath);
        raml = ramlParser->getRamlPtr();
    }
    catch (RAML::RamlException &e)
    {
        OC_LOG_V(ERROR, TAG, "RAML Exception occured! [%s]", e.what());
        throw;
    }

    std::map<std::string, RAML::RamlResourcePtr> ramlResources = raml->getResources();
    RAML::RamlResourcePtr ramlResource;
    if (0 == ramlResources.size() || (ramlResource = ramlResources.begin()->second) == nullptr)
    {
        OC_LOG(ERROR, TAG, "Zero resources detected from RAML!");
        return nullptr;
    }

    if (ramlResource)
    {
        SimulatorResourceServerImplSP simResource(new SimulatorResourceServerImpl());
        simResource->setName(ramlResource->getDisplayName());
        simResource->setURI(ramlResource->getResourceUri());

        // Get the resource representation schema from GET response body
        RAML::ActionPtr action = ramlResource->getAction(RAML::ActionType::GET);
        if (!action)
        {
            OC_LOG(ERROR, TAG, "Failed to create resource representation schema as it does not"
                   "posess the GET request!");
            return nullptr;
        }

        RAML::ResponsePtr getResponse = action->getResponse("200");
        if (!getResponse)
        {
            OC_LOG(ERROR, TAG, "Resource does not provide valid GET response!");
            return nullptr;
        }

        RAML::RequestResponseBodyPtr responseBody = getResponse->getResponseBody("application/json");
        if (responseBody)
        {
            RAML::JsonSchemaPtr resourceProperties = responseBody->getSchema()->getProperties();
            for ( auto & propertyElement : resourceProperties->getProperties())
            {
                if (!propertyElement.second)
                    continue;

                std::string propName = propertyElement.second->getName();
                if ("rt" == propName || "resourceType" == propName)
                {
                    simResource->setResourceType(propertyElement.second->getValueString());
                    continue;
                }
                else if ("if" == propName)
                {
                    simResource->setInterfaceType(propertyElement.second->getValueString());
                    continue;
                }
                else if ("p" == propName || "n" == propName || "id" == propName)
                {
                    continue;
                }

                // Build representation attribute
                SimulatorResourceModel::Attribute attribute(propName);
                switch (propertyElement.second->getValueType())
                {
                    case 0: // Integer
                        attribute.setValue(propertyElement.second->getValue<int>());
                        break;

                    case 1: // Double
                        attribute.setValue(propertyElement.second->getValue<double>());
                        break;

                    case 2: // Boolean
                        attribute.setValue(propertyElement.second->getValue<bool>());
                        break;

                    case 3: // String
                        attribute.setValue(propertyElement.second->getValue<std::string>());
                        break;
                }

                // Set range/supported values set
                int min = 0, max = 0, multipleof = 0;
                propertyElement.second->getRange(min, max, multipleof);
                attribute.setRange(min, max);

                if (propertyElement.second->getAllowedValuesSize() > 0)
                    attribute.setAllowedValues(propertyElement.second->getAllowedValues());

                simResource->addAttribute(attribute);
            }
        }

        simResource->setURI(constructURI(simResource->getURI()));
        return simResource;
    }

    return nullptr;
}