[Expeditions] Store members on dynamic zone (#1358)

This moves members from expeditions so other systems can use them

Replace expedition_members table with dynamic_zone_members

Move 'EnableInDynamicZoneStatus' rule to DynamicZone namespace

Modify #dz list to show dz members (not instance players) and type name

Move various queries to repository methods

common/repositories/base/base_dynamic_zone_members_repository.h

@@ -4,22 +4,22 @@
  * 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://eqemu.gitbook.io/server/in-development/developer-area/repositories
  */
 
-#ifndef EQEMU_BASE_EXPEDITION_MEMBERS_REPOSITORY_H
-#define EQEMU_BASE_EXPEDITION_MEMBERS_REPOSITORY_H
+#ifndef EQEMU_BASE_DYNAMIC_ZONE_MEMBERS_REPOSITORY_H
+#define EQEMU_BASE_DYNAMIC_ZONE_MEMBERS_REPOSITORY_H
 
 #include "../../database.h"
 #include "../../string_util.h"
 
-class BaseExpeditionMembersRepository {
+class BaseDynamicZoneMembersRepository {
 public:
-	struct ExpeditionMembers {
+	struct DynamicZoneMembers {
 		int id;
-		int expedition_id;
+		int dynamic_zone_id;
 		int character_id;
 		int is_current_member;
 	};
@@ -33,7 +33,7 @@ public:
 	{
 		return {
 			"id",
-			"expedition_id",
+			"dynamic_zone_id",
 			"character_id",
 			"is_current_member",
 		};
@@ -46,7 +46,7 @@ public:
 
 	static std::string TableName()
 	{
-		return std::string("expedition_members");
+		return std::string("dynamic_zone_members");
 	}
 
 	static std::string BaseSelect()
@@ -67,51 +67,51 @@ public:
 		);
 	}
 
-	static ExpeditionMembers NewEntity()
+	static DynamicZoneMembers NewEntity()
 	{
-		ExpeditionMembers entry{};
+		DynamicZoneMembers entry{};
 
 		entry.id                = 0;
-		entry.expedition_id     = 0;
+		entry.dynamic_zone_id   = 0;
 		entry.character_id      = 0;
 		entry.is_current_member = 1;
 
 		return entry;
 	}
 
-	static ExpeditionMembers GetExpeditionMembersEntry(
-		const std::vector<ExpeditionMembers> &expedition_memberss,
-		int expedition_members_id
+	static DynamicZoneMembers GetDynamicZoneMembersEntry(
+		const std::vector<DynamicZoneMembers> &dynamic_zone_memberss,
+		int dynamic_zone_members_id
 	)
 	{
-		for (auto &expedition_members : expedition_memberss) {
-			if (expedition_members.id == expedition_members_id) {
-				return expedition_members;
+		for (auto &dynamic_zone_members : dynamic_zone_memberss) {
+			if (dynamic_zone_members.id == dynamic_zone_members_id) {
+				return dynamic_zone_members;
 			}
 		}
 
 		return NewEntity();
 	}
 
-	static ExpeditionMembers FindOne(
+	static DynamicZoneMembers FindOne(
 		Database& db,
-		int expedition_members_id
+		int dynamic_zone_members_id
 	)
 	{
 		auto results = db.QueryDatabase(
 			fmt::format(
 				"{} WHERE id = {} LIMIT 1",
 				BaseSelect(),
-				expedition_members_id
+				dynamic_zone_members_id
 			)
 		);
 
 		auto row = results.begin();
 		if (results.RowCount() == 1) {
-			ExpeditionMembers entry{};
+			DynamicZoneMembers entry{};
 
 			entry.id                = atoi(row[0]);
-			entry.expedition_id     = atoi(row[1]);
+			entry.dynamic_zone_id   = atoi(row[1]);
 			entry.character_id      = atoi(row[2]);
 			entry.is_current_member = atoi(row[3]);
 
@@ -123,7 +123,7 @@ public:
 
 	static int DeleteOne(
 		Database& db,
-		int expedition_members_id
+		int dynamic_zone_members_id
 	)
 	{
 		auto results = db.QueryDatabase(
@@ -131,7 +131,7 @@ public:
 				"DELETE FROM {} WHERE {} = {}",
 				TableName(),
 				PrimaryKey(),
-				expedition_members_id
+				dynamic_zone_members_id
 			)
 		);
 
@@ -140,16 +140,16 @@ public:
 
 	static int UpdateOne(
 		Database& db,
-		ExpeditionMembers expedition_members_entry
+		DynamicZoneMembers dynamic_zone_members_entry
 	)
 	{
 		std::vector<std::string> update_values;
 
 		auto columns = Columns();
 
-		update_values.push_back(columns[1] + " = " + std::to_string(expedition_members_entry.expedition_id));
-		update_values.push_back(columns[2] + " = " + std::to_string(expedition_members_entry.character_id));
-		update_values.push_back(columns[3] + " = " + std::to_string(expedition_members_entry.is_current_member));
+		update_values.push_back(columns[1] + " = " + std::to_string(dynamic_zone_members_entry.dynamic_zone_id));
+		update_values.push_back(columns[2] + " = " + std::to_string(dynamic_zone_members_entry.character_id));
+		update_values.push_back(columns[3] + " = " + std::to_string(dynamic_zone_members_entry.is_current_member));
 
 		auto results = db.QueryDatabase(
 			fmt::format(
@@ -157,24 +157,24 @@ public:
 				TableName(),
 				implode(", ", update_values),
 				PrimaryKey(),
-				expedition_members_entry.id
+				dynamic_zone_members_entry.id
 			)
 		);
 
 		return (results.Success() ? results.RowsAffected() : 0);
 	}
 
-	static ExpeditionMembers InsertOne(
+	static DynamicZoneMembers InsertOne(
 		Database& db,
-		ExpeditionMembers expedition_members_entry
+		DynamicZoneMembers dynamic_zone_members_entry
 	)
 	{
 		std::vector<std::string> insert_values;
 
-		insert_values.push_back(std::to_string(expedition_members_entry.id));
-		insert_values.push_back(std::to_string(expedition_members_entry.expedition_id));
-		insert_values.push_back(std::to_string(expedition_members_entry.character_id));
-		insert_values.push_back(std::to_string(expedition_members_entry.is_current_member));
+		insert_values.push_back(std::to_string(dynamic_zone_members_entry.id));
+		insert_values.push_back(std::to_string(dynamic_zone_members_entry.dynamic_zone_id));
+		insert_values.push_back(std::to_string(dynamic_zone_members_entry.character_id));
+		insert_values.push_back(std::to_string(dynamic_zone_members_entry.is_current_member));
 
 		auto results = db.QueryDatabase(
 			fmt::format(
@@ -185,29 +185,29 @@ public:
 		);
 
 		if (results.Success()) {
-			expedition_members_entry.id = results.LastInsertedID();
-			return expedition_members_entry;
+			dynamic_zone_members_entry.id = results.LastInsertedID();
+			return dynamic_zone_members_entry;
 		}
 
-		expedition_members_entry = NewEntity();
+		dynamic_zone_members_entry = NewEntity();
 
-		return expedition_members_entry;
+		return dynamic_zone_members_entry;
 	}
 
 	static int InsertMany(
 		Database& db,
-		std::vector<ExpeditionMembers> expedition_members_entries
+		std::vector<DynamicZoneMembers> dynamic_zone_members_entries
 	)
 	{
 		std::vector<std::string> insert_chunks;
 
-		for (auto &expedition_members_entry: expedition_members_entries) {
+		for (auto &dynamic_zone_members_entry: dynamic_zone_members_entries) {
 			std::vector<std::string> insert_values;
 
-			insert_values.push_back(std::to_string(expedition_members_entry.id));
-			insert_values.push_back(std::to_string(expedition_members_entry.expedition_id));
-			insert_values.push_back(std::to_string(expedition_members_entry.character_id));
-			insert_values.push_back(std::to_string(expedition_members_entry.is_current_member));
+			insert_values.push_back(std::to_string(dynamic_zone_members_entry.id));
+			insert_values.push_back(std::to_string(dynamic_zone_members_entry.dynamic_zone_id));
+			insert_values.push_back(std::to_string(dynamic_zone_members_entry.character_id));
+			insert_values.push_back(std::to_string(dynamic_zone_members_entry.is_current_member));
 
 			insert_chunks.push_back("(" + implode(",", insert_values) + ")");
 		}
@@ -225,9 +225,9 @@ public:
 		return (results.Success() ? results.RowsAffected() : 0);
 	}
 
-	static std::vector<ExpeditionMembers> All(Database& db)
+	static std::vector<DynamicZoneMembers> All(Database& db)
 	{
-		std::vector<ExpeditionMembers> all_entries;
+		std::vector<DynamicZoneMembers> all_entries;
 
 		auto results = db.QueryDatabase(
 			fmt::format(
@@ -239,10 +239,10 @@ public:
 		all_entries.reserve(results.RowCount());
 
 		for (auto row = results.begin(); row != results.end(); ++row) {
-			ExpeditionMembers entry{};
+			DynamicZoneMembers entry{};
 
 			entry.id                = atoi(row[0]);
-			entry.expedition_id     = atoi(row[1]);
+			entry.dynamic_zone_id   = atoi(row[1]);
 			entry.character_id      = atoi(row[2]);
 			entry.is_current_member = atoi(row[3]);
 
@@ -252,9 +252,9 @@ public:
 		return all_entries;
 	}
 
-	static std::vector<ExpeditionMembers> GetWhere(Database& db, std::string where_filter)
+	static std::vector<DynamicZoneMembers> GetWhere(Database& db, std::string where_filter)
 	{
-		std::vector<ExpeditionMembers> all_entries;
+		std::vector<DynamicZoneMembers> all_entries;
 
 		auto results = db.QueryDatabase(
 			fmt::format(
@@ -267,10 +267,10 @@ public:
 		all_entries.reserve(results.RowCount());
 
 		for (auto row = results.begin(); row != results.end(); ++row) {
-			ExpeditionMembers entry{};
+			DynamicZoneMembers entry{};
 
 			entry.id                = atoi(row[0]);
-			entry.expedition_id     = atoi(row[1]);
+			entry.dynamic_zone_id   = atoi(row[1]);
 			entry.character_id      = atoi(row[2]);
 			entry.is_current_member = atoi(row[3]);
 
@@ -307,4 +307,4 @@ public:
 
 };
 
-#endif //EQEMU_BASE_EXPEDITION_MEMBERS_REPOSITORY_H
+#endif //EQEMU_BASE_DYNAMIC_ZONE_MEMBERS_REPOSITORY_H

common/repositories/dynamic_zone_members_repository.h

@@ -0,0 +1,249 @@
+/**
+ * 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_DYNAMIC_ZONE_MEMBERS_REPOSITORY_H
+#define EQEMU_DYNAMIC_ZONE_MEMBERS_REPOSITORY_H
+
+#include "../database.h"
+#include "../string_util.h"
+#include "base/base_dynamic_zone_members_repository.h"
+
+class DynamicZoneMembersRepository: public BaseDynamicZoneMembersRepository {
+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
+     *
+     * DynamicZoneMembersRepository::GetByZoneAndVersion(int zone_id, int zone_version)
+     * DynamicZoneMembersRepository::GetWhereNeverExpires()
+     * DynamicZoneMembersRepository::GetWhereXAndY()
+     * DynamicZoneMembersRepository::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
+
+	struct MemberWithName {
+		uint32_t id;
+		uint32_t dynamic_zone_id;
+		uint32_t character_id;
+		int is_current_member;
+		std::string character_name;
+	};
+
+	static std::string SelectMembersWithNames()
+	{
+		return std::string(SQL(
+			SELECT
+				dynamic_zone_members.id,
+				dynamic_zone_members.dynamic_zone_id,
+				dynamic_zone_members.character_id,
+				dynamic_zone_members.is_current_member,
+				character_data.name
+			FROM dynamic_zone_members
+				INNER JOIN character_data ON dynamic_zone_members.character_id = character_data.id
+		));
+	}
+
+	static std::vector<MemberWithName> GetWithNames(Database& db,
+		const std::vector<uint32_t>& dynamic_zone_ids)
+	{
+		if (dynamic_zone_ids.empty())
+		{
+			return {};
+		}
+
+		std::vector<MemberWithName> all_entries;
+
+		auto results = db.QueryDatabase(fmt::format(SQL(
+			{}
+			WHERE dynamic_zone_members.dynamic_zone_id IN ({})
+				AND dynamic_zone_members.is_current_member = TRUE;
+		),
+			SelectMembersWithNames(),
+			fmt::join(dynamic_zone_ids, ",")
+		));
+
+		if (results.Success())
+		{
+			all_entries.reserve(results.RowCount());
+
+			for (auto row = results.begin(); row != results.end(); ++row)
+			{
+				MemberWithName entry{};
+
+				int col = 0;
+				entry.id                = strtoul(row[col++], nullptr, 10);
+				entry.dynamic_zone_id   = strtoul(row[col++], nullptr, 10);
+				entry.character_id      = strtoul(row[col++], nullptr, 10);
+				entry.is_current_member = strtoul(row[col++], nullptr, 10);
+				entry.character_name    = row[col++];
+
+				all_entries.emplace_back(std::move(entry));
+			}
+		}
+
+		return all_entries;
+	}
+
+	static int DeleteByInstance(Database& db, int instance_id)
+	{
+		auto results = db.QueryDatabase(fmt::format(SQL(
+			DELETE dynamic_zone_members
+			FROM dynamic_zone_members
+				INNER JOIN dynamic_zones ON dynamic_zone_members.dynamic_zone_id = dynamic_zones.id
+			WHERE dynamic_zones.instance_id = {}
+		), instance_id));
+
+		return (results.Success() ? results.RowsAffected() : 0);
+	}
+
+	static int DeleteByManyInstances(Database& db, const std::string& joined_instance_ids)
+	{
+		auto results = db.QueryDatabase(fmt::format(SQL(
+			DELETE dynamic_zone_members
+			FROM dynamic_zone_members
+				INNER JOIN dynamic_zones ON dynamic_zone_members.dynamic_zone_id = dynamic_zones.id
+			WHERE dynamic_zones.instance_id IN ({})
+		), joined_instance_ids));
+
+		return (results.Success() ? results.RowsAffected() : 0);
+	}
+
+	static int GetCountWhere(Database& db, const std::string& where_filter)
+	{
+		auto results = db.QueryDatabase(fmt::format(
+			"SELECT COUNT(*) FROM {} WHERE {};", TableName(), where_filter));
+
+		uint32_t count = 0;
+		if (results.Success() && results.RowCount() > 0)
+		{
+			auto row = results.begin();
+			count = strtoul(row[0], nullptr, 10);
+		}
+		return count;
+	}
+
+	static void AddMember(Database& db, uint32_t dynamic_zone_id, uint32_t character_id)
+	{
+		db.QueryDatabase(fmt::format(SQL(
+			INSERT INTO {}
+				(dynamic_zone_id, character_id)
+			VALUES
+				({}, {})
+			ON DUPLICATE KEY UPDATE is_current_member = TRUE;
+		),
+			TableName(),
+			dynamic_zone_id,
+			character_id
+		));
+	}
+
+	static void RemoveMember(Database& db, uint32_t dynamic_zone_id, uint32_t character_id)
+	{
+		db.QueryDatabase(fmt::format(SQL(
+			UPDATE {} SET is_current_member = FALSE
+			WHERE dynamic_zone_id = {} AND character_id = {};
+		),
+			TableName(), dynamic_zone_id, character_id
+		));
+	}
+
+	static void RemoveAllMembers(Database& db, uint32_t dynamic_zone_id)
+	{
+		db.QueryDatabase(fmt::format(SQL(
+			UPDATE {} SET is_current_member = FALSE
+			WHERE dynamic_zone_id = {};
+		),
+			TableName(), dynamic_zone_id
+		));
+	}
+
+	static void RemoveAllMembers(Database& db, std::vector<uint32_t> dynamic_zone_ids)
+	{
+		if (!dynamic_zone_ids.empty())
+		{
+			db.QueryDatabase(fmt::format(SQL(
+				UPDATE {} SET is_current_member = FALSE
+				WHERE dynamic_zone_id IN ({});
+			),
+				TableName(), fmt::join(dynamic_zone_ids, ",")
+			));
+		}
+	}
+
+	static int InsertOrUpdateMany(Database& db,
+		const std::vector<DynamicZoneMembers>& dynamic_zone_members_entries)
+	{
+		std::vector<std::string> insert_chunks;
+
+		for (auto &dynamic_zone_members_entry: dynamic_zone_members_entries)
+		{
+			std::vector<std::string> insert_values;
+
+			insert_values.push_back(std::to_string(dynamic_zone_members_entry.id));
+			insert_values.push_back(std::to_string(dynamic_zone_members_entry.dynamic_zone_id));
+			insert_values.push_back(std::to_string(dynamic_zone_members_entry.character_id));
+			insert_values.push_back(std::to_string(dynamic_zone_members_entry.is_current_member));
+
+			insert_chunks.push_back("(" + implode(",", insert_values) + ")");
+		}
+
+		std::vector<std::string> insert_values;
+
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"INSERT INTO {} ({}) VALUES {} ON DUPLICATE KEY UPDATE is_current_member = TRUE;",
+				TableName(),
+				ColumnsRaw(),
+				implode(",", insert_chunks)
+			)
+		);
+
+		return (results.Success() ? results.RowsAffected() : 0);
+	}
+};
+
+#endif //EQEMU_DYNAMIC_ZONE_MEMBERS_REPOSITORY_H

common/repositories/dynamic_zones_repository.h

@@ -249,7 +249,7 @@ public:
 		int      version;
 		uint32_t start_time;
 		int      duration;
-		int      player_count;
+		int      member_count;
 	};
 
 	static std::string SelectDynamicZoneInstancePlayerCount()
@@ -263,10 +263,11 @@ public:
 				instance_list.version,
 				instance_list.start_time,
 				instance_list.duration,
-				COUNT(instance_list_player.id) member_count
+				COUNT(dynamic_zone_members.character_id) member_count
 			FROM dynamic_zones
 				INNER JOIN instance_list ON dynamic_zones.instance_id = instance_list.id
-				LEFT JOIN instance_list_player ON instance_list.id = instance_list_player.id
+				LEFT JOIN dynamic_zone_members ON dynamic_zones.id = dynamic_zone_members.dynamic_zone_id
+					AND dynamic_zone_members.is_current_member = TRUE
 			GROUP BY instance_list.id
 			ORDER BY dynamic_zones.id;
 		));
@@ -293,7 +294,7 @@ public:
 				entry.version      = strtol(row[col++], nullptr, 10);
 				entry.start_time   = strtoul(row[col++], nullptr, 10);
 				entry.duration     = strtol(row[col++], nullptr, 10);
-				entry.player_count = strtol(row[col++], nullptr, 10);
+				entry.member_count = strtol(row[col++], nullptr, 10);
 
 				all_entries.emplace_back(std::move(entry));
 			}

common/repositories/expedition_members_repository.h

@@ -1,132 +0,0 @@
-/**
- * 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_EXPEDITION_MEMBERS_REPOSITORY_H
-#define EQEMU_EXPEDITION_MEMBERS_REPOSITORY_H
-
-#include "../database.h"
-#include "../string_util.h"
-#include "base/base_expedition_members_repository.h"
-
-class ExpeditionMembersRepository: public BaseExpeditionMembersRepository {
-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
-     *
-     * ExpeditionMembersRepository::GetByZoneAndVersion(int zone_id, int zone_version)
-     * ExpeditionMembersRepository::GetWhereNeverExpires()
-     * ExpeditionMembersRepository::GetWhereXAndY()
-     * ExpeditionMembersRepository::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
-
-	struct MemberWithName {
-		uint32_t id;
-		uint32_t expedition_id;
-		uint32_t character_id;
-		int is_current_member;
-		std::string character_name;
-	};
-
-	static std::string SelectMembersWithNames()
-	{
-		return std::string(SQL(
-			SELECT
-				expedition_members.id,
-				expedition_members.expedition_id,
-				expedition_members.character_id,
-				expedition_members.is_current_member,
-				character_data.name
-			FROM expedition_members
-				INNER JOIN character_data ON expedition_members.character_id = character_data.id
-		));
-	}
-
-	static std::vector<MemberWithName> GetWithNames(Database& db,
-		const std::vector<uint32_t>& expedition_ids)
-	{
-		if (expedition_ids.empty())
-		{
-			return {};
-		}
-
-		std::vector<MemberWithName> all_entries;
-
-		auto results = db.QueryDatabase(fmt::format(SQL(
-			{}
-			WHERE expedition_members.expedition_id IN ({})
-				AND expedition_members.is_current_member = TRUE;
-		),
-			SelectMembersWithNames(),
-			fmt::join(expedition_ids, ",")
-		));
-
-		if (results.Success())
-		{
-			all_entries.reserve(results.RowCount());
-
-			for (auto row = results.begin(); row != results.end(); ++row)
-			{
-				MemberWithName entry{};
-
-				int col = 0;
-				entry.id                = strtoul(row[col++], nullptr, 10);
-				entry.expedition_id     = strtoul(row[col++], nullptr, 10);
-				entry.character_id      = strtoul(row[col++], nullptr, 10);
-				entry.is_current_member = strtoul(row[col++], nullptr, 10);
-				entry.character_name    = row[col++];
-
-				all_entries.emplace_back(std::move(entry));
-			}
-		}
-
-		return all_entries;
-	}
-};
-
-#endif //EQEMU_EXPEDITION_MEMBERS_REPOSITORY_H

common/repositories/expeditions_repository.h

@@ -184,11 +184,11 @@ public:
 				character_data.name,
 				MAX(expeditions.id)
 			FROM character_data
-				LEFT JOIN expedition_members
-					ON character_data.id = expedition_members.character_id
-					AND expedition_members.is_current_member = TRUE
+				LEFT JOIN dynamic_zone_members
+					ON character_data.id = dynamic_zone_members.character_id
+					AND dynamic_zone_members.is_current_member = TRUE
 				LEFT JOIN expeditions
-					ON expedition_members.expedition_id = expeditions.id
+					ON dynamic_zone_members.dynamic_zone_id = expeditions.dynamic_zone_id
 			WHERE character_data.name IN ({})
 			GROUP BY character_data.id
 			ORDER BY FIELD(character_data.name, {})
@@ -214,6 +214,37 @@ public:
 
 		return entries;
 	}
+
+	static uint32_t GetIDByMemberID(Database& db, uint32_t character_id)
+	{
+		if (character_id == 0)
+		{
+			return 0;
+		}
+
+		uint32_t expedition_id = 0;
+
+		auto results = db.QueryDatabase(fmt::format(SQL(
+			SELECT
+				expeditions.id
+			FROM expeditions
+				INNER JOIN dynamic_zone_members
+					ON expeditions.dynamic_zone_id = dynamic_zone_members.dynamic_zone_id
+			WHERE
+				dynamic_zone_members.character_id = {}
+				AND dynamic_zone_members.is_current_member = TRUE;
+		),
+			character_id
+		));
+
+		if (results.Success() && results.RowCount() > 0)
+		{
+			auto row = results.begin();
+			expedition_id = std::strtoul(row[0], nullptr, 10);
+		}
+
+		return expedition_id;
+	}
 };
 
 #endif //EQEMU_EXPEDITIONS_REPOSITORY_H

common/repositories/instance_list_player_repository.h

@@ -65,6 +65,34 @@ public:
 
 	// Custom extended repository methods here
 
+	static int InsertOrUpdateMany(Database& db,
+		const std::vector<InstanceListPlayer>& instance_list_player_entries)
+	{
+		std::vector<std::string> insert_chunks;
+
+		for (auto &instance_list_player_entry: instance_list_player_entries)
+		{
+			std::vector<std::string> insert_values;
+
+			insert_values.push_back(std::to_string(instance_list_player_entry.id));
+			insert_values.push_back(std::to_string(instance_list_player_entry.charid));
+
+			insert_chunks.push_back("(" + implode(",", insert_values) + ")");
+		}
+
+		std::vector<std::string> insert_values;
+
+		auto results = db.QueryDatabase(
+			fmt::format(
+				"INSERT INTO {} ({}) VALUES {} ON DUPLICATE KEY UPDATE id = VALUES(id)",
+				TableName(),
+				ColumnsRaw(),
+				implode(",", insert_chunks)
+			)
+		);
+
+		return (results.Success() ? results.RowsAffected() : 0);
+	}
 };
 
 #endif //EQEMU_INSTANCE_LIST_PLAYER_REPOSITORY_H