backend/controllers/ReportController.cc

#include "controllers/ReportController.h"

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

#include <optional>

using drogon::HttpResponsePtr;

namespace
{
std::optional<std::string> queryValue(const drogon::HttpRequestPtr &req,
                                      const std::string &key)
{
    const auto value = req->getParameter(key);
    if (value.empty())
    {
        return std::nullopt;
    }
    return value;
}

std::optional<visione::auth::UserContext> requireUser(
    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 user;
}

void sendService(Json::Value body,
                 std::function<void(const HttpResponsePtr &)> &&callback)
{
    if (body.get("ok", false).asBool())
    {
        callback(visione::http::json(std::move(body)));
        return;
    }
    const auto error = body.get("error", "").asString();
    const auto status = error == "forbidden" ? drogon::k403Forbidden
                                             : drogon::k400BadRequest;
    callback(visione::http::json(std::move(body), status));
}
}  // namespace

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

    visione::services::ReportService service;
    sendService(service.createReport(*user, body), std::move(callback));
}

void ReportController::list(
    const drogon::HttpRequestPtr &req,
    std::function<void(const HttpResponsePtr &)> &&callback)
{
    auto user = requireUser(req, callback);
    if (!user)
    {
        return;
    }

    visione::services::ReportService service;
    sendService(service.listReports(*user,
                                    queryValue(req, "status"),
                                    queryValue(req, "category_id"),
                                    queryValue(req, "area_id")),
                std::move(callback));
}

void ReportController::detail(
    const drogon::HttpRequestPtr &req,
    std::function<void(const HttpResponsePtr &)> &&callback,
    long long reportId)
{
    auto user = requireUser(req, callback);
    if (!user)
    {
        return;
    }
    visione::services::ReportService service;
    sendService(service.reportDetail(*user, reportId), std::move(callback));
}

void ReportController::updateStatus(
    const drogon::HttpRequestPtr &req,
    std::function<void(const HttpResponsePtr &)> &&callback,
    long long reportId)
{
    auto user = requireUser(req, callback);
    if (!user)
    {
        return;
    }
    const auto body = visione::http::requireJson(req);
    visione::services::ReportService service;
    sendService(service.updateStatus(*user, reportId, body), std::move(callback));
}

void ReportController::addMessage(
    const drogon::HttpRequestPtr &req,
    std::function<void(const HttpResponsePtr &)> &&callback,
    long long reportId)
{
    auto user = requireUser(req, callback);
    if (!user)
    {
        return;
    }
    const auto body = visione::http::requireJson(req);
    visione::services::ReportService service;
    sendService(service.addMessage(*user, reportId, body), std::move(callback));
}

void ReportController::listMessages(
    const drogon::HttpRequestPtr &req,
    std::function<void(const HttpResponsePtr &)> &&callback,
    long long reportId)
{
    auto user = requireUser(req, callback);
    if (!user)
    {
        return;
    }
    visione::services::ReportService service;
    sendService(service.listMessages(*user, reportId), std::move(callback));
}

void ReportController::assignTeam(
    const drogon::HttpRequestPtr &req,
    std::function<void(const HttpResponsePtr &)> &&callback,
    long long reportId)
{
    auto user = requireUser(req, callback);
    if (!user)
    {
        return;
    }
    const auto body = visione::http::requireJson(req);
    visione::services::ReportService service;
    sendService(service.assignTeam(*user, reportId, body), std::move(callback));
}

void ReportController::addFeedback(
    const drogon::HttpRequestPtr &req,
    std::function<void(const HttpResponsePtr &)> &&callback,
    long long reportId)
{
    auto user = requireUser(req, callback);
    if (!user)
    {
        return;
    }
    const auto body = visione::http::requireJson(req);
    visione::services::ReportService service;
    sendService(service.addFeedback(*user, reportId, body), std::move(callback));
}