backend/controllers/AuthController.cc

#include "controllers/AuthController.h"

#include "common/Auth.h"
#include "common/Http.h"
#include "services/AuthService.h"

using drogon::HttpResponsePtr;

namespace
{
void serviceResponse(
    Json::Value body,
    std::function<void(const HttpResponsePtr &)> &&callback)
{
    if (body.get("ok", false).asBool())
    {
        callback(visione::http::json(std::move(body)));
        return;
    }
    callback(visione::http::json(std::move(body), drogon::k400BadRequest));
}
}  // namespace

void AuthController::registerCitizen(
    const drogon::HttpRequestPtr &req,
    std::function<void(const HttpResponsePtr &)> &&callback)
{
    const auto body = visione::http::requireJson(req);
    if (body.isNull())
    {
        callback(visione::http::error("invalid_json", drogon::k400BadRequest));
        return;
    }

    visione::services::AuthService service;
    serviceResponse(service.registerCitizen(body), std::move(callback));
}

void AuthController::requestOtp(
    const drogon::HttpRequestPtr &req,
    std::function<void(const HttpResponsePtr &)> &&callback)
{
    const auto body = visione::http::requireJson(req);
    if (body.isNull())
    {
        callback(visione::http::error("invalid_json", drogon::k400BadRequest));
        return;
    }

    visione::services::AuthService service;
    serviceResponse(service.requestOtp(body), std::move(callback));
}

void AuthController::verifyOtp(
    const drogon::HttpRequestPtr &req,
    std::function<void(const HttpResponsePtr &)> &&callback)
{
    const auto body = visione::http::requireJson(req);
    if (body.isNull())
    {
        callback(visione::http::error("invalid_json", drogon::k400BadRequest));
        return;
    }

    visione::services::AuthService service;
    serviceResponse(service.verifyOtp(body), std::move(callback));
}

void AuthController::startCieLogin(
    const drogon::HttpRequestPtr &req,
    std::function<void(const HttpResponsePtr &)> &&callback)
{
    const auto body = visione::http::requireJson(req);
    if (body.isNull())
    {
        callback(visione::http::error("invalid_json", drogon::k400BadRequest));
        return;
    }

    visione::services::AuthService service;
    serviceResponse(service.startCieLogin(body), std::move(callback));
}

void AuthController::completeCieLogin(
    const drogon::HttpRequestPtr &req,
    std::function<void(const HttpResponsePtr &)> &&callback)
{
    const std::string rawBody(req->body());
    const auto body = visione::http::parseJsonBody(rawBody);
    if (body.isNull())
    {
        callback(visione::http::error("invalid_json", drogon::k400BadRequest));
        return;
    }

    visione::services::AuthService service;
    auto responseBody =
        service.completeCieLogin(rawBody, body, req->getHeader("X-Visione-Signature"));
    if (responseBody.get("ok", false).asBool() &&
        responseBody.isMember("redirect_url"))
    {
        callback(visione::http::redirect(responseBody["redirect_url"].asString()));
        return;
    }
    serviceResponse(std::move(responseBody), std::move(callback));
}

void AuthController::cieSessionStatus(
    const drogon::HttpRequestPtr & /*req*/,
    std::function<void(const HttpResponsePtr &)> &&callback,
    std::string state)
{
    visione::services::AuthService service;
    auto body = service.cieSessionStatus(state);
    if (!body.get("ok", false).asBool())
    {
        callback(visione::http::json(std::move(body), drogon::k404NotFound));
        return;
    }
    callback(visione::http::json(std::move(body)));
}

void AuthController::me(
    const drogon::HttpRequestPtr &req,
    std::function<void(const HttpResponsePtr &)> &&callback)
{
    const auto user = visione::auth::authenticate(req);
    if (!user)
    {
        callback(visione::http::error("unauthorized", drogon::k401Unauthorized));
        return;
    }

    visione::services::AuthService service;
    callback(visione::http::json(service.currentUser(*user)));
}

void AuthController::editUser(
    const drogon::HttpRequestPtr &req,
    std::function<void(const drogon::HttpResponsePtr &)> &&callback) {
    const auto user = visione::auth::authenticate(req);
    if (!user)
    {
        callback(visione::http::error("unauthorized", drogon::k401Unauthorized));
        return;
    }

    const auto body = visione::http::requireJson(req);
    if (body.isNull())
    {
        callback(visione::http::error("invalid_json", drogon::k400BadRequest));
        return;
    }

    visione::services::AuthService service;
    serviceResponse(service.editUser(*user, body), std::move(callback));
}