Create repository.template

common/repositories/template/repository.template

@@ -0,0 +1,252 @@
+/**
+ * EQEmulator: Everquest Server Emulator
+ * Copyright (C) 2001-2020 EQEmulator Development Team (https://github.com/EQEmu/Server)
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY except by those people which sell it, which
+ * are required to give you total support for your newly bought product;
+ * without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+#ifndef EQEMU_{{TABLE_NAME_UPPER}}_REPOSITORY_H
+#define EQEMU_{{TABLE_NAME_UPPER}}_REPOSITORY_H
+
+#include "../database.h"
+#include "../string_util.h"
+
+class {{TABLE_NAME_CLASS}}Repository {
+public:
+	struct {{TABLE_NAME_STRUCT}} {
+{{TABLE_STRUCT_COLUMNS}}
+	};
+
+	static std::string PrimaryKey()
+	{
+		return std::string("{{PRIMARY_KEY_STRING}}");
+	}
+
+	static std::vector<std::string> Columns()
+	{
+		return {
+{{COLUMNS_LIST_QUOTED}}
+		};
+	}
+
+	static std::string ColumnsRaw()
+	{
+		return std::string(implode(", ", Columns()));
+	}
+
+	static std::string InsertColumnsRaw()
+	{
+		std::vector<std::string> insert_columns;
+
+		for (auto &column : Columns()) {
+			if (column == PrimaryKey()) {
+				continue;
+			}
+
+			insert_columns.push_back(column);
+		}
+
+		return std::string(implode(", ", insert_columns));
+	}
+
+	static std::string TableName()
+	{
+		return std::string("{{TABLE_NAME_VAR}}");
+	}
+
+	static std::string BaseSelect()
+	{
+		return fmt::format(
+			"SELECT {} FROM {}",
+			ColumnsRaw(),
+			TableName()
+		);
+	}
+
+	static std::string BaseInsert()
+	{
+		return fmt::format(
+			"INSERT INTO {} ({}) ",
+			TableName(),
+			InsertColumnsRaw()
+		);
+	}
+
+	static {{TABLE_NAME_STRUCT}} NewEntity()
+	{
+		{{TABLE_NAME_STRUCT}} entry{};
+
+{{DEFAULT_ENTRIES}}
+
+		return entry;
+	}
+
+	static {{TABLE_NAME_STRUCT}} Get{{TABLE_NAME_STRUCT}}Entry(
+		const std::vector<{{TABLE_NAME_STRUCT}}> &{{TABLE_NAME_VAR}}s,
+		int {{TABLE_NAME_VAR}}_id
+	)
+	{
+		for (auto &{{TABLE_NAME_VAR}} : {{TABLE_NAME_VAR}}s) {
+			if ({{TABLE_NAME_VAR}}.{{PRIMARY_KEY_STRING}} == {{TABLE_NAME_VAR}}_id) {
+				return {{TABLE_NAME_VAR}};
+			}
+		}
+
+		return NewEntity();
+	}
+
+	static {{TABLE_NAME_STRUCT}} FindOne(
+		int {{TABLE_NAME_VAR}}_id
+	)
+	{
+		auto results = {{DATABASE_CONNECTION}}.QueryDatabase(
+			fmt::format(
+				"{} WHERE id = {} LIMIT 1",
+				BaseSelect(),
+				{{TABLE_NAME_VAR}}_id
+			)
+		);
+
+		auto row = results.begin();
+		if (results.RowCount() == 1) {
+			{{TABLE_NAME_STRUCT}} entry{};
+
+{{FIND_ONE_ENTRIES}}
+			return entry;
+		}
+
+		return NewEntity();
+	}
+
+	static int DeleteOne(
+		int {{TABLE_NAME_VAR}}_id
+	)
+	{
+		auto results = {{DATABASE_CONNECTION}}.QueryDatabase(
+			fmt::format(
+				"DELETE FROM {} WHERE {} = {}",
+				TableName(),
+				PrimaryKey(),
+				{{TABLE_NAME_VAR}}_id
+			)
+		);
+
+		return (results.Success() ? results.RowsAffected() : 0);
+	}
+
+	static int UpdateOne(
+		{{TABLE_NAME_STRUCT}} {{TABLE_NAME_VAR}}_entry
+	)
+	{
+		std::vector<std::string> update_values;
+
+		auto columns = Columns();
+
+{{UPDATE_ONE_ENTRIES}}
+
+		auto results = {{DATABASE_CONNECTION}}.QueryDatabase(
+			fmt::format(
+				"UPDATE {} SET {} WHERE {} = {}",
+				TableName(),
+				implode(", ", update_values),
+				PrimaryKey(),
+				{{TABLE_NAME_VAR}}_entry.{{PRIMARY_KEY_STRING}}
+			)
+		);
+
+		return (results.Success() ? results.RowsAffected() : 0);
+	}
+
+	static {{TABLE_NAME_STRUCT}} InsertOne(
+		{{TABLE_NAME_STRUCT}} {{TABLE_NAME_VAR}}_entry
+	)
+	{
+		std::vector<std::string> insert_values;
+
+{{INSERT_ONE_ENTRIES}}
+
+		auto results = {{DATABASE_CONNECTION}}.QueryDatabase(
+			fmt::format(
+				"{} VALUES ({})",
+				BaseInsert(),
+				implode(",", insert_values)
+			)
+		);
+
+		if (results.Success()) {
+			{{TABLE_NAME_VAR}}_entry.id = results.LastInsertedID();
+			return {{TABLE_NAME_VAR}}_entry;
+		}
+
+		{{TABLE_NAME_VAR}}_entry = InstanceListRepository::NewEntity();
+
+		return {{TABLE_NAME_VAR}}_entry;
+	}
+
+	static int InsertMany(
+		std::vector<{{TABLE_NAME_STRUCT}}> {{TABLE_NAME_VAR}}_entries
+	)
+	{
+		std::vector<std::string> insert_chunks;
+
+		for (auto &{{TABLE_NAME_VAR}}_entry: {{TABLE_NAME_VAR}}_entries) {
+			std::vector<std::string> insert_values;
+
+{{INSERT_MANY_ENTRIES}}
+
+			insert_chunks.push_back("(" + implode(",", insert_values) + ")");
+		}
+
+		std::vector<std::string> insert_values;
+
+		auto results = {{DATABASE_CONNECTION}}.QueryDatabase(
+			fmt::format(
+				"{} VALUES {}",
+				BaseInsert(),
+				implode(",", insert_chunks)
+			)
+		);
+
+		return (results.Success() ? results.RowsAffected() : 0);
+	}
+
+	static std::vector<{{TABLE_NAME_STRUCT}}> All()
+	{
+		std::vector<{{TABLE_NAME_STRUCT}}> all_entries;
+
+		auto results = {{DATABASE_CONNECTION}}.QueryDatabase(
+			fmt::format(
+				"{}",
+				BaseSelect()
+			)
+		);
+
+		all_entries.reserve(results.RowCount());
+
+		for (auto row = results.begin(); row != results.end(); ++row) {
+			{{TABLE_NAME_STRUCT}} entry{};
+
+{{ALL_ENTRIES}}
+
+			all_entries.push_back(entry);
+		}
+
+		return all_entries;
+	}
+
+};
+
+#endif //EQEMU_{{TABLE_NAME_UPPER}}_REPOSITORY_H