[Commands] Cleanup #rules Command. (#2593)

* [Commands] Cleanup #rules Command. - Cleanup messages and logic. - Rewrite all rules logic to use `std::string` and repositories. * References * Update rules.cpp * Strings::Equal and Strings::EqualFold. * Cleanup. * Update rulesys.cpp * Update rulesys.cpp Co-authored-by: Akkadius <akkadius1@gmail.com>
2026-05-16 22:58:34 +00:00 · 2022-12-10 18:08:55 -05:00
parent 3872555332
commit b1c4e7c23f
10 changed files with 926 additions and 632 deletions
@@ -24,462 +24,451 @@
 #include <cstring>
 #include <fmt/format.h>

-/*
-	Commands:
-	#rules:
-	current -> lists current set name
-	switch (set name) -> change set in the DB, but dont reload
-	load (set name) -> load set into this zone without changing the world
-	wload (set name) -> tell world and all zones to load this rule set
-	store [set name] -> store the current rules in this zone to the set (or active if not specified)
-	reset -> reset all rule values to their defaults.
-	list [catname]
-	set (cat) (rule) (value)
-	values [catname] -> show the values of all rules in the specified category/
-*/
+#include "../common/repositories/rule_sets_repository.h"
+#include "../common/repositories/rule_values_repository.h"

-const char *RuleManager::s_categoryNames[_CatCount+1] = {
-	#define RULE_CATEGORY(catname) \
-		#catname ,
+const char *RuleManager::s_categoryNames[_CatCount + 1] = {
+	#define RULE_CATEGORY(category_name) \
+		#category_name ,
 	#include "ruletypes.h"
 	"InvalidCategory"
 };

-const RuleManager::RuleInfo RuleManager::s_RuleInfo[_IntRuleCount+_RealRuleCount+_BoolRuleCount+1] = {
+const RuleManager::RuleInfo RuleManager::s_RuleInfo[_IntRuleCount + _RealRuleCount + _BoolRuleCount + 1] = {
 	/* this is done in three steps so we can reliably get to them by index*/
-	#define RULE_INT(cat, rule, default_value, notes) \
-		{ #cat ":" #rule, Category__##cat, IntRule, Int__##rule, notes },
+	#define RULE_INT(category_name, rule_name, default_value, notes) \
+		{ #category_name ":" #rule_name, Category__##category_name, IntRule, Int__##rule_name, notes },
 	#include "ruletypes.h"
-	#define RULE_REAL(cat, rule, default_value, notes) \
-		{ #cat ":" #rule, Category__##cat, RealRule, Real__##rule, notes },
+	#define RULE_REAL(category_name, rule_name, default_value, notes) \
+		{ #category_name ":" #rule_name, Category__##category_name, RealRule, Real__##rule_name, notes },
 	#include "ruletypes.h"
-	#define RULE_BOOL(cat, rule, default_value, notes) \
-		{ #cat ":" #rule, Category__##cat, BoolRule, Bool__##rule, notes },
+	#define RULE_BOOL(category_name, rule_name, default_value, notes) \
+		{ #category_name ":" #rule_name, Category__##category_name, BoolRule, Bool__##rule_name, notes },
 	#include "ruletypes.h"
 	{ "Invalid Rule", _CatCount, IntRule }
 };

 RuleManager::RuleManager()
-:	m_activeRuleset(0),
-	m_activeName("default")
+	: m_activeRuleset(0),
+	  m_activeName("default")
 {
 	ResetRules(false);
 }

-RuleManager::CategoryType RuleManager::FindCategory(const char *catname) {
-	int i;
-	for (i = 0; i < _CatCount; i++) {
-		if (strcasecmp(catname, s_categoryNames[i]) == 0)
-			return((CategoryType)i);
-	}
-	return(InvalidCategory);
-}
-
-bool RuleManager::ListRules(const char *catname, std::vector<const char *> &into) {
-	CategoryType cat = InvalidCategory;
-	if (catname != nullptr) {
-		cat = FindCategory(catname);
-		if (cat == InvalidCategory) {
-			Log(Logs::Detail, Logs::Rules, "Unable to find category '%s'", catname);
-			return(false);
+RuleManager::CategoryType RuleManager::FindCategory(const std::string &category_name)
+{
+	for (int i = 0; i < _CatCount; i++) {
+		if (Strings::Contains(category_name, s_categoryNames[i])) {
+			return static_cast<CategoryType>(i);
 		}
 	}
-	int i;
-	int rule_count = CountRules();
-	for (i = 0; i < rule_count; i++) {
-		const RuleInfo &rule = s_RuleInfo[i];
-		if (catname == nullptr || cat == rule.category) {
-			into.push_back(rule.name);
+
+	return InvalidCategory;
+}
+
+bool RuleManager::ListRules(const std::string &category_name, std::vector<std::string> &l)
+{
+	CategoryType category_type = InvalidCategory;
+	if (!category_name.empty()) {
+		category_type = FindCategory(category_name);
+		if (category_type == InvalidCategory) {
+			LogRulesDetail("Unable to find category '{}'.", category_name);
+			return false;
 		}
 	}
-	return(true);
-}

-bool RuleManager::ListCategories(std::vector<const char *> &into) {
-	int i;
-	for (i = 0; i < _CatCount; i++) {
-		into.push_back(s_categoryNames[i]);
+	for (int i = 0; i < CountRules(); i++) {
+		const auto& r = s_RuleInfo[i];
+		if (category_name.empty() || category_type == r.category) {
+			l.push_back(r.name);
+		}
 	}
-	return(true);
-}
-
-bool RuleManager::GetRule(const char *rule_name, std::string &return_value) {
-	RuleType type;
-	uint16 index;
-	if (!_FindRule(rule_name, type, index))
-		return false;
-
-	char tmp[255] = "";
-	switch(type) {
-		case IntRule:
-			sprintf(tmp, "%i", m_RuleIntValues[index]);
-			break;
-		case RealRule:
-			sprintf(tmp, "%f", m_RuleRealValues[index]);
-			break;
-		case BoolRule:
-			std::string tmp_val = m_RuleBoolValues[index] ? "true" : "false";
-			sprintf(tmp, "%s", tmp_val.c_str());
-			break;
-	}
-
-	return_value = tmp;

 	return true;
 }

-bool RuleManager::SetRule(const char *rule_name, const char *rule_value, Database *database, bool db_save, bool reload) {
-	if(rule_name == nullptr || rule_value == nullptr)
-		return(false);
+bool RuleManager::ListCategories(std::vector <std::string> &l)
+{
+	for (int i = 0; i < _CatCount; i++) {
+		l.push_back(s_categoryNames[i]);
+	}
+
+	return true;
+}
+
+bool RuleManager::GetRule(const std::string &rule_name, std::string &rule_value)
+{
+	RuleType type;
+	uint16 index;
+	if (!_FindRule(rule_name, type, index)) {
+		return false;
+	}
+
+	switch (type) {
+		case IntRule:
+			rule_value = fmt::format("{}", m_RuleIntValues[index]);
+			break;
+		case RealRule:
+			rule_value = fmt::format("{}", m_RuleRealValues[index]);
+			break;
+		case BoolRule:
+			rule_value = m_RuleBoolValues[index] ? "true" : "false";
+			break;
+	}
+
+	return true;
+}
+
+bool RuleManager::SetRule(const std::string &rule_name, const std::string &rule_value, Database *db, bool db_save, bool reload)
+{
+	if (rule_name.empty() || rule_value.empty()) {
+		return false;
+	}

 	RuleType type;
 	uint16 index;
-	if(!_FindRule(rule_name, type, index))
-		return(false);
-
-	if (reload) {
-		if (strcasecmp(rule_name, "World:ExpansionSettings") == 0)
-			return(false);
-		if (strcasecmp(rule_name, "World:UseClientBasedExpansionSettings") == 0)
-			return(false);
+	if (!_FindRule(rule_name, type, index)) {
+		return (false);
 	}

-	switch(type) {
+	if (reload) {
+		bool is_client = Strings::EqualFold(rule_name, "World:UseClientBasedExpansionSettings");
+		bool is_world = Strings::EqualFold(rule_name, "World:ExpansionSettings");
+		if (is_client || is_world) {
+			return false;
+		}
+	}
+
+	switch (type) {
 		case IntRule:
-			m_RuleIntValues[index] = atoi(rule_value);
+			m_RuleIntValues[index] = atoi(rule_value.c_str());
 			LogRules("Set rule [{}] to value [{}]", rule_name, m_RuleIntValues[index]);
 			break;
 		case RealRule:
-			m_RuleRealValues[index] = atof(rule_value);
-			LogRules("Set rule [{}] to value [{}]", rule_name, m_RuleRealValues[index]);
+			m_RuleRealValues[index] = atof(rule_value.c_str());
+			LogRules("Set rule [{}] to value [{:.2f}]", rule_name, m_RuleRealValues[index]);
 			break;
 		case BoolRule:
-			uint32 val = 0;
-			if (!strcasecmp(rule_value, "on") || !strcasecmp(rule_value, "true") || !strcasecmp(rule_value, "yes") || !strcasecmp(rule_value, "enabled") || !strcmp(rule_value, "1"))
-				val = 1;
-
-			m_RuleBoolValues[index] = val;
+			m_RuleBoolValues[index] = static_cast<uint32>(Strings::ToBool(rule_value));
 			LogRules("Set rule [{}] to value [{}]", rule_name, m_RuleBoolValues[index] == 1 ? "true" : "false");
 			break;
 	}

-	if(db_save)
-		_SaveRule(database, type, index);
+	if (db_save) {
+		_SaveRule(db, type, index);
+	}

-	return(true);
+	return true;
 }

 void RuleManager::ResetRules(bool reload) {
-	std::string expansion1;
-	std::string expansion2;
+	std::string client_rule;
+	std::string world_rule;

 	// these rules must not change during server runtime
 	if (reload) {
-		GetRule("World:ExpansionSettings", expansion1);
-		GetRule("World:UseClientBasedExpansionSettings", expansion2);
+		GetRule("World:UseClientBasedExpansionSettings", client_rule);
+		GetRule("World:ExpansionSettings", world_rule);
 	}

-	Log(Logs::Detail, Logs::Rules, "Resetting running rules to default values");
-	#define RULE_INT(cat, rule, default_value, notes) \
-		m_RuleIntValues[ Int__##rule ] = default_value;
-	#define RULE_REAL(cat, rule, default_value, notes) \
-		m_RuleRealValues[ Real__##rule ] = default_value;
-	#define RULE_BOOL(cat, rule, default_value, notes) \
-		m_RuleBoolValues[ Bool__##rule ] = default_value;
+	LogRulesDetail("Resetting running rules to default values.");
+
+	#define RULE_INT(category_name, rule_name, default_value, notes) \
+		m_RuleIntValues[ Int__##rule_name ] = default_value;
+	#define RULE_REAL(category_name, rule_name, default_value, notes) \
+		m_RuleRealValues[ Real__##rule_name ] = default_value;
+	#define RULE_BOOL(category_name, rule_name, default_value, notes) \
+		m_RuleBoolValues[ Bool__##rule_name ] = default_value;
 	#include "ruletypes.h"

 	// restore these rules to their pre-reset values
 	if (reload) {
-		SetRule("World:ExpansionSettings", expansion1.c_str(), nullptr, false, false);
-		SetRule("World:UseClientBasedExpansionSettings", expansion2.c_str(), nullptr, false, false);
+		SetRule("World:UseClientBasedExpansionSettings", client_rule);
+		SetRule("World:ExpansionSettings", world_rule);
 	}
 }

-bool RuleManager::_FindRule(const char *rule_name, RuleType &type_into, uint16 &index_into) {
-	if (rule_name == nullptr)
-		return(false);
+bool RuleManager::_FindRule(const std::string &rule_name, RuleType &type_into, uint16 &index_into) {
+	if (rule_name.empty()) {
+		return false;
+	}

-	int i;
-	int rule_count = CountRules();
-	for (i = 0; i < rule_count; i++) {
-		const RuleInfo &rule = s_RuleInfo[i];
-		if (strcmp(rule_name, rule.name) == 0) {
-			type_into = rule.type;
-			index_into = rule.rule_index;
-			return(true);
+	for (int i = 0; i < CountRules(); i++) {
+		const auto& r = s_RuleInfo[i];
+		if (rule_name == r.name) {
+			type_into = r.type;
+			index_into = r.rule_index;
+			return true;
 		}
 	}
-	Log(Logs::Detail, Logs::Rules, "Unable to find rule '%s'", rule_name);
-	return(false);
+
+	LogRulesDetail("Unable to find rule '{}'.", rule_name);
+	return false;
 }

 //assumes index is valid!
-const char *RuleManager::_GetRuleName(RuleType type, uint16 index) {
+std::string RuleManager::_GetRuleName(RuleType type, uint16 index) {
 	switch (type) {
-	case IntRule:
-		return(s_RuleInfo[index].name);
-	case RealRule:
-		return(s_RuleInfo[index+_IntRuleCount].name);
-	case BoolRule:
-		return(s_RuleInfo[index+_IntRuleCount+_RealRuleCount].name);
-	default:
-		break;
+		case IntRule:
+			return s_RuleInfo[index].name;
+		case RealRule:
+			return s_RuleInfo[index + _IntRuleCount].name;
+		case BoolRule:
+			return s_RuleInfo[index + _IntRuleCount + _RealRuleCount].name;
+		default:
+			break;
 	}
-	//should never happen
-	return(s_RuleInfo[_IntRuleCount+_RealRuleCount+_BoolRuleCount].name); // no need to create a string when one already exists...
+
+	return s_RuleInfo[_IntRuleCount + _RealRuleCount + _BoolRuleCount].name;
 }

 //assumes index is valid!
 const std::string &RuleManager::_GetRuleNotes(RuleType type, uint16 index) {
 	switch (type) {
-	case IntRule:
-		return(s_RuleInfo[index].notes);
-	case RealRule:
-		return(s_RuleInfo[index+_IntRuleCount].notes);
-	case BoolRule:
-		return(s_RuleInfo[index+_IntRuleCount+_RealRuleCount].notes);
-	default:
-		break;
+		case IntRule:
+			return s_RuleInfo[index].notes;
+		case RealRule:
+			return s_RuleInfo[index + _IntRuleCount].notes;
+		case BoolRule:
+			return s_RuleInfo[index + _IntRuleCount + _RealRuleCount].notes;
+		default:
+			break;
 	}
-	//should never happen
-	return(s_RuleInfo[_IntRuleCount+_RealRuleCount+_BoolRuleCount].notes);
+
+	return s_RuleInfo[_IntRuleCount + _RealRuleCount + _BoolRuleCount].notes;
 }

-bool RuleManager::LoadRules(Database *database, const char *ruleset_name, bool reload) {
-
-	int ruleset_id = GetRulesetID(database, ruleset_name);
-	if (ruleset_id < 0) {
-		Log(Logs::Detail, Logs::Rules, "Failed to find ruleset '%s' for load operation. Canceling.", ruleset_name);
-		return (false);
+bool RuleManager::LoadRules(Database *db, const std::string &rule_set_name, bool reload) {
+	const auto rule_set_id = RuleSetsRepository::GetRuleSetID(*db, rule_set_name);
+	if (rule_set_id < 0) {
+		LogRulesDetail("Failed to find Rule Set {} for load operation. Canceling.", rule_set_name);
+		return false;
 	}

-	m_activeRuleset = ruleset_id;
-	m_activeName = ruleset_name;
+	m_activeRuleset = rule_set_id;
+	m_activeName = rule_set_name;

 	/* Load default ruleset values first if we're loading something other than default */
-	if (strcasecmp(ruleset_name, "default") != 0) {

-		std::string default_ruleset_name = "default";
-		int         default_ruleset_id = GetRulesetID(database, default_ruleset_name.c_str());
+	const std::string default_ruleset_name = "default";
+	bool is_default = rule_set_name == default_ruleset_name;

-		if (default_ruleset_id < 0) {
-			Log(Logs::Detail,
-				Logs::Rules,
-				"Failed to find default ruleset '%s' for load operation. Canceling.",
-				default_ruleset_name.c_str()
+	if (!is_default) {
+		const auto default_rule_set_id = RuleSetsRepository::GetRuleSetID(*db, default_ruleset_name);
+
+		if (default_rule_set_id < 0) {
+			LogRulesDetail(
+				"Failed to load default Rule Set {} for load operation.",
+				default_ruleset_name
 			);

-			return (false);
-		}
-
-		Log(Logs::Detail, Logs::Rules, "Processing rule set '%s' (%d) load...", default_ruleset_name.c_str(), default_ruleset_id);
-
-		std::string query = StringFormat(
-			"SELECT `rule_name`, `rule_value` FROM `rule_values` WHERE `ruleset_id` = %d",
-			default_ruleset_id
-		);
-
-		auto results = database->QueryDatabase(query);
-		if (!results.Success()) {
 			return false;
 		}

-		for (auto row = results.begin(); row != results.end(); ++row) {
-			if (!SetRule(row[0], row[1], nullptr, false, reload)) {
-				Log(Logs::Detail, Logs::Rules, "Unable to interpret rule record for '%s'", row[0]);
+		LogRulesDetail("Loading Rule Set {} ({}).", default_ruleset_name, default_rule_set_id);
+
+		const auto& l = RuleValuesRepository::GetWhere(
+			*db,
+			fmt::format(
+				"ruleset_id = {}",
+				default_rule_set_id
+			)
+		);
+		if (l.empty()) {
+			return false;
+		}
+
+		for (const auto& e : l) {
+			if (!SetRule(e.rule_name, e.rule_value, nullptr, false, reload)) {
+				LogRulesDetail("Unable to interpret rule record for '{}'.", e.rule_name);
 			}
 		}
 	}

-	Log(Logs::Detail, Logs::Rules, "Processing rule set '%s' (%d) load...", ruleset_name, ruleset_id);
+	LogRulesDetail("Loading Rule Set {} ({}).", rule_set_name, rule_set_id);

-	std::string query = StringFormat("SELECT `rule_name`, `rule_value` FROM `rule_values` WHERE `ruleset_id` = %d", ruleset_id);
-
-	auto results = database->QueryDatabase(query);
-	if (!results.Success()) {
+	const auto& l = RuleValuesRepository::GetWhere(
+		*db,
+		fmt::format(
+			"ruleset_id = {}",
+			rule_set_id
+		)
+	);
+	if (l.empty()) {
 		return false;
 	}

-	for (auto row = results.begin(); row != results.end(); ++row) {
-		if (!SetRule(row[0], row[1], nullptr, false, reload)) {
-			Log(Logs::Detail, Logs::Rules, "Unable to interpret rule record for '%s'", row[0]);
+	for (const auto& e : l) {
+		if (!SetRule(e.rule_name, e.rule_value, nullptr, false, reload)) {
+			LogRulesDetail("Unable to interpret Rule record for Rule '{}'.", e.rule_name);
 		}
 	}

 	return true;
 }

-void RuleManager::SaveRules(Database *database, const char *ruleset_name) {
-
-	if (ruleset_name != nullptr) {
-		//saving to a specific name
-		if (m_activeName != ruleset_name) {
-			//a new name...
-
-			m_activeRuleset = _FindOrCreateRuleset(database, ruleset_name);
+void RuleManager::SaveRules(Database *db, const std::string &rule_set_name) {
+	if (!rule_set_name.empty()) {
+		if (m_activeName != rule_set_name) {
+			m_activeRuleset = _FindOrCreateRuleset(db, rule_set_name);
 			if (m_activeRuleset == -1) {
-				Log(Logs::Detail, Logs::Rules, "Unable to find or create rule set %s", ruleset_name);
+				LogRulesDetail("Unable to find or create Rule Set {}.", rule_set_name);
 				return;
 			}
-			m_activeName = ruleset_name;
+
+			m_activeName = rule_set_name;
 		}
-		Log(Logs::Detail, Logs::Rules, "Saving running rules into rule set %s (%d)", ruleset_name, m_activeRuleset);
-	}
-	else {
-		Log(Logs::Detail, Logs::Rules, "Saving running rules into running rule set %s", m_activeName.c_str(), m_activeRuleset);
+
+		LogRulesDetail("Saving running rules into Rule Set {} ({}).", rule_set_name, m_activeRuleset);
+	} else {
+		LogRulesDetail("Saving running rules into running Rule Set {} ({}).", m_activeName, m_activeRuleset);
 	}

 	int i;
 	for (i = 0; i < _IntRuleCount; i++) {
-		_SaveRule(database, IntRule, i);
+		_SaveRule(db, IntRule, i);
 	}
+
 	for (i = 0; i < _RealRuleCount; i++) {
-		_SaveRule(database, RealRule, i);
+		_SaveRule(db, RealRule, i);
 	}
+
 	for (i = 0; i < _BoolRuleCount; i++) {
-		_SaveRule(database, BoolRule, i);
+		_SaveRule(db, BoolRule, i);
 	}
 }

-void RuleManager::_SaveRule(Database *database, RuleType type, uint16 index) {
-	char value_string[100];
+void RuleManager::_SaveRule(Database *db, RuleType type, uint16 index) {
+	const auto rule_name = _GetRuleName(type, index);

-	if (type == IntRule && strcasecmp(_GetRuleName(type, index), "World:ExpansionSettings") == 0)
-		return;
-	if (type == BoolRule && strcasecmp(_GetRuleName(type, index), "World:UseClientBasedExpansionSettings") == 0)
+	if (
+		(type == BoolRule && Strings::EqualFold(rule_name, "World:UseClientBasedExpansionSettings")) ||
+		(type == IntRule && Strings::EqualFold(rule_name, "World:ExpansionSettings"))
+	) {
 		return;
+	}
+
+	std::string rule_value;

 	switch (type) {
 		case IntRule:
-			sprintf(value_string, "%d", m_RuleIntValues[index]);
+			rule_value = fmt::format("{}", m_RuleIntValues[index]);
 			break;
 		case RealRule:
-			sprintf(value_string, "%.13f", m_RuleRealValues[index]);
+			rule_value = fmt::format("{:.13f}", m_RuleRealValues[index]);
 			break;
 		case BoolRule:
-			sprintf(value_string, "%s", m_RuleBoolValues[index] ? "true" : "false");
+			rule_value = m_RuleBoolValues[index] ? "true" : "false";
 			break;
 	}

-	std::string query = StringFormat(
-			"REPLACE INTO `rule_values`"
-			"(`ruleset_id`, `rule_name`, `rule_value`, `notes`)"
-			" VALUES('%d', '%s', '%s', '%s')",
+	const auto rule_notes = _GetRuleNotes(type, index);
+
+	const auto& l = RuleValuesRepository::GetWhere(
+		*db,
+		fmt::format(
+			"ruleset_id = {} AND rule_name = '{}' LIMIT 1",
 			m_activeRuleset,
-			_GetRuleName(type, index),
-			value_string,
-			Strings::Escape(_GetRuleNotes(type, index)).c_str()
+			rule_name
+		)
 	);

-	database->QueryDatabase(query);
+	if (!l.empty()) {
+		auto e = l[0];
+		e.rule_value = rule_value;
+		e.notes      = rule_notes;
+
+		RuleValuesRepository::UpdateOne(*db, e);
+		return;
+	}
+
+	auto e = RuleValuesRepository::NewEntity();
+
+	e.ruleset_id = m_activeRuleset;
+	e.rule_name  = _GetRuleName(type, index);
+	e.rule_value = rule_value;
+	e.notes      = rule_notes;
+
+	RuleValuesRepository::InsertOne(*db, e);
 }

-bool RuleManager::UpdateInjectedRules(Database *db, const char *ruleset_name, bool quiet_update)
+bool RuleManager::UpdateInjectedRules(Database *db, const std::string &rule_set_name, bool quiet_update)
 {
-	std::vector<std::string> database_data;
-	std::map<std::string, std::pair<std::string, const std::string *>> rule_data;
+	std::map<std::string, std::pair<std::string, const std::string *>>  rule_data;
 	std::vector<std::tuple<int, std::string, std::string, std::string>> injected_rule_entries;

-	if (ruleset_name == nullptr) {
+	if (rule_set_name.empty()) {
 		return false;
 	}

-	int ruleset_id = GetRulesetID(db, ruleset_name);
-	if (ruleset_id < 0) {
+	const auto rule_set_id = RuleSetsRepository::GetRuleSetID(*db, rule_set_name);
+	if (rule_set_id < 0) {
 		return false;
 	}

-	// load database rule names
-	std::string query(StringFormat("SELECT `rule_name` FROM `rule_values` WHERE `ruleset_id` = '%i'", ruleset_id));
-
-	auto results = db->QueryDatabase(query);
-	if (!results.Success()) {
+	const auto& v = RuleValuesRepository::GetRuleNames(*db, rule_set_id);
+	if (v.empty()) {
 		return false;
 	}

-	// build database data entries
-	for (auto row : results) {
-		database_data.push_back(std::string(row[0]));
-	}
-
 	// build rule data entries
-	for (const auto &ri_iter : s_RuleInfo) {
-		if (strcasecmp(ri_iter.name, "Invalid Rule") == 0) {
+	for (const auto& r : s_RuleInfo) {
+		if (Strings::EqualFold(r.name, "Invalid Rule")) {
 			continue;
 		}

-		char buffer[100];
-
-		switch (ri_iter.type) {
-		case IntRule:
-			sprintf(buffer, "%d", m_RuleIntValues[ri_iter.rule_index]);
-			rule_data[ri_iter.name].first = buffer;
-			rule_data[ri_iter.name].second = &ri_iter.notes;
-			break;
-		case RealRule:
-			sprintf(buffer, "%.13f", m_RuleRealValues[ri_iter.rule_index]);
-			rule_data[ri_iter.name].first = buffer;
-			rule_data[ri_iter.name].second = &ri_iter.notes;
-			break;
-		case BoolRule:
-			sprintf(buffer, "%s", (m_RuleBoolValues[ri_iter.rule_index] ? "true" : "false"));
-			rule_data[ri_iter.name].first = buffer;
-			rule_data[ri_iter.name].second = &ri_iter.notes;
-			break;
-		default:
-			break;
+		switch (r.type) {
+			case IntRule:
+				rule_data[r.name].first = fmt::format("{}", m_RuleIntValues[r.rule_index]);
+				rule_data[r.name].second = &r.notes;
+				break;
+			case RealRule:
+				rule_data[r.name].first = fmt::format("{:.13f}", m_RuleRealValues[r.rule_index]);
+				rule_data[r.name].second = &r.notes;
+				break;
+			case BoolRule:
+				rule_data[r.name].first = fmt::format("{}", m_RuleBoolValues[r.rule_index] ? "true" : "false");
+				rule_data[r.name].second = &r.notes;
+				break;
+			default:
+				break;
 		}
 	}

 	// build injected entries
-	for (const auto &rd_iter : rule_data) {
-
-		const auto &dd_iter = std::find(database_data.begin(), database_data.end(), rd_iter.first);
-		if (dd_iter == database_data.end()) {
-
+	for (const auto &d : rule_data) {
+		if (std::find(v.begin(), v.end(), d.first) == v.end()) {
 			injected_rule_entries.push_back(
 				std::tuple<int, std::string, std::string, std::string>(
-					ruleset_id,								// `ruleset_id`
-					rd_iter.first,							// `rule_name`
-					rd_iter.second.first,					// `rule_value`
-					Strings::Escape(*rd_iter.second.second)	// `notes`
+					rule_set_id,
+					d.first,
+					d.second.first,
+					Strings::Escape(*d.second.second)
 				)
 			);

 			if (!quiet_update) {
 				LogInfo(
 					"Adding new rule [{}] ruleset [{}] ({}) value [{}]",
-					rd_iter.first.c_str(),
-					ruleset_name,
-					ruleset_id,
-					rd_iter.second.first.c_str()
+					d.first,
+					rule_set_name,
+					rule_set_id,
+					d.second.first
 				);
 			}
 		}
 	}

 	if (injected_rule_entries.size()) {
-
-		std::string query(
-			fmt::format(
-				"REPLACE INTO `rule_values`(`ruleset_id`, `rule_name`, `rule_value`, `notes`) VALUES {}",
-				Strings::ImplodePair(
-					",",
-					std::pair<char, char>('(', ')'),
-					join_tuple(",", std::pair<char, char>('\'', '\''), injected_rule_entries)
-				)
-			)
-		);
-
-		if (!db->QueryDatabase(query).Success()) {
+		if (!RuleValuesRepository::InjectRules(*db, injected_rule_entries)) {
 			return false;
 		}

 		LogInfo(
 			"[{}] New rule(s) added to ruleset [{}] [{}]",
 			injected_rule_entries.size(),
-			ruleset_name,
-			ruleset_id
+			rule_set_name,
+			rule_set_id
 		);
 	}

@@ -491,50 +480,36 @@ bool RuleManager::UpdateOrphanedRules(Database *db, bool quiet_update)
 	std::vector<std::string> rule_data;
 	std::vector<std::string> orphaned_rule_entries;

-	// load database rule names
-	std::string query("SELECT `rule_name` FROM `rule_values` GROUP BY `rule_name`");
-
-	auto results = db->QueryDatabase(query);
-	if (!results.Success()) {
+	const auto& l = RuleValuesRepository::GetGroupedRules(*db);
+	if (l.empty()) {
 		return false;
 	}

 	// build rule data entries
-	for (const auto &ri_iter : s_RuleInfo) {
-		if (strcasecmp(ri_iter.name, "Invalid Rule") == 0) {
+	for (const auto &r : s_RuleInfo) {
+		if (Strings::EqualFold(r.name, "Invalid Rule")) {
 			continue;
 		}

-		rule_data.push_back(ri_iter.name);
+		rule_data.push_back(r.name);
 	}

-	// build orphaned entries
-	for (auto row : results) {
-
-		const auto &rd_iter = std::find(rule_data.begin(), rule_data.end(), row[0]);
-		if (rd_iter == rule_data.end()) {
-
-			orphaned_rule_entries.push_back(std::string(row[0]));
+	for (const auto& e : l) {
+		const auto &d = std::find(rule_data.begin(), rule_data.end(), e);
+		if (d == rule_data.end()) {
+			orphaned_rule_entries.push_back(e);

 			if (!quiet_update) {
 				LogInfo(
 					"Rule [{}] no longer exists... Deleting orphaned entry from `rule_values` table...",
-					row[0]
+					e
 				);
 			}
 		}
 	}

 	if (orphaned_rule_entries.size()) {
-
-		std::string query (
-			fmt::format(
-				"DELETE FROM `rule_values` WHERE `rule_name` IN ({})",
-				Strings::ImplodePair(",", std::pair<char, char>('\'', '\''), orphaned_rule_entries)
-			)
-		);
-
-		if (!db->QueryDatabase(query).Success()) {
+		if (!RuleValuesRepository::DeleteOrphanedRules(*db, orphaned_rule_entries)) {
 			return false;
 		}

@@ -546,139 +521,83 @@ bool RuleManager::UpdateOrphanedRules(Database *db, bool quiet_update)

 bool RuleManager::RestoreRuleNotes(Database *db)
 {
-	std::string query("SELECT `ruleset_id`, `rule_name`, `notes` FROM `rule_values`");
-
-	auto results = db->QueryDatabase(query);
-	if (!results.Success()) {
+	const auto& l = RuleValuesRepository::All(*db);
+	if (l.empty()) {
 		return false;
 	}

 	int update_count = 0;
-	for (auto row = results.begin(); row != results.end(); ++row) {
-
-		auto rule = [](const char *rule_name) {
+	for (const auto& e : l) {

+		auto rule = [](std::string rule_name) {
 			for (auto rule_iter : s_RuleInfo) {
-				if (strcasecmp(rule_iter.name, rule_name) == 0) {
+				if (Strings::EqualFold(rule_iter.name, rule_name)) {
 					return rule_iter;
 				}
 			}

-			return s_RuleInfo[_IntRuleCount+_RealRuleCount+_BoolRuleCount];
-		}(row[1]);
+			return s_RuleInfo[_IntRuleCount + _RealRuleCount + _BoolRuleCount];
+		}(e.rule_name);

-		if (strcasecmp(rule.name, row[1]) != 0) {
+		if (Strings::Contains(rule.name, e.rule_name)) {
 			continue;
 		}

-		if (row[2] != nullptr && rule.notes.compare(row[2]) == 0) {
+		if (!e.notes.empty() && !rule.notes.compare(e.notes)) {
 			continue;
 		}

-		std::string query(
-			fmt::format(
-				"UPDATE `rule_values` SET `notes` = '{}' WHERE `ruleset_id` = '{}' AND `rule_name` = '{}'",
-				Strings::Escape(rule.notes),
-				row[0],
-				row[1]
-			)
-		);
-
-		if (!db->QueryDatabase(query).Success()) {
+		if (!RuleValuesRepository::UpdateRuleNote(*db, e.ruleset_id, e.rule_name, rule.notes)) {
 			continue;
 		}

 		++update_count;
 	}

-	if (update_count > 0) {
-		LogInfo("[{}] Rule Note [{}] Restored", update_count, (update_count == 1 ? "" : "s"));
+	if (update_count) {
+		LogInfo("[{}] Rule Note{} Restored", update_count, update_count != 1 ? "s" : "");
 	}

 	return true;
 }

-int RuleManager::GetRulesetID(Database *database, const char *ruleset_name) {
+int RuleManager::_FindOrCreateRuleset(Database *db, const std::string &rule_set_name)
+{
+	const auto rule_set_id = RuleSetsRepository::GetRuleSetID(*db, rule_set_name);
+	if (rule_set_id >= 0) {
+		return rule_set_id;
+	}

-	uint32 len = static_cast<uint32>(strlen(ruleset_name));
-	auto rst = new char[2 * len + 1];
-	database->DoEscapeString(rst, ruleset_name, len);
-
-	std::string query = StringFormat("SELECT ruleset_id FROM rule_sets WHERE name='%s'", rst);
-	safe_delete_array(rst);
-	auto results = database->QueryDatabase(query);
-	if (!results.Success())
-		return -1;
-
-	if (results.RowCount() == 0)
-		return -1;
-
-	auto row = results.begin();
-
-	return atoi(row[0]);
+	return RuleSetsRepository::CreateNewRuleSet(*db, rule_set_name);
 }

-int RuleManager::_FindOrCreateRuleset(Database *database, const char *in_ruleset_name) {
+bool RuleManager::ListRulesets(Database *db, std::map<int, std::string> &m)
+{
+	m[0] = "default";

-	int ruleset_id = GetRulesetID(database, in_ruleset_name);
-	if (ruleset_id >= 0)
-		return ruleset_id;	//found and existing one...
-
-	uint32 len = strlen(in_ruleset_name);
-	auto ruleset_name = new char[2 * len + 1];
-	database->DoEscapeString(ruleset_name, in_ruleset_name, len);
-
-	std::string query = StringFormat("INSERT INTO rule_sets (ruleset_id, name) VALUES(0, '%s')", ruleset_name);
-	safe_delete_array(ruleset_name);
-	auto results = database->QueryDatabase(query);
-	if (!results.Success())
-		return -1;
-
-	return results.LastInsertedID();
-}
-
-std::string RuleManager::GetRulesetName(Database *database, int ruleset_id) {
-	std::string query = StringFormat("SELECT name FROM rule_sets WHERE ruleset_id=%d", ruleset_id);
-	auto results = database->QueryDatabase(query);
-	if (!results.Success())
-		return "";
-
-	if (results.RowCount() == 0)
-		return "";
-
-	auto row = results.begin();
-
-	return row[0];
-}
-
-bool RuleManager::ListRulesets(Database *database, std::map<int, std::string> &into) {
-
-	//start out with the default set which is always present.
-	into[0] = "default";
-
-	std::string query = "SELECT ruleset_id, name FROM rule_sets";
-	auto results = database->QueryDatabase(query);
-	if (results.Success())
+	const auto& l = RuleSetsRepository::All(*db);
+	if (l.empty()) {
 		return false;
+	}

-	for (auto row = results.begin(); row != results.end(); ++row)
-		into[atoi(row[0])] = row[1];
+	for (const auto& e : l) {
+		m[e.ruleset_id] = e.name;
+	}

 	return true;
 }

-int32 RuleManager::GetIntRule(RuleManager::IntType t) const
+int RuleManager::GetIntRule(RuleManager::IntType t) const
 {
-	return (m_RuleIntValues[t]);
+	return m_RuleIntValues[t];
 }

 float RuleManager::GetRealRule(RuleManager::RealType t) const
 {
-	return (m_RuleRealValues[t]);
+	return m_RuleRealValues[t];
 }

 bool RuleManager::GetBoolRule(RuleManager::BoolType t) const
 {
-	return (m_RuleBoolValues[t] == 1);
+	return m_RuleBoolValues[t] == 1;
 }
-