AsyncConfigController.hpp

/*
** Copyright (C) 2022 CERN
**
** This software is provided 'as-is', without any express or implied
** warranty.  In no event will the authors be held liable for any damages
** arising from the use of this software.
**
** Permission is granted to anyone to use this software for any purpose,
** including commercial applications, and to alter it and redistribute it
** freely, subject to the following restrictions:
**
** 1. The origin of this software must not be misrepresented; you must not
**    claim that you wrote the original software. If you use this software
**    in a product, an acknowledgment in the product documentation would be
**    appreciated but is not required.
** 2. Altered source versions must be plainly marked as such, and must not be
**    misrepresented as being the original software.
** 3. This notice may not be removed or altered from any source distribution.
**
** Created on: 2022-08-02T09:42:28
** Author: Sylvain Fargier <sylvain.fargier@cern.ch>
*/
 
#ifndef ASYNCCONFIGCONTROLLER_HPP__
#define ASYNCCONFIGCONTROLLER_HPP__
 
#include <ccut/utils.hpp>
#include <oatpp/core/macro/component.hpp>
 
#include "FutureCoroutine.hpp"
#include "OatExt.hpp"
#include "SmcController.hpp"
#include "device/DeviceBase.hpp"
#include "device/DeviceStore.hpp"
 
#include OATPP_CODEGEN_BEGIN(ApiController)
 
// clang-format off
class AsyncConfigController : public SmcController
{
public:
    explicit AsyncConfigController(OATPP_COMPONENT(std::shared_ptr<ObjectMapper>,
                                                objectMapper)) :
        SmcController(objectMapper)
    {
        addTag(*this, "config");
    }
 
    void addParams(const std::shared_ptr<oatpp::web::server::api::Endpoint::Info>& info)
    {
        info->pathParams.add<String>("id")
        .addExample("Grbl axis X", String("grbl://1/axis/X"));
    }
 
    ENDPOINT_INFO(getConfigList)
    {
        info->summary = "get device configuration parameters";
        info->addResponse<List<String>>(Status::CODE_200, "application/json");
        addParams(info);
    }
    ENDPOINT_ASYNC("GET", "/config/{id}", getConfigList)
    {
    public:
        ENDPOINT_ASYNC_INIT(getConfigList)
        Action act() override
        {
            auto deviceStore(controller->deviceStore.lock());
            if (deviceStore)
            {
                smc::DeviceBase::Shared device = deviceStore->getDevice(
                    ccut::urldecode(request->getPathVariable("id").getValue("")));
 
                auto future = device->listConfig();
                return smc::debug::wait(future.share())
                    .callbackTo(&getConfigList::onResult);
            }
            return _return(controller->createResponse(Status::CODE_500, "no deviceStore"));
        }
 
        Action onResult(const std::set<std::string> &value)
        {
            oatpp::UnorderedSet<String> ret{oatpp::UnorderedSet<String>::createShared()};
                ret->insert(value.begin(), value.end());
            return _return(
                controller->createDtoResponse(Status::CODE_200, ret));
        }
    };
 
    ENDPOINT_INFO(getConfig)
    {
        info->summary = "get configuration parameter value";
        info->addResponse<String>(Status::CODE_200, "application/json");
        addParams(info);
        info->pathParams.add<String>("name")
        .addExample("Axis travel resolution", String("axis travel resolution"));
    }
    ENDPOINT_ASYNC("GET", "/config/{id}/{name}", getConfig)
    {
    public:
        ENDPOINT_ASYNC_INIT(getConfig)
        Action act() override
        {
            auto deviceStore(controller->deviceStore.lock());
            if (deviceStore)
            {
                smc::DeviceBase::Shared device = deviceStore->getDevice(
                    ccut::urldecode(request->getPathVariable("id").getValue("")));
                const std::string name =
                    ccut::urldecode(request->getPathVariable("name").getValue(""));
 
                auto future = device->getConfig(name);
                return smc::debug::wait(future.share())
                    .callbackTo(&getConfig::onResult);
            }
            return _return(controller->createResponse(Status::CODE_500, "no deviceStore"));
        }
 
        Action onResult(const std::string &value)
        {
            return _return(
                controller->createDtoResponse(Status::CODE_200, String{value}));
        }
    };
 
    ENDPOINT_INFO(putConfig)
    {
        info->summary = "set a configuration parameter value";
        info->addResponse<String>(Status::CODE_200, "application/json");
        addParams(info);
        info->pathParams.add<String>("name")
        .addExample("Axis travel resolution", String("axis travel resolution"));
        info->addConsumes<String>("application/json")
        .addExample("sample value", String("250"));
    }
    ENDPOINT_ASYNC("PUT", "/config/{id}/{name}", putConfig)
    {
    public:
        ENDPOINT_ASYNC_INIT(putConfig)
        Action act() override
        {
            return request->readBodyToDtoAsync<String>(
                controller->getDefaultObjectMapper())
            .callbackTo(&putConfig::onBody);
        }
 
        Action onBody(const String &value)
        {
            auto deviceStore(controller->deviceStore.lock());
            if (deviceStore)
            {
                smc::DeviceBase::Shared device = deviceStore->getDevice(
                    ccut::urldecode(request->getPathVariable("id").getValue("")));
                const std::string name =
                    ccut::urldecode(request->getPathVariable("name").getValue(""));
 
                auto future = device->setConfig(name, value.getValue(""));
                return smc::debug::wait(future.share())
                    .next(_return(controller->createResponse(Status::CODE_200, "done")));
            }
            return _return(controller->createResponse(Status::CODE_500, "no deviceStore"));
        }
    };
};
 
//clang-format on
 
#include OATPP_CODEGEN_END(ApiController)
 
 
#endif