AsyncGpioController.hpp

/*
** Copyright (C) 2023 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: 2023-03-09T09:47:19
** Author: Sylvain Fargier <sylvain.fargier@cern.ch>
*/
 
#ifndef ASYNCGPIOCONTROLLER_HPP__
#define ASYNCGPIOCONTROLLER_HPP__
 
#include <algorithm>
#include <cmath>
#include <memory>
 
#include <ccut/async.hpp>
#include <ccut/utils.hpp>
#include <logger/Logger.hpp>
#include <oatpp/core/macro/component.hpp>
#include <oatpp/web/protocol/http/incoming/Request.hpp>
 
#include "Exception.hpp"
#include "FutureCoroutine.hpp"
#include "OatExt.hpp"
#include "SmcController.hpp"
#include "device/Axis.hpp"
#include "device/DeviceBase.hpp"
#include "device/DeviceStore.hpp"
#include "platform/PlatformFactory.hpp"
#include "util/serialize.hpp"
 
#include OATPP_CODEGEN_BEGIN(ApiController)
 
// clang-format off
class AsyncGpioController : public SmcController
{
public:
    explicit AsyncGpioController(OATPP_COMPONENT(std::shared_ptr<ObjectMapper>,
                                                objectMapper)) :
        SmcController(objectMapper)
    {
        addTag(*this, "gpio");
    }
 
    void addParams(const std::shared_ptr<oatpp::web::server::api::Endpoint::Info>& info)
    {
        info->pathParams.add<String>("id")
        .addExample("Gpio id", String("mfe://1/gpio/limit"));
    }
 
    ENDPOINT_INFO(getIoValue)
    {
        info->summary = "get gpio value";
        info->addResponse<UInt64>(Status::CODE_200, "application/json")
            .addExample("example", UInt64(1234));
        addParams(info);
    }
    ENDPOINT_ASYNC("GET", "/gpio/{id}/value", getIoValue)
    {
    public:
        ENDPOINT_ASYNC_INIT(getIoValue)
        Action act() override
        {
            auto deviceStore(controller->deviceStore.lock());
            if (deviceStore)
            {
                smc::Gpio::Shared device = deviceStore->getDevice<smc::Gpio>(
                    ccut::urldecode(request->getPathVariable("id").getValue("")));
 
                auto future = device->getIoState();
                return smc::debug::wait(future.share())
                    .callbackTo(&getIoValue::onResult);
            }
            return _return(controller->createResponse(Status::CODE_500, "no deviceStore"));
        }
 
        Action onResult(const smc::units::io_port_t &value)
        {
            return _return(
                controller->createDtoResponse(Status::CODE_200, UInt64(value.value)));
        }
    };
 
    ENDPOINT_INFO(getIoSize)
    {
        info->summary = "get gpio size (in bits)";
        info->addResponse<UInt64>(Status::CODE_200, "application/json")
            .addExample("example", UInt32(16));
        addParams(info);
    }
    ENDPOINT_ASYNC("GET", "/gpio/{id}/size", getIoSize)
    {
    public:
        ENDPOINT_ASYNC_INIT(getIoSize)
        Action act() override
        {
            auto deviceStore(controller->deviceStore.lock());
            if (deviceStore)
            {
                smc::Gpio::Shared device = deviceStore->getDevice<smc::Gpio>(
                    ccut::urldecode(request->getPathVariable("id").getValue("")));
 
                auto future = device->getIoState();
                return smc::debug::wait(future.share())
                    .callbackTo(&getIoSize::onResult);
            }
            return _return(controller->createResponse(Status::CODE_500, "no deviceStore"));
        }
 
        Action onResult(const smc::units::io_port_t &value)
        {
            return _return(
                controller->createDtoResponse(Status::CODE_200, UInt32(value.size)));
        }
    };
 
    ENDPOINT_INFO(putIoValue)
    {
        info->summary = "set gpio value";
        info->addResponse(Status::CODE_200, "application/json");
        info->addConsumes<UInt64>("application/json")
        .addExample("gpio value", UInt64(1234));
 
        {
            auto &param = info->queryParams.add<UInt32>("size")
                .addExample("size", UInt32(32));
 
            param.required = false;
            param.description = "request unit";
        }
        addParams(info);
    }
    ENDPOINT_ASYNC("PUT", "/gpio/{id}/value", putIoValue)
    {
    public:
        ENDPOINT_ASYNC_INIT(putIoValue)
        Action act() override
        {
            return request
                ->readBodyToDtoAsync<UInt64>(
                    controller->getDefaultObjectMapper())
                .callbackTo(&putIoValue::onSetIoState);
        }
 
        Action onSetIoState(const UInt64 &value)
        {
            size_t size = getQueryParameter<uint32_t>(request, "size", sizeof(smc::units::io_port_t::value_type));
            auto deviceStore(controller->deviceStore.lock());
            if (deviceStore)
            {
                smc::Gpio::Shared device = deviceStore->getDevice<smc::Gpio>(
                    ccut::urldecode(request->getPathVariable("id").getValue("")));
 
                auto future = device->setIoState(smc::units::io_port_t{value.getValue(0), size});
                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