AsyncAliasController.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-31T00:08:47
** Author: Sylvain Fargier <sylvain.fargier@cern.ch>
*/
 
/*
** 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-27T09:08:31
** Author: Sylvain Fargier <sylvain.fargier@cern.ch>
*/
 
#ifndef ASYNCALIASCONTROLLER_HPP__
#define ASYNCALIASCONTROLLER_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 "OatExt.hpp"
#include "SmcController.hpp"
#include "device/DeviceStore.hpp"
 
#include OATPP_CODEGEN_BEGIN(ApiController)
 
// clang-format off
class AsyncAliasController : public SmcController
{
public:
    explicit AsyncAliasController(OATPP_COMPONENT(std::shared_ptr<ObjectMapper>,
                                                objectMapper)) :
        SmcController(objectMapper)
    {
        addTag(*this, "alias");
    }
 
    ENDPOINT_INFO(getAliasList)
    {
        info->summary = "Get list of alias";
        info->addResponse<List<String>>(Status::CODE_200, "application/json")
        .addExample("example", List<String>{"alias1", "myStepper"});
    }
    ENDPOINT_ASYNC("GET", "/alias", getAliasList)
    {
    public:
        ENDPOINT_ASYNC_INIT(getAliasList)
        Action act() override
        {
            oatpp::UnorderedSet<String> ret{oatpp::UnorderedSet<String>::createShared()};
            auto deviceStore(controller->deviceStore.lock());
            if (deviceStore)
            {
                std::set<std::string> list{deviceStore->getAliasList()};
                ret->insert(list.begin(), list.end());
                return _return(controller->createDtoResponse(Status::CODE_200, ret));
            }
 
            return _return(controller->createResponse(Status::CODE_500, "no deviceStore"));
        }
    };
 
    ENDPOINT_INFO(getAlias)
    {
        info->summary = "Resolve an alias";
        info->addResponse<String>(Status::CODE_200, "application/json")
        .addExample("example", String{"grbl://1/axis/X"});
        info->pathParams.add<String>("id");
    }
    ENDPOINT_ASYNC("GET", "/alias/{id}", getAlias)
    {
    public:
        ENDPOINT_ASYNC_INIT(getAlias)
        Action act() override
        {
            auto deviceStore(controller->deviceStore.lock());
            if (deviceStore)
            {
                const std::string id = request->getPathVariable("id").getValue("");
                const std::string ret = deviceStore->getAlias(id);
                if (ret.empty())
                    return _return(controller->createResponse(Status::CODE_404, "no such alias"));
                else
                    return _return(controller->createDtoResponse(Status::CODE_200, String(ret)));
            }
            return _return(controller->createResponse(Status::CODE_500, "no deviceStore"));
        }
    };
 
    ENDPOINT_INFO(deleteAlias)
    {
        info->summary = "Delete an alias";
        info->addResponse<String>(Status::CODE_200, "application/json");
        info->pathParams.add<String>("id");
    }
    ENDPOINT_ASYNC("DELETE", "/alias/{id}", deleteAlias)
    {
    public:
        ENDPOINT_ASYNC_INIT(deleteAlias)
        Action act() override
        {
            auto deviceStore(controller->deviceStore.lock());
            if (deviceStore)
            {
                const std::string id = request->getPathVariable("id").getValue("");
                deviceStore->removeAlias(id);
                return _return(controller->createResponse(Status::CODE_200, "done"));
            }
            return _return(controller->createResponse(Status::CODE_500, "no deviceStore"));
        }
    };
 
    ENDPOINT_INFO(putAlias)
    {
        info->summary = "Create or update an alias";
        info->addResponse<String>(Status::CODE_200, "application/json");
        info->pathParams.add<String>("id");
        info->addConsumes<String>("application/json")
        .addExample("device id", String("grbl://1/axis/X"));
    }
    ENDPOINT_ASYNC("PUT", "/alias/{id}", putAlias)
    {
    public:
        ENDPOINT_ASYNC_INIT(putAlias)
        Action act() override
        {
            return request
                ->readBodyToDtoAsync<String>(
                    controller->getDefaultObjectMapper())
                .callbackTo(&putAlias::onBodyReady);
        }
        Action onBodyReady(const String &target)
        {
            auto deviceStore(controller->deviceStore.lock());
            if (deviceStore)
            {
                const std::string id = request->getPathVariable("id").getValue("");
                deviceStore->addAlias(id, target.getValue(""));
                return _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