Implement content flags

common/CMakeLists.txt

@@ -166,6 +166,7 @@ SET(repositories
 	repositories/base/base_char_create_point_allocations_repository.h
 	repositories/base/base_char_recipe_list_repository.h
 	repositories/base/base_completed_tasks_repository.h
+	repositories/base/base_content_flags_repository.h
 	repositories/base/base_data_buckets_repository.h
 	repositories/base/base_db_str_repository.h
 	repositories/base/base_discovered_items_repository.h
@@ -323,6 +324,7 @@ SET(repositories
 	repositories/char_create_point_allocations_repository.h
 	repositories/char_recipe_list_repository.h
 	repositories/completed_tasks_repository.h
+	repositories/content_flags_repository.h
 	repositories/data_buckets_repository.h
 	repositories/db_str_repository.h
 	repositories/discovered_items_repository.h

common/content/world_content_service.cpp

@@ -19,6 +19,10 @@
  */
 
 #include "world_content_service.h"
+#include "../database.h"
+#include "../rulesys.h"
+#include "../eqemu_logsys.h"
+
 
 WorldContentService::WorldContentService()
 {
@@ -30,6 +34,20 @@ int WorldContentService::GetCurrentExpansion() const
 	return current_expansion;
 }
 
+void WorldContentService::SetExpansionContext()
+{
+	int expansion = RuleI(Expansion, CurrentExpansion);
+	if (expansion >= Expansion::Classic && expansion <= Expansion::MaxId) {
+		content_service.SetCurrentExpansion(expansion);
+	}
+
+	LogInfo(
+		"Current expansion is [{}] ({})",
+		GetCurrentExpansion(),
+		GetCurrentExpansionName()
+	);
+}
+
 void WorldContentService::SetCurrentExpansion(int current_expansion)
 {
 	WorldContentService::current_expansion = current_expansion;

common/content/world_content_service.h

@@ -163,6 +163,7 @@ private:
 public:
 	const std::vector<std::string> &GetContentFlags() const;
 	void SetContentFlags(std::vector<std::string> content_flags);
+	void SetExpansionContext();
 };
 
 extern WorldContentService content_service;

common/database.cpp

@@ -2178,6 +2178,9 @@ uint32 Database::GetRaidIDByCharID(uint32 character_id) {
  */
 void Database::LoadLogSettings(EQEmuLogSys::LogSettings *log_settings)
 {
+
+	std::cout << "We're hitting this eh " << std::endl;
+
 	std::string query =
 					"SELECT "
 					"log_category_id, "

common/database_schema.h

@@ -248,6 +248,7 @@ namespace DatabaseSchema {
 		return {
 			"chatchannels",
 			"command_settings",
+			"content_flags",
 			"db_str",
 			"eqtime",
 			"launcher",

common/repositories/base/base_content_flags_repository.h

@@ -0,0 +1,327 @@
+/**
+ * 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
+ *
+ *
+ */
+
+/**
+ * This repository was automatically generated and is NOT to be modified directly.
+ * Any repository modifications are meant to be made to
+ * the repository extending the base. Any modifications to base repositories are to
+ * be made by the generator only
+ */
+
+#ifndef EQEMU_BASE_CONTENT_FLAGS_REPOSITORY_H
+#define EQEMU_BASE_CONTENT_FLAGS_REPOSITORY_H
+
+#include "../../database.h"
+#include "../../string_util.h"
+
+class BaseContentFlagsRepository {
+public:
+	struct ContentFlags {
+		int         id;
+		std::string flag_name;
+		int8        enabled;
+		std::string notes;
+	};
+
+	static std::string PrimaryKey()
+	{
+		return std::string("id");
+	}
+
+	static std::vector<std::string> Columns()
+	{
+		return {
+			"id",
+			"flag_name",
+			"enabled",
+			"notes",
+		};
+	}
+
+	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("content_flags");
+	}
+
+	static std::string BaseSelect()
+	{
+		return fmt::format(
+			"SELECT {} FROM {}",
+			ColumnsRaw(),
+			TableName()
+		);
+	}
+
+	static std::string BaseInsert()
+	{
+		return fmt::format(
+			"INSERT INTO {} ({}) ",
+			TableName(),
+			InsertColumnsRaw()
+		);
+	}
+
+	static ContentFlags NewEntity()
+	{
+		ContentFlags entry{};
+
+		entry.id        = 0;
+		entry.flag_name = "";
+		entry.enabled   = 0;
+		entry.notes     = "";
+
+		return entry;
+	}
+
+	static ContentFlags GetContentFlagsEntry(
+		const std::vector<ContentFlags> &content_flagss,
+		int content_flags_id
+	)
+	{
+		for (auto &content_flags : content_flagss) {
+			if (content_flags.id == content_flags_id) {
+				return content_flags;
+			}
+		}
+
+		return NewEntity();
+	}
+
+	static ContentFlags FindOne(
+		int content_flags_id
+	)
+	{
+		auto results = database.QueryDatabase(
+			fmt::format(
+				"{} WHERE id = {} LIMIT 1",
+				BaseSelect(),
+				content_flags_id
+			)
+		);
+
+		auto row = results.begin();
+		if (results.RowCount() == 1) {
+			ContentFlags entry{};
+
+			entry.id        = atoi(row[0]);
+			entry.flag_name = row[1] ? row[1] : "";
+			entry.enabled   = atoi(row[2]);
+			entry.notes     = row[3] ? row[3] : "";
+
+			return entry;
+		}
+
+		return NewEntity();
+	}
+
+	static int DeleteOne(
+		int content_flags_id
+	)
+	{
+		auto results = database.QueryDatabase(
+			fmt::format(
+				"DELETE FROM {} WHERE {} = {}",
+				TableName(),
+				PrimaryKey(),
+				content_flags_id
+			)
+		);
+
+		return (results.Success() ? results.RowsAffected() : 0);
+	}
+
+	static int UpdateOne(
+		ContentFlags content_flags_entry
+	)
+	{
+		std::vector<std::string> update_values;
+
+		auto columns = Columns();
+
+		update_values.push_back(columns[0] + " = " + std::to_string(content_flags_entry.id));
+		update_values.push_back(columns[1] + " = '" + EscapeString(content_flags_entry.flag_name) + "'");
+		update_values.push_back(columns[2] + " = " + std::to_string(content_flags_entry.enabled));
+		update_values.push_back(columns[3] + " = '" + EscapeString(content_flags_entry.notes) + "'");
+
+		auto results = database.QueryDatabase(
+			fmt::format(
+				"UPDATE {} SET {} WHERE {} = {}",
+				TableName(),
+				implode(", ", update_values),
+				PrimaryKey(),
+				content_flags_entry.id
+			)
+		);
+
+		return (results.Success() ? results.RowsAffected() : 0);
+	}
+
+	static ContentFlags InsertOne(
+		ContentFlags content_flags_entry
+	)
+	{
+		std::vector<std::string> insert_values;
+
+		insert_values.push_back(std::to_string(content_flags_entry.id));
+		insert_values.push_back("'" + EscapeString(content_flags_entry.flag_name) + "'");
+		insert_values.push_back(std::to_string(content_flags_entry.enabled));
+		insert_values.push_back("'" + EscapeString(content_flags_entry.notes) + "'");
+
+		auto results = database.QueryDatabase(
+			fmt::format(
+				"{} VALUES ({})",
+				BaseInsert(),
+				implode(",", insert_values)
+			)
+		);
+
+		if (results.Success()) {
+			content_flags_entry.id = results.LastInsertedID();
+			return content_flags_entry;
+		}
+
+		content_flags_entry = NewEntity();
+
+		return content_flags_entry;
+	}
+
+	static int InsertMany(
+		std::vector<ContentFlags> content_flags_entries
+	)
+	{
+		std::vector<std::string> insert_chunks;
+
+		for (auto &content_flags_entry: content_flags_entries) {
+			std::vector<std::string> insert_values;
+
+			insert_values.push_back(std::to_string(content_flags_entry.id));
+			insert_values.push_back("'" + EscapeString(content_flags_entry.flag_name) + "'");
+			insert_values.push_back(std::to_string(content_flags_entry.enabled));
+			insert_values.push_back("'" + EscapeString(content_flags_entry.notes) + "'");
+
+			insert_chunks.push_back("(" + implode(",", insert_values) + ")");
+		}
+
+		std::vector<std::string> insert_values;
+
+		auto results = database.QueryDatabase(
+			fmt::format(
+				"{} VALUES {}",
+				BaseInsert(),
+				implode(",", insert_chunks)
+			)
+		);
+
+		return (results.Success() ? results.RowsAffected() : 0);
+	}
+
+	static std::vector<ContentFlags> All()
+	{
+		std::vector<ContentFlags> all_entries;
+
+		auto results = database.QueryDatabase(
+			fmt::format(
+				"{}",
+				BaseSelect()
+			)
+		);
+
+		all_entries.reserve(results.RowCount());
+
+		for (auto row = results.begin(); row != results.end(); ++row) {
+			ContentFlags entry{};
+
+			entry.id        = atoi(row[0]);
+			entry.flag_name = row[1] ? row[1] : "";
+			entry.enabled   = atoi(row[2]);
+			entry.notes     = row[3] ? row[3] : "";
+
+			all_entries.push_back(entry);
+		}
+
+		return all_entries;
+	}
+
+	static std::vector<ContentFlags> GetWhere(std::string where_filter)
+	{
+		std::vector<ContentFlags> all_entries;
+
+		auto results = database.QueryDatabase(
+			fmt::format(
+				"{} WHERE {}",
+				BaseSelect(),
+				where_filter
+			)
+		);
+
+		all_entries.reserve(results.RowCount());
+
+		for (auto row = results.begin(); row != results.end(); ++row) {
+			ContentFlags entry{};
+
+			entry.id        = atoi(row[0]);
+			entry.flag_name = row[1] ? row[1] : "";
+			entry.enabled   = atoi(row[2]);
+			entry.notes     = row[3] ? row[3] : "";
+
+			all_entries.push_back(entry);
+		}
+
+		return all_entries;
+	}
+
+	static int DeleteWhere(std::string where_filter)
+	{
+		auto results = database.QueryDatabase(
+			fmt::format(
+				"DELETE FROM {} WHERE {}",
+				TableName(),
+				PrimaryKey(),
+				where_filter
+			)
+		);
+
+		return (results.Success() ? results.RowsAffected() : 0);
+	}
+
+};
+
+#endif //EQEMU_BASE_CONTENT_FLAGS_REPOSITORY_H

common/repositories/content_flags_repository.h

@@ -0,0 +1,70 @@
+/**
+ * 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_CONTENT_FLAGS_REPOSITORY_H
+#define EQEMU_CONTENT_FLAGS_REPOSITORY_H
+
+#include "../database.h"
+#include "../string_util.h"
+#include "base/base_content_flags_repository.h"
+
+class ContentFlagsRepository: public BaseContentFlagsRepository {
+public:
+
+    /**
+     * This file was auto generated and can be modified and extended upon
+     *
+     * Base repository methods are automatically
+     * generated in the "base" version of this repository. The base repository
+     * is immutable and to be left untouched, while methods in this class
+     * are used as extension methods for more specific persistence-layer
+     * accessors or mutators.
+     *
+     * Base Methods (Subject to be expanded upon in time)
+     *
+     * Note: Not all tables are designed appropriately to fit functionality with all base methods
+     *
+     * InsertOne
+     * UpdateOne
+     * DeleteOne
+     * FindOne
+     * GetWhere(std::string where_filter)
+     * DeleteWhere(std::string where_filter)
+     * InsertMany
+     * All
+     *
+     * Example custom methods in a repository
+     *
+     * ContentFlagsRepository::GetByZoneAndVersion(int zone_id, int zone_version)
+     * ContentFlagsRepository::GetWhereNeverExpires()
+     * ContentFlagsRepository::GetWhereXAndY()
+     * ContentFlagsRepository::DeleteWhereXAndY()
+     *
+     * Most of the above could be covered by base methods, but if you as a developer
+     * find yourself re-using logic for other parts of the code, its best to just make a
+     * method that can be re-used easily elsewhere especially if it can use a base repository
+     * method and encapsulate filters there
+     */
+
+	// Custom extended repository methods here
+
+};
+
+#endif //EQEMU_CONTENT_FLAGS_REPOSITORY_H

utils/scripts/generators/repository-generator.pl

@@ -100,6 +100,10 @@ if ($requested_table_to_generate eq "all" || !$requested_table_to_generate) {
     }
 }
 
+if ($requested_table_to_generate ne "all") {
+    @tables = ($requested_table_to_generate);
+}
+
 my $generated_base_repository_files = "";
 my $generated_repository_files      = "";
 

utils/sql/git/required/2020_04_11_expansions_content_filters.sql

@@ -80,3 +80,6 @@ ALTER TABLE `zone_points` ADD `content_flags` varchar(100) NULL;
 
 -- pok books
 update doors set min_expansion = 4 where name like '%POKTELE%';
+
+-- content flags
+CREATE TABLE `content_flags` (`id` int AUTO_INCREMENT,`flag_name` varchar(75),`enabled` tinyint,`notes` text, PRIMARY KEY (id));

world/main.cpp

@@ -18,6 +18,8 @@
  *
  */
 
+#define PLATFORM_WORLD 1
+
 #include "../common/global_define.h"
 
 #include <iostream>

zone/main.cpp

@@ -53,6 +53,7 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 #ifdef BOTS
 #include "bot_command.h"
 #endif
+#include "zonedb.h"
 #include "zone_config.h"
 #include "titles.h"
 #include "guild_mgr.h"
@@ -68,6 +69,7 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 #include "../common/net/eqstream.h"
 #include "../common/net/servertalk_server.h"
 #include "../common/content/world_content_service.h"
+#include "../common/repositories/content_flags_repository.h"
 
 #include <iostream>
 #include <string>
@@ -395,16 +397,22 @@ int main(int argc, char** argv) {
 		LogInfo("Initialized dynamic dictionary entries");
 	}
 
-	int current_expansion = RuleI(Expansion, CurrentExpansion);
+	content_service.SetExpansionContext();
-	if (current_expansion >= Expansion::Classic && current_expansion <= Expansion::MaxId) {
+
-		content_service.SetCurrentExpansion(current_expansion);
+	std::vector<std::string> set_content_flags;
+	auto                     content_flags = ContentFlagsRepository::GetWhere("enabled = 1");
+	set_content_flags.reserve(content_flags.size());
+
+	for (auto &flags: content_flags) {
+		set_content_flags.push_back(flags.flag_name);
+
+		LogInfo(
+			"Enabling content-flag [{}]",
+			flags.flag_name
+		);
 	}
 
-	LogInfo(
+	content_service.SetContentFlags(set_content_flags);
-		"Current expansion is [{}] ({})",
-		content_service.GetCurrentExpansion(),
-		content_service.GetCurrentExpansionName()
-	);
 
 #ifdef BOTS
 	LogInfo("Loading bot commands");