Add Visione backend foundation

controllers/AdminController.cc

@@ -0,0 +1,116 @@
+#include "controllers/AdminController.h"
+
+#include "common/Auth.h"
+#include "common/Http.h"
+#include "services/AdminService.h"
+
+using drogon::HttpResponsePtr;
+
+namespace
+{
+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 sendAdmin(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 AdminController::listCategories(
+    const drogon::HttpRequestPtr &,
+    std::function<void(const HttpResponsePtr &)> &&callback)
+{
+    visione::services::AdminService service;
+    callback(visione::http::json(service.listCategories()));
+}
+
+void AdminController::createCategory(
+    const drogon::HttpRequestPtr &req,
+    std::function<void(const HttpResponsePtr &)> &&callback)
+{
+    auto user = requireUser(req, callback);
+    if (!user)
+    {
+        return;
+    }
+    visione::services::AdminService service;
+    sendAdmin(service.createCategory(*user, visione::http::requireJson(req)),
+              std::move(callback));
+}
+
+void AdminController::listAreas(
+    const drogon::HttpRequestPtr &,
+    std::function<void(const HttpResponsePtr &)> &&callback)
+{
+    visione::services::AdminService service;
+    callback(visione::http::json(service.listAreas()));
+}
+
+void AdminController::createArea(
+    const drogon::HttpRequestPtr &req,
+    std::function<void(const HttpResponsePtr &)> &&callback)
+{
+    auto user = requireUser(req, callback);
+    if (!user)
+    {
+        return;
+    }
+    visione::services::AdminService service;
+    sendAdmin(service.createArea(*user, visione::http::requireJson(req)),
+              std::move(callback));
+}
+
+void AdminController::listTeams(
+    const drogon::HttpRequestPtr &,
+    std::function<void(const HttpResponsePtr &)> &&callback)
+{
+    visione::services::AdminService service;
+    callback(visione::http::json(service.listTeams()));
+}
+
+void AdminController::createTeam(
+    const drogon::HttpRequestPtr &req,
+    std::function<void(const HttpResponsePtr &)> &&callback)
+{
+    auto user = requireUser(req, callback);
+    if (!user)
+    {
+        return;
+    }
+    visione::services::AdminService service;
+    sendAdmin(service.createTeam(*user, visione::http::requireJson(req)),
+              std::move(callback));
+}
+
+void AdminController::overviewStats(
+    const drogon::HttpRequestPtr &req,
+    std::function<void(const HttpResponsePtr &)> &&callback)
+{
+    auto user = requireUser(req, callback);
+    if (!user)
+    {
+        return;
+    }
+    visione::services::AdminService service;
+    sendAdmin(service.overviewStats(*user), std::move(callback));
+}
+

controllers/AdminController.h

@@ -0,0 +1,46 @@
+#pragma once
+
+#include <drogon/HttpController.h>
+
+class AdminController : public drogon::HttpController<AdminController>
+{
+  public:
+    METHOD_LIST_BEGIN
+    ADD_METHOD_TO(AdminController::listCategories,
+                  "/api/v1/admin/categories",
+                  drogon::Get);
+    ADD_METHOD_TO(AdminController::createCategory,
+                  "/api/v1/admin/categories",
+                  drogon::Post);
+    ADD_METHOD_TO(AdminController::listAreas, "/api/v1/admin/areas", drogon::Get);
+    ADD_METHOD_TO(AdminController::createArea, "/api/v1/admin/areas", drogon::Post);
+    ADD_METHOD_TO(AdminController::listTeams, "/api/v1/admin/teams", drogon::Get);
+    ADD_METHOD_TO(AdminController::createTeam, "/api/v1/admin/teams", drogon::Post);
+    ADD_METHOD_TO(AdminController::overviewStats,
+                  "/api/v1/admin/stats/overview",
+                  drogon::Get);
+    METHOD_LIST_END
+
+    void listCategories(
+        const drogon::HttpRequestPtr &req,
+        std::function<void(const drogon::HttpResponsePtr &)> &&callback);
+    void createCategory(
+        const drogon::HttpRequestPtr &req,
+        std::function<void(const drogon::HttpResponsePtr &)> &&callback);
+    void listAreas(
+        const drogon::HttpRequestPtr &req,
+        std::function<void(const drogon::HttpResponsePtr &)> &&callback);
+    void createArea(
+        const drogon::HttpRequestPtr &req,
+        std::function<void(const drogon::HttpResponsePtr &)> &&callback);
+    void listTeams(
+        const drogon::HttpRequestPtr &req,
+        std::function<void(const drogon::HttpResponsePtr &)> &&callback);
+    void createTeam(
+        const drogon::HttpRequestPtr &req,
+        std::function<void(const drogon::HttpResponsePtr &)> &&callback);
+    void overviewStats(
+        const drogon::HttpRequestPtr &req,
+        std::function<void(const drogon::HttpResponsePtr &)> &&callback);
+};
+

controllers/ApiController.cc

@@ -0,0 +1,72 @@
+#include "ApiController.h"
+
+#include <drogon/drogon.h>
+#include <drogon/orm/Exception.h>
+
+#include <json/json.h>
+#include <memory>
+
+using drogon::HttpResponse;
+using drogon::HttpResponsePtr;
+using drogon::k503ServiceUnavailable;
+
+namespace
+{
+HttpResponsePtr jsonResponse(Json::Value body,
+                             drogon::HttpStatusCode status = drogon::k200OK)
+{
+    auto response = HttpResponse::newHttpJsonResponse(std::move(body));
+    response->setStatusCode(status);
+    return response;
+}
+
+Json::Value mysqlReadyBody(bool ready)
+{
+    Json::Value body;
+    body["status"] = ready ? "ready" : "not_ready";
+    body["dependencies"]["mysql"] = ready;
+    return body;
+}
+}
+
+void ApiController::health(
+    const drogon::HttpRequestPtr &,
+    std::function<void(const HttpResponsePtr &)> &&callback)
+{
+    Json::Value body;
+    body["status"] = "ok";
+    body["service"] = "visione-backend";
+
+    callback(jsonResponse(std::move(body)));
+}
+
+void ApiController::ready(
+    const drogon::HttpRequestPtr &,
+    std::function<void(const HttpResponsePtr &)> &&callback)
+{
+    auto responseCallback = std::make_shared<
+        std::function<void(const HttpResponsePtr &)>>(std::move(callback));
+
+    try
+    {
+        auto dbClient = drogon::app().getDbClient();
+        dbClient->execSqlAsync(
+            "SELECT 1",
+            [responseCallback](const drogon::orm::Result &) {
+                (*responseCallback)(jsonResponse(mysqlReadyBody(true)));
+            },
+            [responseCallback](const drogon::orm::DrogonDbException &error) {
+                auto body = mysqlReadyBody(false);
+                body["errors"]["mysql"] = error.base().what();
+                (*responseCallback)(
+                    jsonResponse(std::move(body), k503ServiceUnavailable));
+            });
+    }
+    catch (const std::exception &error)
+    {
+        auto body = mysqlReadyBody(false);
+        body["errors"]["mysql"] = error.what();
+        (*responseCallback)(
+            jsonResponse(std::move(body), k503ServiceUnavailable));
+    }
+}

controllers/ApiController.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include <drogon/HttpController.h>
+
+class ApiController : public drogon::HttpController<ApiController>
+{
+  public:
+    METHOD_LIST_BEGIN
+    ADD_METHOD_TO(ApiController::health, "/api/v1/health", drogon::Get);
+    ADD_METHOD_TO(ApiController::ready, "/api/v1/ready", drogon::Get);
+    METHOD_LIST_END
+
+    void health(const drogon::HttpRequestPtr &req,
+                std::function<void(const drogon::HttpResponsePtr &)> &&callback);
+
+    void ready(const drogon::HttpRequestPtr &req,
+               std::function<void(const drogon::HttpResponsePtr &)> &&callback);
+};

controllers/AuthController.cc

@@ -0,0 +1,98 @@
+#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::loginWithPassword(
+    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.loginWithPassword(body), std::move(callback));
+}
+
+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)));
+}
+

controllers/AuthController.h

@@ -0,0 +1,39 @@
+#pragma once
+
+#include <drogon/HttpController.h>
+
+class AuthController : public drogon::HttpController<AuthController>
+{
+  public:
+    METHOD_LIST_BEGIN
+    ADD_METHOD_TO(AuthController::registerCitizen,
+                  "/api/v1/auth/register",
+                  drogon::Post);
+    ADD_METHOD_TO(AuthController::requestOtp,
+                  "/api/v1/auth/otp/request",
+                  drogon::Post);
+    ADD_METHOD_TO(AuthController::verifyOtp,
+                  "/api/v1/auth/otp/verify",
+                  drogon::Post);
+    ADD_METHOD_TO(AuthController::loginWithPassword,
+                  "/api/v1/auth/login/password",
+                  drogon::Post);
+    ADD_METHOD_TO(AuthController::me, "/api/v1/me", drogon::Get);
+    METHOD_LIST_END
+
+    void registerCitizen(
+        const drogon::HttpRequestPtr &req,
+        std::function<void(const drogon::HttpResponsePtr &)> &&callback);
+    void requestOtp(
+        const drogon::HttpRequestPtr &req,
+        std::function<void(const drogon::HttpResponsePtr &)> &&callback);
+    void verifyOtp(
+        const drogon::HttpRequestPtr &req,
+        std::function<void(const drogon::HttpResponsePtr &)> &&callback);
+    void loginWithPassword(
+        const drogon::HttpRequestPtr &req,
+        std::function<void(const drogon::HttpResponsePtr &)> &&callback);
+    void me(const drogon::HttpRequestPtr &req,
+            std::function<void(const drogon::HttpResponsePtr &)> &&callback);
+};
+

controllers/ReportController.cc

@@ -0,0 +1,176 @@
+#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));
+}
+

controllers/ReportController.h

@@ -0,0 +1,57 @@
+#pragma once
+
+#include <drogon/HttpController.h>
+
+class ReportController : public drogon::HttpController<ReportController>
+{
+  public:
+    METHOD_LIST_BEGIN
+    ADD_METHOD_TO(ReportController::create, "/api/v1/reports", drogon::Post);
+    ADD_METHOD_TO(ReportController::list, "/api/v1/reports", drogon::Get);
+    ADD_METHOD_TO(ReportController::detail, "/api/v1/reports/{1}", drogon::Get);
+    ADD_METHOD_TO(ReportController::updateStatus,
+                  "/api/v1/reports/{1}/status",
+                  drogon::Patch);
+    ADD_METHOD_TO(ReportController::addMessage,
+                  "/api/v1/reports/{1}/messages",
+                  drogon::Post);
+    ADD_METHOD_TO(ReportController::listMessages,
+                  "/api/v1/reports/{1}/messages",
+                  drogon::Get);
+    ADD_METHOD_TO(ReportController::assignTeam,
+                  "/api/v1/reports/{1}/assignments",
+                  drogon::Post);
+    ADD_METHOD_TO(ReportController::addFeedback,
+                  "/api/v1/reports/{1}/feedback",
+                  drogon::Post);
+    METHOD_LIST_END
+
+    void create(const drogon::HttpRequestPtr &req,
+                std::function<void(const drogon::HttpResponsePtr &)> &&callback);
+    void list(const drogon::HttpRequestPtr &req,
+              std::function<void(const drogon::HttpResponsePtr &)> &&callback);
+    void detail(const drogon::HttpRequestPtr &req,
+                std::function<void(const drogon::HttpResponsePtr &)> &&callback,
+                long long reportId);
+    void updateStatus(
+        const drogon::HttpRequestPtr &req,
+        std::function<void(const drogon::HttpResponsePtr &)> &&callback,
+        long long reportId);
+    void addMessage(
+        const drogon::HttpRequestPtr &req,
+        std::function<void(const drogon::HttpResponsePtr &)> &&callback,
+        long long reportId);
+    void listMessages(
+        const drogon::HttpRequestPtr &req,
+        std::function<void(const drogon::HttpResponsePtr &)> &&callback,
+        long long reportId);
+    void assignTeam(
+        const drogon::HttpRequestPtr &req,
+        std::function<void(const drogon::HttpResponsePtr &)> &&callback,
+        long long reportId);
+    void addFeedback(
+        const drogon::HttpRequestPtr &req,
+        std::function<void(const drogon::HttpResponsePtr &)> &&callback,
+        long long reportId);
+};
+