Add has_many_to_many interface

appveyor.yml

@@ -8,7 +8,7 @@ platform:
 
 services:
   - mssql2017
-  - postgresql101
+  - postgresql13
 
 image: Visual Studio 2019
 
@@ -29,7 +29,7 @@ skip_commits:
     - .github/workflows/coverage.yml
 
 init:
-  - SET PATH=C:\Program Files\PostgreSQL\10\bin\;%PATH%
+  - SET PATH=C:\Program Files\PostgreSQL\13\bin\;%PATH%
   - psql --version
 
 branches:

examples/demo/CMakeLists.txt

@@ -7,19 +7,25 @@ ENDIF()
 
 SET (DEMO_SOURCES
   main.cpp
-  services/auth_service.cpp
-  services/auth_service.hpp
+  models/movie.hpp
+  models/person.hpp
   models/credential.hpp
   models/user.hpp
   pages/movie_page.cpp
   pages/movie_page.hpp
-  models/movie.hpp
-  models/person.hpp
-  services/movie_service.cpp
-  services/movie_service.hpp pages/main_page.cpp pages/main_page.hpp
+  pages/main_page.cpp
+  pages/main_page.hpp
   pages/crud_page.hpp
   pages/directors_page.cpp
-  pages/directors_page.hpp)
+  pages/directors_page.hpp
+  services/auth_service.cpp
+  services/auth_service.hpp
+  services/movie_service.cpp
+  services/movie_service.hpp
+  services/director_service.cpp
+  services/director_service.hpp
+  converter/object_to_json_table_converter.hpp
+  converter/object_to_json_table_converter.cpp)
 
 ADD_EXECUTABLE(demo ${DEMO_SOURCES})
 

examples/demo/converter/object_to_json_table_converter.cpp

@@ -0,0 +1,30 @@
+#include "object_to_json_table_converter.hpp"
+
+#include <matador/utils/string.hpp>
+
+using namespace matador;
+
+void object_to_json_table_converter::on_primary_key(const char * /*id*/, std::string &pk, size_t /*size*/)
+{
+  result_.push_back(create_value_information(pk, "PRIMARY_KEY"));
+}
+
+void object_to_json_table_converter::on_attribute(const char * /*id*/, bool &to, const matador::field_attributes &)
+{
+  result_.push_back(create_value_information(to, "BOOLEAN"));
+}
+
+void object_to_json_table_converter::on_attribute(const char * /*id*/, std::string &to, const matador::field_attributes &)
+{
+  result_.push_back(create_value_information(to, "STRING"));
+}
+
+void object_to_json_table_converter::on_attribute(const char * /*id*/, matador::date &to, const matador::field_attributes &)
+{
+  result_.push_back(create_value_information(to_string(to), "DATE"));
+}
+
+void object_to_json_table_converter::on_attribute(const char * /*id*/, matador::time &to, const matador::field_attributes &)
+{
+  result_.push_back(create_value_information(to_string(to), "TIME"));
+}

examples/demo/converter/object_to_json_table_converter.hpp

@@ -0,0 +1,128 @@
+#ifndef MATADOR_OBJECT_TO_JSON_TABLE_CONVERTER_HPP
+#define MATADOR_OBJECT_TO_JSON_TABLE_CONVERTER_HPP
+
+#include "matador/object/object_ptr.hpp"
+#include "matador/object/object_view.hpp"
+#include "matador/object/object_json_attribute_extractor.hpp"
+
+#include <matador/json/json.hpp>
+
+class object_to_json_table_converter
+{
+public:
+  template<typename Type>
+  matador::json to_json_table(const matador::object_ptr<Type> &obj)
+  {
+    result_ = matador::json::object();
+    matador::access::process(*this, *obj);
+    return result_;
+  }
+
+  template< typename T >
+  matador::json to_json_table(const matador::object_view<T> &objects)
+  {
+    auto result = matador::json::array();
+
+    for (const auto &obj : objects) {
+      result_ = matador::json::array();
+      matador::access::process(*this, *obj.get());
+      result.push_back(result_);
+    }
+
+    return result;
+  }
+
+  template<typename Type>
+  [[nodiscard]] matador::json create_value_information(const Type &value, const std::string &type_name) const {
+    return {
+      { "type", type_name },
+      { "value", value }
+    };
+  }
+
+  template< class V >
+  void on_primary_key(const char * /*id*/, V &pk, typename std::enable_if<std::is_integral<V>::value && !std::is_same<bool, V>::value>::type* = 0)
+  {
+    result_.push_back(create_value_information(pk, "PRIMARY_KEY"));
+  }
+  void on_primary_key(const char *id, std::string &pk, size_t /*size*/);
+
+  void on_revision(const char * /*id*/, unsigned long long &rev)
+  {
+    result_.push_back(create_value_information(rev, "INTEGER"));
+  }
+
+  template < class V >
+  void on_attribute(const char * /*id*/, V &val, const matador::field_attributes &/*attr*/ = matador::null_attributes, typename std::enable_if<std::is_integral<V>::value && !std::is_same<V, bool>::value>::type* = 0)
+  {
+    result_.push_back(create_value_information(val, "INTEGER"));
+  }
+
+  template < class V >
+  void on_attribute(const char * /*id*/, V &val, const matador::field_attributes &/*attr*/ = matador::null_attributes, typename std::enable_if<std::is_floating_point<V>::value && !std::is_same<V, bool>::value>::type* = 0)
+  {
+    result_.push_back(create_value_information(val, "REAL"));
+  }
+
+  void on_attribute(const char *id, bool &to, const matador::field_attributes &/*attr*/ = matador::null_attributes);
+  void on_attribute(const char *id, std::string &to, const matador::field_attributes &/*attr*/ = matador::null_attributes);
+  void on_attribute(const char *id, matador::date &to, const matador::field_attributes &/*attr*/ = matador::null_attributes);
+  void on_attribute(const char *id, matador::time &to, const matador::field_attributes &/*attr*/ = matador::null_attributes);
+
+  template<class V>
+  void on_belongs_to(const char * /*id*/, matador::object_ptr<V> &x, const matador::foreign_attributes &/*attr*/ = matador::default_foreign_attributes)
+  {
+    if (!x.empty()) {
+      result_.push_back(create_value_information(extractor_.extract(x, { "id", "name"}), "ENTITY"));
+    }
+  }
+  template<class V>
+  void on_has_one(const char * /*id*/, matador::object_ptr<V> &x, const matador::foreign_attributes &/*attr*/ = matador::default_foreign_attributes)
+  {
+    if (!x.empty()) {
+      result_.push_back(create_value_information(extractor_.extract(x, { "id", "name"}), "ENTITY"));
+    }
+  }
+
+  template < class V, template <class ...> class Container >
+  void on_has_many(const char *id, matador::container<V, Container> &x, const char * /*join_column*/, const matador::foreign_attributes &/*attr*/ = matador::default_foreign_attributes)
+  {
+    handle_has_many(id, x);
+  }
+
+  template < class V, template <class ...> class Container >
+  void on_has_many(const char *id, matador::container<V, Container> &x, const matador::foreign_attributes &/*attr*/ = matador::default_foreign_attributes)
+  {
+    handle_has_many(id, x);
+  }
+
+  template < class V, template <class ...> class Container >
+  void on_has_many_to_many(const char *id, matador::container<V, Container> &x, const char *, const char *, const matador::foreign_attributes &/*attr*/ = matador::default_foreign_attributes)
+  {
+    handle_has_many(id, x);
+  }
+
+  template < class V, template <class ...> class Container >
+  void on_has_many_to_many(const char *id, matador::container<V, Container> &x, const matador::foreign_attributes &/*attr*/ = matador::default_foreign_attributes)
+  {
+    handle_has_many(id, x);
+  }
+
+private:
+  template < class V, template <class ...> class Container >
+  void handle_has_many(const char *id, matador::container<V, Container> &x)
+  {
+    auto array = matador::json::array();
+    for (const auto &obj : x) {
+      array.push_back(create_value_information(extractor_.extract(obj, { "id", "name"}), "ENTITY"));
+    }
+    result_.push_back(create_value_information(array, "COLLECTION"));
+  }
+
+private:
+  matador::object_json_attribute_extractor extractor_;
+  matador::json result_;
+};
+
+
+#endif //MATADOR_OBJECT_TO_JSON_TABLE_CONVERTER_HPP

examples/demo/main.cpp

@@ -1,4 +1,6 @@
+#include "services/director_service.hpp"
 #include "services/movie_service.hpp"
+
 #include "pages/directors_page.hpp"
 #include "pages/movie_page.hpp"
 #include "pages/main_page.hpp"
@@ -12,32 +14,40 @@
 #include "matador/orm/session.hpp"
 
 #include "matador/http/http_server.hpp"
-#include "matador/http/request.hpp"
 #include "matador/http/static_file_service.hpp"
 
 #include "matador/utils/os.hpp"
 
 using namespace matador;
 
+void initialize(matador::session &s);
+
 int main(int /*argc*/, char* /*argv*/[])
 {
   try {
     // setup application logging
     matador::add_log_sink(matador::create_file_sink("log/server.log"));
     matador::add_log_sink(matador::create_stdout_sink());
 
+    const std::string dbname = "moviedb.sqlite";
+    const auto initialized = os::exists(dbname);
+
     // setup database
-    matador::persistence p("sqlite://moviedb.sqlite");
+    matador::persistence p("sqlite://" + dbname);
     p.enable_log();
 
     p.attach<person>("person");
     p.attach<movie>("movie");
 
-    p.create();
-
     // load entities
     session s(p);
-    s.load();
+    p.create();
+
+    if (!initialized) {
+      initialize(s);
+    } else {
+      s.load();
+    }
 
     // initialize network stack
     net::init();
@@ -54,7 +64,9 @@ int main(int /*argc*/, char* /*argv*/[])
     main_page mainpage(server, p);
     movie_page moviepage(server, p);
     directors_page directorpage(server, p);
+
     movie_service mservice(server, p);
+    director_service dservice(server, p);
 
     // start server
     server.run();
@@ -66,3 +78,27 @@ int main(int /*argc*/, char* /*argv*/[])
   }
   return 0;
 }
+
+void initialize(matador::session &s) {
+  auto log = matador::create_logger("Initialize");
+  object_ptr<person> steven;
+  transaction tr = s.begin();
+  try {
+    steven = s.insert(new person("Steven Spielberg", date(18, 12, 1946)));
+    s.insert(new person("George Lucas", date(14, 5, 1944)));
+    tr.commit();
+  } catch (std::exception &ex) {
+    log.error("Couldn't commit transaction: %s", ex.what());
+    tr.rollback();
+  }
+
+  tr = s.begin();
+  try {
+    s.insert(new movie("Jaws", 1974, steven));
+    s.insert(new movie("Raiders of the lost Arc", 1984, steven));
+    tr.commit();
+  } catch (std::exception &ex) {
+    log.error("Couldn't commit transaction: %s", ex.what());
+    tr.rollback();
+  }
+}

examples/demo/models/credential.hpp

@@ -13,8 +13,9 @@ struct credential
   template < class Operator >
   void process(Operator &op)
   {
-    matador::access::attribute(op, "username", username, 255);
-    matador::access::attribute(op, "password", password, 255);
+    namespace field = matador::access;
+    field::attribute(op, "username", username, 255);
+    field::attribute(op, "password", password, 255);
   }
 };
 

examples/demo/models/movie.hpp

@@ -26,7 +26,7 @@ struct movie
     : title(std::move(t)), year(y), director(dir)
   {}
 
-  unsigned long id;
+  unsigned long id{};
   std::string title;
   matador::container<e_genre> genres;
   unsigned short year {};
@@ -36,12 +36,13 @@ struct movie
   template < class Operator >
   void process(Operator &op)
   {
-    matador::access::primary_key(op, "id", id);
-    matador::access::attribute(op, "title", title, 255);
+    namespace field = matador::access;
+    field::primary_key(op, "id", id);
+    field::attribute(op, "title", title, 255);
     //serializer.serialize("genres", genres, "movie_id", "genre", matador::cascade_type::ALL);
-    matador::access::attribute(op, "year", year);
-    matador::access::has_many(op, "actors", actors, "movie_id", "actor_id", matador::cascade_type::NONE);
-    matador::access::has_one(op, "director", director, matador::cascade_type::NONE);
+    field::attribute(op, "year", year);
+    field::has_many_to_many(op, "actors", actors, "movie_id", "actor_id", matador::cascade_type::NONE);
+    field::has_one(op, "director", director, matador::cascade_type::NONE);
   }
 };
 #endif //MATADOR_MOVIE_HPP

examples/demo/models/person.hpp

@@ -8,7 +8,7 @@
 
 struct person
 {
-  unsigned long id;
+  unsigned long id{};
   std::string name;
   matador::date birthday;
 
@@ -20,9 +20,10 @@ struct person
   template < class Operator >
   void process(Operator &op)
   {
-    matador::access::primary_key(op, "id", id);
-    matador::access::attribute(op, "name", name, 255);
-    matador::access::attribute(op, "birthday", birthday);
+    namespace field = matador::access;
+    field::primary_key(op, "id", id);
+    field::attribute(op, "name", name, 255);
+    field::attribute(op, "birthday", birthday);
   }
 };
 

examples/demo/models/user.hpp

@@ -16,11 +16,12 @@ struct user
   template < class Operator >
   void process(Operator &op)
   {
-    matador::access::primary_key(op, "id", id);
-    matador::access::attribute(op, "username", username, 255);
-    matador::access::attribute(op, "password", password, 255);
-    matador::access::attribute(op, "first_name", first_name, 255);
-    matador::access::attribute(op, "last_name", last_name, 255);
+    namespace field = matador::access;
+    field::primary_key(op, "id", id);
+    field::attribute(op, "username", username, 255);
+    field::attribute(op, "password", password, 255);
+    field::attribute(op, "first_name", first_name, 255);
+    field::attribute(op, "last_name", last_name, 255);
   }
 };