AsyncTriggerController.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-10-16
** Author: Sam Wilson <samuel.wilson@cern.ch>
*/
 
#ifndef ASYNCTRIGGERCONTROLLER_HPP__
#define ASYNCTRIGGERCONTROLLER_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 "Exception.hpp"
#include "FutureCoroutine.hpp"
#include "OatExt.hpp"
#include "SmcController.hpp"
#include "device/DeviceBase.hpp"
#include "device/DeviceStore.hpp"
#include "device/Trigger.hpp"
#include "platform/PlatformFactory.hpp"
#include "util/serialize.hpp"
 
#include OATPP_CODEGEN_BEGIN(ApiController)
 
// clang-format off
class AsyncTriggerController : public SmcController
{
public:
    // create trigger component in UI
    explicit AsyncTriggerController(
        OATPP_COMPONENT(std::shared_ptr<ObjectMapper>, objectMapper)) :
        SmcController(objectMapper)
    {
        addTag(*this, "trigger");
    }
    // create parameter sections and defaults
    void addParams(
        const std::shared_ptr<oatpp::web::server::api::Endpoint::Info> &info)
    {
        info->pathParams.add<String>("id")
            .addExample("Global Trigger", String("grbl://1/trigger"))
            .addExample("Trigger 0", String("grbl://1/trigger/0"));
    }
 
    // Get Trigger State
    ENDPOINT_INFO(getTriggerState)
    {
        // set summary and response type
        info->summary = "trigger is armed?";
        info->addResponse<Boolean>(Status::CODE_200, "application/json")
            .addExample("example", Boolean(true));
        info->summary = "checking if a trigger is armed is not currently  "
                        "possible at grbl level";
        addParams(info);
    }
    // create async endpoint for getting trigger state
    ENDPOINT_ASYNC("GET", "/trigger/{id}/state", getTriggerState)
    {
    public:
        // initialise endpoint
        ENDPOINT_ASYNC_INIT(getTriggerState)
        Action act() override
        {
            // get device store
            auto deviceStore(controller->deviceStore.lock());
            if (deviceStore)
            {
                // get trigger device from device store - if no id -> global trigger
                smc::Trigger::Shared trigger = deviceStore->getDevice<smc::Trigger>(
                    ccut::urldecode(request->getPathVariable("id").getValue("")));
 
                // get trigger state - is it armed or not?
                auto future = trigger->isArmed();
                // wait for future to complete and then call onResult
                return smc::debug::wait(future.share())
                    .callbackTo(&getTriggerState::onResult);
            }
            // return error if device store is not available
            return _return(
                controller->createResponse(Status::CODE_500, "no deviceStore"));
        }
 
        Action onResult(const bool &armed)
        {
            return _return(
                controller->createDtoResponse(Status::CODE_200, Boolean(armed)));
        }
    };
 
    // Arm the Trigger
    ENDPOINT_INFO(putTriggerState)
    {
        // set summary and consumes type
        info->summary = "arm trigger";
        info->addResponse(Status::CODE_200, "application/json");
        info->addConsumes<Boolean>("application/json")
            .addExample("arm trigger", Boolean(true))
            .addExample("disarm trigger", Boolean(false));
 
        addParams(info);
    }
    // create async endpoint for arming trigger
    ENDPOINT_ASYNC("PUT", "/trigger/{id}/arm", putTriggerState)
    {
    public:
        // initialise endpoint
        ENDPOINT_ASYNC_INIT(putTriggerState)
        Action act() override
        {
            // read body to dto and call onArmTrigger
            return request
                ->readBodyToDtoAsync<Boolean>(
                    controller->getDefaultObjectMapper())
                .callbackTo(&putTriggerState::onArmTrigger);
        }
 
        // arm trigger if armed is true, disarm if false
        Action onArmTrigger(const Boolean &armed)
        {
            // get device store
            auto deviceStore(controller->deviceStore.lock());
            if (deviceStore)
            {
                // get trigger device from device store - if no id -> global trigger
                smc::Trigger::Shared trigger = deviceStore->getDevice<smc::Trigger>(
                    ccut::urldecode(request->getPathVariable("id").getValue("")));
 
                // arm or disarm trigger
                logger::info("arming trigger:") << trigger->toString();
 
                auto future = armed ? trigger->arm() : trigger->disarm();
                logger::info("armed trigger:") << trigger->toString();
                return smc::debug::wait(future.share())
                    .next(_return(
                        controller->createResponse(Status::CODE_200, "trigger state changed")));
            }
            return _return(
                controller->createResponse(Status::CODE_500, "no deviceStore"));
        }
    };
 
    // Trigger the Trigger
    ENDPOINT_INFO(postTriggerTrigger)
    {
        // set summary and consumes type
        info->summary = "trigger the trigger";
        info->addResponse(Status::CODE_200, "application/json");
        addParams(info);
    }
 
    // create async endpoint for triggering trigger
    ENDPOINT_ASYNC("POST", "/trigger/{id}/trigger", postTriggerTrigger)
    {
    public:
        // initialise endpoint
        ENDPOINT_ASYNC_INIT(postTriggerTrigger)
        Action act() override
        {
            // get device store
            auto deviceStore(controller->deviceStore.lock());
            if (deviceStore)
            {
                // get trigger device from device store - if no id -> global trigger
                smc::Trigger::Shared trigger = deviceStore->getDevice<smc::Trigger>(
                    ccut::urldecode(request->getPathVariable("id").getValue("")));
 
                // trigger trigger
                logger::info("triggering trigger:") << trigger->toString();
 
                auto future = trigger->trig();
 
                return smc::debug::wait(future.share())
                    .next(_return(
                        controller->createResponse(Status::CODE_200, "trigger triggered")));
 
            }
            return _return(
                controller->createResponse(Status::CODE_500, "no deviceStore"));
 
        }
    };
};
 
// clang-format on
 
#include OATPP_CODEGEN_END(ApiController)
 
#endif // ASYNCTRIGGERCONTROLLER_HPP__