From 447fc026a8046016f6064a2a72d5cf991f8392ce Mon Sep 17 00:00:00 2001 From: Alex King <89047260+Kinglykrab@users.noreply.github.com> Date: Fri, 16 Feb 2024 01:27:08 -0500 Subject: [PATCH] [Repositories] Convert Zone Flags to Repositories (#4077) # Notes - Converts `ClearZoneFlag()`, `LoadZoneFlags()`, and `SetZoneFlag()` to repositories. --- .../base/base_zone_flags_repository.h | 392 ++++++++++++++++++ common/repositories/zone_flags_repository.h | 50 +++ zone/zoning.cpp | 70 ++-- 3 files changed, 474 insertions(+), 38 deletions(-) create mode 100644 common/repositories/base/base_zone_flags_repository.h create mode 100644 common/repositories/zone_flags_repository.h diff --git a/common/repositories/base/base_zone_flags_repository.h b/common/repositories/base/base_zone_flags_repository.h new file mode 100644 index 000000000..dfda1f18a --- /dev/null +++ b/common/repositories/base/base_zone_flags_repository.h @@ -0,0 +1,392 @@ +/** + * DO NOT MODIFY THIS FILE + * + * 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 + * + * @generator ./utils/scripts/generators/repository-generator.pl + * @docs https://docs.eqemu.io/developer/repositories + */ + +#ifndef EQEMU_BASE_ZONE_FLAGS_REPOSITORY_H +#define EQEMU_BASE_ZONE_FLAGS_REPOSITORY_H + +#include "../../database.h" +#include "../../strings.h" +#include + +class BaseZoneFlagsRepository { +public: + struct ZoneFlags { + int32_t charID; + int32_t zoneID; + }; + + static std::string PrimaryKey() + { + return std::string("charID"); + } + + static std::vector Columns() + { + return { + "charID", + "zoneID", + }; + } + + static std::vector SelectColumns() + { + return { + "charID", + "zoneID", + }; + } + + static std::string ColumnsRaw() + { + return std::string(Strings::Implode(", ", Columns())); + } + + static std::string SelectColumnsRaw() + { + return std::string(Strings::Implode(", ", SelectColumns())); + } + + static std::string TableName() + { + return std::string("zone_flags"); + } + + static std::string BaseSelect() + { + return fmt::format( + "SELECT {} FROM {}", + SelectColumnsRaw(), + TableName() + ); + } + + static std::string BaseInsert() + { + return fmt::format( + "INSERT INTO {} ({}) ", + TableName(), + ColumnsRaw() + ); + } + + static ZoneFlags NewEntity() + { + ZoneFlags e{}; + + e.charID = 0; + e.zoneID = 0; + + return e; + } + + static ZoneFlags GetZoneFlags( + const std::vector &zone_flagss, + int zone_flags_id + ) + { + for (auto &zone_flags : zone_flagss) { + if (zone_flags.charID == zone_flags_id) { + return zone_flags; + } + } + + return NewEntity(); + } + + static ZoneFlags FindOne( + Database& db, + int zone_flags_id + ) + { + auto results = db.QueryDatabase( + fmt::format( + "{} WHERE {} = {} LIMIT 1", + BaseSelect(), + PrimaryKey(), + zone_flags_id + ) + ); + + auto row = results.begin(); + if (results.RowCount() == 1) { + ZoneFlags e{}; + + e.charID = row[0] ? static_cast(atoi(row[0])) : 0; + e.zoneID = row[1] ? static_cast(atoi(row[1])) : 0; + + return e; + } + + return NewEntity(); + } + + static int DeleteOne( + Database& db, + int zone_flags_id + ) + { + auto results = db.QueryDatabase( + fmt::format( + "DELETE FROM {} WHERE {} = {}", + TableName(), + PrimaryKey(), + zone_flags_id + ) + ); + + return (results.Success() ? results.RowsAffected() : 0); + } + + static int UpdateOne( + Database& db, + const ZoneFlags &e + ) + { + std::vector v; + + auto columns = Columns(); + + v.push_back(columns[0] + " = " + std::to_string(e.charID)); + v.push_back(columns[1] + " = " + std::to_string(e.zoneID)); + + auto results = db.QueryDatabase( + fmt::format( + "UPDATE {} SET {} WHERE {} = {}", + TableName(), + Strings::Implode(", ", v), + PrimaryKey(), + e.charID + ) + ); + + return (results.Success() ? results.RowsAffected() : 0); + } + + static ZoneFlags InsertOne( + Database& db, + ZoneFlags e + ) + { + std::vector v; + + v.push_back(std::to_string(e.charID)); + v.push_back(std::to_string(e.zoneID)); + + auto results = db.QueryDatabase( + fmt::format( + "{} VALUES ({})", + BaseInsert(), + Strings::Implode(",", v) + ) + ); + + if (results.Success()) { + e.charID = results.LastInsertedID(); + return e; + } + + e = NewEntity(); + + return e; + } + + static int InsertMany( + Database& db, + const std::vector &entries + ) + { + std::vector insert_chunks; + + for (auto &e: entries) { + std::vector v; + + v.push_back(std::to_string(e.charID)); + v.push_back(std::to_string(e.zoneID)); + + insert_chunks.push_back("(" + Strings::Implode(",", v) + ")"); + } + + std::vector v; + + auto results = db.QueryDatabase( + fmt::format( + "{} VALUES {}", + BaseInsert(), + Strings::Implode(",", insert_chunks) + ) + ); + + return (results.Success() ? results.RowsAffected() : 0); + } + + static std::vector All(Database& db) + { + std::vector all_entries; + + auto results = db.QueryDatabase( + fmt::format( + "{}", + BaseSelect() + ) + ); + + all_entries.reserve(results.RowCount()); + + for (auto row = results.begin(); row != results.end(); ++row) { + ZoneFlags e{}; + + e.charID = row[0] ? static_cast(atoi(row[0])) : 0; + e.zoneID = row[1] ? static_cast(atoi(row[1])) : 0; + + all_entries.push_back(e); + } + + return all_entries; + } + + static std::vector GetWhere(Database& db, const std::string &where_filter) + { + std::vector all_entries; + + auto results = db.QueryDatabase( + fmt::format( + "{} WHERE {}", + BaseSelect(), + where_filter + ) + ); + + all_entries.reserve(results.RowCount()); + + for (auto row = results.begin(); row != results.end(); ++row) { + ZoneFlags e{}; + + e.charID = row[0] ? static_cast(atoi(row[0])) : 0; + e.zoneID = row[1] ? static_cast(atoi(row[1])) : 0; + + all_entries.push_back(e); + } + + return all_entries; + } + + static int DeleteWhere(Database& db, const std::string &where_filter) + { + auto results = db.QueryDatabase( + fmt::format( + "DELETE FROM {} WHERE {}", + TableName(), + where_filter + ) + ); + + return (results.Success() ? results.RowsAffected() : 0); + } + + static int Truncate(Database& db) + { + auto results = db.QueryDatabase( + fmt::format( + "TRUNCATE TABLE {}", + TableName() + ) + ); + + return (results.Success() ? results.RowsAffected() : 0); + } + + static int64 GetMaxId(Database& db) + { + auto results = db.QueryDatabase( + fmt::format( + "SELECT COALESCE(MAX({}), 0) FROM {}", + PrimaryKey(), + TableName() + ) + ); + + return (results.Success() && results.begin()[0] ? strtoll(results.begin()[0], nullptr, 10) : 0); + } + + static int64 Count(Database& db, const std::string &where_filter = "") + { + auto results = db.QueryDatabase( + fmt::format( + "SELECT COUNT(*) FROM {} {}", + TableName(), + (where_filter.empty() ? "" : "WHERE " + where_filter) + ) + ); + + return (results.Success() && results.begin()[0] ? strtoll(results.begin()[0], nullptr, 10) : 0); + } + + static std::string BaseReplace() + { + return fmt::format( + "REPLACE INTO {} ({}) ", + TableName(), + ColumnsRaw() + ); + } + + static int ReplaceOne( + Database& db, + const ZoneFlags &e + ) + { + std::vector v; + + v.push_back(std::to_string(e.charID)); + v.push_back(std::to_string(e.zoneID)); + + auto results = db.QueryDatabase( + fmt::format( + "{} VALUES ({})", + BaseReplace(), + Strings::Implode(",", v) + ) + ); + + return (results.Success() ? results.RowsAffected() : 0); + } + + static int ReplaceMany( + Database& db, + const std::vector &entries + ) + { + std::vector insert_chunks; + + for (auto &e: entries) { + std::vector v; + + v.push_back(std::to_string(e.charID)); + v.push_back(std::to_string(e.zoneID)); + + insert_chunks.push_back("(" + Strings::Implode(",", v) + ")"); + } + + std::vector v; + + auto results = db.QueryDatabase( + fmt::format( + "{} VALUES {}", + BaseReplace(), + Strings::Implode(",", insert_chunks) + ) + ); + + return (results.Success() ? results.RowsAffected() : 0); + } +}; + +#endif //EQEMU_BASE_ZONE_FLAGS_REPOSITORY_H diff --git a/common/repositories/zone_flags_repository.h b/common/repositories/zone_flags_repository.h new file mode 100644 index 000000000..a8c40a891 --- /dev/null +++ b/common/repositories/zone_flags_repository.h @@ -0,0 +1,50 @@ +#ifndef EQEMU_ZONE_FLAGS_REPOSITORY_H +#define EQEMU_ZONE_FLAGS_REPOSITORY_H + +#include "../database.h" +#include "../strings.h" +#include "base/base_zone_flags_repository.h" + +class ZoneFlagsRepository: public BaseZoneFlagsRepository { +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 + * + * ZoneFlagsRepository::GetByZoneAndVersion(int zone_id, int zone_version) + * ZoneFlagsRepository::GetWhereNeverExpires() + * ZoneFlagsRepository::GetWhereXAndY() + * ZoneFlagsRepository::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_ZONE_FLAGS_REPOSITORY_H diff --git a/zone/zoning.cpp b/zone/zoning.cpp index 93b3d6da6..d1a988940 100644 --- a/zone/zoning.cpp +++ b/zone/zoning.cpp @@ -35,6 +35,7 @@ extern WorldServer worldserver; extern Zone* zone; #include "../common/repositories/character_peqzone_flags_repository.h" +#include "../common/repositories/zone_flags_repository.h" #include "../common/events/player_event_logs.h" @@ -1067,53 +1068,48 @@ void Client::GoToDeath() { MovePC(m_pp.binds[0].zone_id, m_pp.binds[0].instance_id, 0.0f, 0.0f, 0.0f, 0.0f, 1, ZoneToBindPoint); } -void Client::ClearZoneFlag(uint32 zone_id) { +void Client::ClearZoneFlag(uint32 zone_id) +{ if (!HasZoneFlag(zone_id)) { return; } zone_flags.erase(zone_id); - std::string query = fmt::format( - "DELETE FROM zone_flags WHERE charID = {} AND zoneID = {}", - CharacterID(), - zone_id + ZoneFlagsRepository::DeleteWhere( + database, + fmt::format( + "`charID` = {} AND `zoneID` = {}", + CharacterID(), + zone_id + ) ); - auto results = database.QueryDatabase(query); - - if (!results.Success()) { - LogError("MySQL Error while trying to clear zone flag for [{}]: [{}]", GetName(), results.ErrorMessage().c_str()); - } } -bool Client::HasZoneFlag(uint32 zone_id) const { +bool Client::HasZoneFlag(uint32 zone_id) const +{ return zone_flags.find(zone_id) != zone_flags.end(); } -void Client::LoadZoneFlags() { - const auto query = fmt::format( - "SELECT zoneID from zone_flags WHERE charID = {}", - CharacterID() +void Client::LoadZoneFlags() +{ + const auto& l = ZoneFlagsRepository::GetWhere( + database, + fmt::format( + "`charID` = {}", + CharacterID() + ) ); - auto results = database.QueryDatabase(query); - - if (!results.Success()) { - LogError("MySQL Error while trying to load zone flags for [{}]: [{}]", GetName(), results.ErrorMessage().c_str()); - return; - } - - if (!results.RowCount()) { - return; - } zone_flags.clear(); - for (auto row : results) { - zone_flags.insert(Strings::ToUnsignedInt(row[0])); + for (const auto& e : l) { + zone_flags.insert(e.zoneID); } } -void Client::SendZoneFlagInfo(Client *to) const { +void Client::SendZoneFlagInfo(Client* to) const +{ if (zone_flags.empty()) { to->Message( Chat::White, @@ -1178,23 +1174,21 @@ void Client::SendZoneFlagInfo(Client *to) const { ); } -void Client::SetZoneFlag(uint32 zone_id) { +void Client::SetZoneFlag(uint32 zone_id) +{ if (HasZoneFlag(zone_id)) { return; } zone_flags.insert(zone_id); - const auto query = fmt::format( - "INSERT INTO zone_flags (charID, zoneID) VALUES ({}, {})", - CharacterID(), - zone_id + ZoneFlagsRepository::InsertOne( + database, + ZoneFlagsRepository::ZoneFlags{ + .charID = static_cast(CharacterID()), + .zoneID = static_cast(zone_id) + } ); - auto results = database.QueryDatabase(query); - - if (!results.Success()) { - LogError("MySQL Error while trying to set zone flag for [{}]: [{}]", GetName(), results.ErrorMessage().c_str()); - } } void Client::ClearPEQZoneFlag(uint32 zone_id) {