ApiController.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-11T13:35:13
** Author: Sylvain Fargier <sylvain.fargier@cern.ch>
*/
 
#ifndef APICONTROLLER_HPP__
#define APICONTROLLER_HPP__
 
#include <algorithm>
#include <memory>
 
#include <ccut/async.hpp>
#include <ccut/utils.hpp>
#include <logger/Logger.hpp>
#include <oatpp/core/macro/codegen.hpp>
#include <oatpp/core/macro/component.hpp>
#include <oatpp/web/server/api/ApiController.hpp>
 
#include "Exception.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)
 
class ApiController : public oatpp::web::server::api::ApiController
{
public:
    explicit ApiController(OATPP_COMPONENT(std::shared_ptr<ObjectMapper>,
                                           objectMapper)) :
        oatpp::web::server::api::ApiController(objectMapper)
    {}
 
    ENDPOINT_INFO(root)
    {
        info->summary = "api-docs redirection";
        info->addResponse<List<String>>(Status::CODE_302, "");
    }
    ENDPOINT("GET", "/", root)
    {
        auto ret = createResponse(Status::CODE_302);
        ret->putHeader("Location", "/api-docs/ui");
        return ret;
    }
 
    ENDPOINT_INFO(devicesTypes)
    {
        info->summary = "List device types";
        info->addResponse<List<String>>(Status::CODE_200, "application/json")
            .addExample("example",
                        List<String>{"axis", "position", "gpio", "trigger"});
    }
    ENDPOINT("GET", "/devices/types", devicesTypes)
    {
        auto deviceStore(m_deviceStore.lock());
        List<String> ret{List<String>::createShared()};
        if (deviceStore)
        {
            std::set<smc::DeviceType> deviceTypes =
                smc::getEnumValues<smc::DeviceType>();
            std::transform(deviceTypes.cbegin(), deviceTypes.cend(),
                           std::inserter(*ret, ret->begin()),
                           [](smc::DeviceType t) { return smc::to_string(t); });
        }
        return createDtoResponse(Status::CODE_200, 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;
    }
    ENDPOINT("GET", "/devices", devices, QUERIES(QueryParams, queryParams))
    {
        const std::string deviceType = queryParams.get("type").getValue("");
        oatpp::UnorderedSet<String> ret{
            oatpp::UnorderedSet<String>::createShared()};
 
        auto deviceStore(m_deviceStore.lock());
        if (deviceStore)
        {
            std::set<smc::DeviceId> devices = deviceType.empty() ?
                deviceStore->getDeviceList() :
                deviceStore->getDeviceList(
                    smc::from_string<smc::DeviceType>(deviceType));
            ret->insert(devices.begin(), devices.end());
        }
        return createDtoResponse(Status::CODE_200, ret);
    }
 
    ENDPOINT("PUT",
             "/axis/{id}/position",
             putPosition,
             PATH(String, id),
             BODY_DTO(Float64, position))
    {
        auto deviceStore(m_deviceStore.lock());
        if (deviceStore)
        {
            smc::Axis::Shared axis = deviceStore->getDevice<smc::Axis>(
                ccut::urldecode(id.getValue("")));
            if (!axis)
                return createResponse(Status::CODE_404, "No such axis");
 
            axis->moveTo(smc::units::value_t{smc::units::mm, position}).wait();
            return createResponse(Status::CODE_200, "done");
        }
        return createResponse(Status::CODE_500, "no deviceStore");
    }
 
    ENDPOINT("GET", "/axis/{id}/position", getPosition, PATH(String, id))
    {
        auto deviceStore(m_deviceStore.lock());
        if (deviceStore)
        {
            smc::Axis::Shared axis = deviceStore->getDevice<smc::Axis>(
                ccut::urldecode(id.getValue("")));
            if (!axis)
                return createResponse(Status::CODE_404, "No such axis");
            return createDtoResponse(
                Status::CODE_200,
                Float64(ccut::wait(axis->getPosition(smc::units::mm)).value));
        }
        return createResponse(Status::CODE_500, "no deviceStore");
    }
 
    std::weak_ptr<smc::internal::PlatformFactory> m_platformFactory;
    std::weak_ptr<smc::internal::DeviceStore> m_deviceStore;
};
 
#include OATPP_CODEGEN_END(ApiController)
 
#endif