AsyncApiController.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-07-26T11:50:41
** Author: Sylvain Fargier <sylvain.fargier@cern.ch>
*/
 
#ifndef ASYNCAPICONTROLLER_HPP__
#define ASYNCAPICONTROLLER_HPP__
 
#include <algorithm>
#include <cmath>
#include <memory>
 
#include <ccut/async.hpp>
#include <ccut/utils.hpp>
#include <logger/Logger.hpp>
#include <oatpp/core/Types.hpp>
#include <oatpp/core/macro/codegen.hpp>
#include <oatpp/core/macro/component.hpp>
#include <oatpp/web/server/api/ApiController.hpp>
 
#include "Exception.hpp"
#include "FutureCoroutine.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 AsyncApiController : public SmcController
{
public:
    explicit AsyncApiController(OATPP_COMPONENT(std::shared_ptr<ObjectMapper>,
                                                objectMapper)) :
        SmcController(objectMapper)
    {}
 
    ENDPOINT_INFO(root)
    {
        info->summary = "api-docs redirection";
        info->addResponse<List<String>>(Status::CODE_302, "");
    }
    ENDPOINT_ASYNC("GET", "/", root)
    {
        ENDPOINT_ASYNC_INIT(root)
 
        Action act() override
        {
            auto ret = controller->createResponse(Status::CODE_302);
            ret->putHeader("Location", "/api-docs/ui");
            return _return(ret);
        }
    };
 
    ENDPOINT_INFO(devices)
    {
        info->summary = "List available devices";
        info->addResponse<List<String>>(Status::CODE_200, "application/json")
            .addExample("example",
                        List<String>{"grbl://1/platform", "grbl://1/axis/X",
                                    "grbl://1/axis/Y", "grbl://1/axis/Z",
                                    "grbl://1/axis/A", "grbl://1/axis/B",
                                    "grbl://1/axis/C"});
        {
            auto &param = info->queryParams.add<String>("type")
                            .addExample("fetch all", String())
                            .addExample("trigger", String("trigger"))
                            .addExample("axis", String("axis"))
                            .addExample("platform", String("platform"));
            param.description = "device type filter, accepted values are listed in "
                                "`GET /devices/types`";
            param.required = false;
        }
        {
            auto &param = info->queryParams.add<Boolean>("typed")
                .addExample("default results", Boolean(false))
                .addExample("typed results", Boolean(true));
            param.description = "get a deviceId : type map rather than a simple list";
            param.required = false;
        }
 
    }
    ENDPOINT_ASYNC("GET", "/devices", devices)
    {
        ENDPOINT_ASYNC_INIT(devices)
 
        Action act() override
        {
            const std::string deviceType =
                request->getQueryParameter("type").getValue("");
            bool success = false;
            bool typed = TypeInterpretation<Boolean>::fromString("Boolean",
                request->getQueryParameter("typed"), success);
            if (!success)
                typed = false;
 
 
            auto deviceStore(controller->deviceStore.lock());
            if (deviceStore)
            {
                std::set<smc::DeviceId> devices = deviceType.empty() ?
                    deviceStore->getDeviceList() :
                    deviceStore->getDeviceList(
                        smc::from_string<smc::DeviceType>(deviceType));
                if (!typed)
                {
                    oatpp::UnorderedSet<String> ret{oatpp::UnorderedSet<String>::createShared()};
                    ret->insert(devices.begin(), devices.end());
                    return _return(controller->createDtoResponse(Status::CODE_200, ret));
                }
                else
                {
                    oatpp::UnorderedFields<String> ret{oatpp::UnorderedFields<String>::createShared()};
                    for (smc::DeviceId id : devices)
                        ret[String(id)] = String(smc::to_string(deviceStore->getDevice(id)->type()));
                    return _return(controller->createDtoResponse(Status::CODE_200, ret));
                }
            }
 
            return _return(controller->createResponse(Status::CODE_500, "no deviceStore"));
        }
    };
};
// clang-format on
#include OATPP_CODEGEN_END(ApiController)
 
#endif