Post Diary

CMakeLists.txt

@@ -65,6 +65,7 @@ add_executable(App ./src/main.cpp
         src/DAO/MySQLUserTreatmentSchemesDAO.h
         src/endpoints_handlers/GetUserTreatmentSchemeExecutor.h
         src/endpoints_handlers/GetDiariesExecutor.h
+        src/endpoints_handlers/PostDiaryExecutor.h
         src/DAO/IDiariesDAO.h
         src/dtos/diary_dto.h
         src/DAO/MySQLDiariesDao.cpp

src/DAO/IDiariesDAO.h

@@ -12,6 +12,11 @@ class IDiariesDAO
 public:
   virtual std::vector<diary_dto> GetDiariesByUserUUID(const std::string& login) = 0;
 
+  virtual void СreateDiary(
+    const std::string& user_uuid,
+    const diary_dto& dto
+  ) const = 0;
+
   virtual ~IDiariesDAO() = default;
 };
 }

src/DAO/MySQLDiariesDAO.cpp

@@ -48,15 +48,63 @@ std::vector<diary_dto> MySqlDiariesDAO::GetDiariesByUserUUID(const std::string&
     dto.dream_level = row[7].get<int>();
     dto.anxiety_level = row[8].get<int>();
 
-    dto.comment =
+    dto.comment = row[9].get<std::string>();
-      row[9].isNull() ? "" : row[9].get<std::string>();
 
-    dto.user_treatment_scheme_uuid =
+    dto.user_treatment_scheme_uuid = row[10].get<std::string>();
-      row[10].isNull() ? "" : row[10].get<std::string>();
 
     diaries.push_back(std::move(dto));
   }
 
   return diaries;
 }
+
+void MySqlDiariesDAO::СreateDiary(const std::string& user_uuid, const diary_dto& dto) const
+{
+  auto stmt = session_.sql(R"(
+        INSERT INTO `up_and_down`.`diaries` (
+            uuid,
+            user_uuid,
+            time,
+            mania_level,
+            depression_level,
+            mood_level,
+            activity_level,
+            appetite_level,
+            dream_level,
+            anxiety_level,
+            comment,
+            user_treatment_schemes_uuid
+        ) VALUES (
+            ?,
+            ?,
+            FROM_UNIXTIME(? / 1000),
+            ?,
+            ?,
+            ?,
+            ?,
+            ?,
+            ?,
+            ?,
+            ?,
+            ?
+        )
+    )");
+
+  stmt.bind(
+      dto.uuid,
+      user_uuid,
+      dto.time_ms,
+      dto.mania_level,
+      dto.depression_level,
+      dto.mood_level,
+      dto.activity_level,
+      dto.appetite_level,
+      dto.dream_level,
+      dto.anxiety_level,
+      dto.comment,
+      dto.user_treatment_scheme_uuid
+  );
+
+  stmt.execute();
+}
 }

src/DAO/MySQLDiariesDAO.h

@@ -11,10 +11,15 @@ namespace uad
 class MySqlDiariesDAO final : public IDiariesDAO
 {
   mysqlx::Session& session_;
+
 public:
   explicit MySqlDiariesDAO(mysqlx::Session& session);
 
   std::vector<diary_dto> GetDiariesByUserUUID(const std::string& user_uuid) override;
 
+  void СreateDiary(
+    const std::string& user_uuid,
+    const diary_dto& dto
+  ) const override;
 };
-}
+}

src/endpoints_handlers/PostDiaryExecutor.h

@@ -0,0 +1,140 @@
+#pragma once
+#include <boost/log/trivial.hpp>
+
+#include <regex>
+#include <boost/json.hpp>
+#include <boost/mpl/vector/vector0.hpp>
+#include <mysqlx/xdevapi.h>
+
+#include "IExecutor.h"
+#include "../DAO/IAuthDAO.h"
+#include "../DAO/IDiariesDAO.h"
+#include "../DAO/IUserTreatmentSchemesDAO.h"
+#include "../exceptions/session_exception.h"
+
+namespace uad
+{
+template <class Body, class Allocator, class ResponseType>
+class PostDiaryExecutor : public IExecutor<Body, Allocator, ResponseType>
+{
+  mysqlx::Session& session_;
+  const std::shared_ptr<IAuthDAO>& auth_dao_;
+  const std::shared_ptr<IDiariesDAO>& diaries_dao_;
+
+public:
+  PostDiaryExecutor(
+    mysqlx::Session& session,
+    const std::shared_ptr<IAuthDAO>& auth_dao,
+    const std::shared_ptr<IDiariesDAO>& diaries_dao
+  ) : session_(session), auth_dao_(auth_dao), diaries_dao_(diaries_dao)
+  {
+  }
+
+  [[nodiscard]] boost::beast::http::response<ResponseType> operator ()(
+    boost::beast::http::request<Body, boost::beast::http::basic_fields<Allocator>>&& req
+  ) override
+  {
+    using namespace boost;
+    using namespace boost::json;
+    using namespace boost::beast;
+    using namespace std::string_literals;
+    using namespace std::string_view_literals;
+
+    constexpr std::string_view auth_prefix = "Bearer "sv;
+    static const std::string invalid_token_message =
+      "POST /api/v1/Diary - Response 401: Unauthorized"s;
+
+    BOOST_LOG_TRIVIAL(info) << "POST /api/v1/Diary - Request";
+
+    if (req[http::field::authorization].size() <= auth_prefix.size())
+    {
+      BOOST_LOG_TRIVIAL(error) << invalid_token_message;
+      throw session_exception(http::status::unauthorized, "Unauthorized");
+    }
+
+    const std::string auth_token = {
+        req[http::field::authorization].begin() + auth_prefix.size(),
+        req[http::field::authorization].end()
+      };
+
+    if (!auth_dao_->HasAuthorized(auth_token))
+    {
+      BOOST_LOG_TRIVIAL(error) << invalid_token_message;
+      throw session_exception(http::status::unauthorized, "Unauthorized");
+    }
+
+    std::string_view user_uuid_ref = auth_dao_->GetUUID(auth_token);
+    const std::string user_uuid{user_uuid_ref.begin(), user_uuid_ref.end()};
+
+    value val = json::parse(req.body());
+    object& obj = val.as_object();
+
+    diary_dto dto;
+
+    dto.uuid = obj["uuid"].as_string().c_str();
+    dto.time_ms = obj["time_ms"].as_int64();
+    dto.mania_level = obj["mania_level"].as_int64();
+    dto.depression_level = obj["depression_level"].as_int64();
+    dto.mood_level = obj["mood_level"].as_int64();
+    dto.activity_level = obj["activity_level"].as_int64();
+    dto.appetite_level = obj["appetite_level"].as_int64();
+    dto.dream_level = obj["dream_level"].as_int64();
+    dto.anxiety_level = obj["anxiety_level"].as_int64();
+
+    if (obj.contains("comment"))
+      dto.comment = obj["comment"].as_string().c_str();
+
+    if (obj.contains("user_treatment_scheme_uuid"))
+      dto.user_treatment_scheme_uuid =
+        obj["user_treatment_scheme_uuid"].as_string().c_str();
+
+    try
+    {
+      diaries_dao_->СreateDiary(user_uuid, dto);
+    }
+    catch (const mysqlx::Error& e)
+    {
+      BOOST_LOG_TRIVIAL(error) << "MySQL Error: " << e.what();
+      throw session_exception(http::status::internal_server_error, "Internal Server Error");
+    }
+    catch (const std::exception& e)
+    {
+      BOOST_LOG_TRIVIAL(error) << "Unexpected Error: " << e.what();
+      throw session_exception(http::status::internal_server_error, "Internal Server Error");
+    }
+
+    http::response<ResponseType> res{http::status::ok, req.version()};
+    value response_body;
+
+    response_body.emplace_object();
+    response_body.as_object().emplace("diary", ToJSON(dto));
+
+    res.body() = serialize(response_body);
+    res.set(http::field::content_type, "application/json");
+    res.content_length(res.body().size());
+
+    return res;
+  }
+
+private:
+  boost::json::object ToJSON(const diary_dto& diary)
+  {
+    boost::json::object diary_json;
+
+    diary_json["uuid"] = diary.uuid;
+    diary_json["time"] = diary.time_ms;
+    diary_json["mania_level"] = diary.mania_level;
+    diary_json["depression_level"] = diary.depression_level;
+    diary_json["mood_level"] = diary.mood_level;
+    diary_json["activity_level"] = diary.activity_level;
+    diary_json["appetite_level"] = diary.appetite_level;
+    diary_json["dream_level"] = diary.dream_level;
+    diary_json["anxiety_level"] = diary.anxiety_level;
+    diary_json["comment"] = diary.comment;
+    diary_json["user_treatment_scheme_uuid"] =
+      diary.user_treatment_scheme_uuid;
+
+    return diary_json;
+  }
+};
+}

src/endpoints_handlers/RootExecutor.h

@@ -12,6 +12,7 @@
 #include "PostUserTreatmentSchemeExecutor.h"
 #include "PostUserMedicationsExecutor.h"
 #include "GetDiariesExecutor.h"
+#include "PostDiaryExecutor.h"
 #include "../DAO/IUserDAO.h"
 #include "../DAO/IAuthDAO.h"
 #include "../DAO/IDiariesDAO.h"
@@ -42,6 +43,8 @@ class RootExecutor
     Body, Allocator, boost::beast::http::string_body>;
   using RouteGetDiariesExecutor = GetDiariesExecutor<
     Body, Allocator, boost::beast::http::string_body>;
+  using RoutePostDiaryExecutor = PostDiaryExecutor<
+    Body, Allocator, boost::beast::http::string_body>;
   using IRouteController = IController<Body, Allocator, boost::beast::http::string_body>;
   using RouteController = Controller<Body, Allocator, boost::beast::http::string_body>;
   using RoutesPathes = std::unordered_map<std::string, std::unique_ptr<IRouteController>>;
@@ -139,6 +142,11 @@ public:
            std::make_shared<RouteGetDiariesExecutor>(session_, auth_dao_,
                                                      diaries_dao_)
          },
+         {
+           boost::beast::http::verb::post,
+           std::make_shared<RoutePostDiaryExecutor>(session_, auth_dao_,
+                                                     diaries_dao_)
+         },
        }
       );
   }