[Expeditions] Refactor expedition caching (#1315)

Add common expedition base class

Use repository for zone and world expedition caching

World now stores members and leader as Member objects instead of ids

This improves readability of the caching methods and lets world cache
expedition dzs and members like zone. World also now caches expeditions
as unique_ptr which will be necessary for future dz callback lambdas
that capture 'this' so addresses don't change on cache vector resizes.

zone/command.cpp

@@ -6900,20 +6900,20 @@ void command_dz(Client* c, const Seperator* sep)
 				auto leader_saylink = EQ::SayLinkEngine::GenerateQuestSaylink(fmt::format(
 					"#goto {}", expedition->GetLeaderName()), false, expedition->GetLeaderName());
 				auto zone_saylink = EQ::SayLinkEngine::GenerateQuestSaylink(fmt::format(
-					"#zoneinstance {}", expedition->GetInstanceID()), false, "zone");
+					"#zoneinstance {}", expedition->GetDynamicZone().GetInstanceID()), false, "zone");
 
 				auto seconds = expedition->GetDynamicZone().GetSecondsRemaining();
 
 				c->Message(Chat::White, fmt::format(
 					"expedition id: [{}] dz id: [{}] name: [{}] leader: [{}] {}: [{}]:[{}]:[{}]:[{}] members: [{}] remaining: [{:02}:{:02}:{:02}]",
 					expedition->GetID(),
-					expedition->GetDynamicZoneID(),
+					expedition->GetDynamicZone().GetID(),
 					expedition->GetName(),
 					leader_saylink,
 					zone_saylink,
 					ZoneName(expedition->GetDynamicZone().GetZoneID()),
 					expedition->GetDynamicZone().GetZoneID(),
-					expedition->GetInstanceID(),
+					expedition->GetDynamicZone().GetInstanceID(),
 					expedition->GetDynamicZone().GetZoneVersion(),
 					expedition->GetMemberCount(),
 					seconds / 3600,      // hours

zone/dynamic_zone.cpp

@@ -64,22 +64,6 @@ DynamicZone* DynamicZone::FindDynamicZoneByID(uint32_t dz_id)
 	return nullptr;
 }
 
-std::unordered_map<uint32_t, DynamicZone> DynamicZone::LoadMultipleDzFromDatabase(
-	const std::vector<uint32_t>& dynamic_zone_ids)
-{
-	LogDynamicZonesDetail("Loading dynamic zone data for [{}] instances", dynamic_zone_ids.size());
-
-	std::unordered_map<uint32_t, DynamicZone> dynamic_zones;
-
-	auto entries = DynamicZonesRepository::GetWithInstance(database, dynamic_zone_ids);
-	for (auto& entry : entries)
-	{
-		dynamic_zones.emplace(entry.id, std::move(entry));
-	}
-
-	return dynamic_zones;
-}
-
 void DynamicZone::StartAllClientRemovalTimers()
 {
 	for (const auto& client_iter : entity_list.GetClientList())

zone/dynamic_zone.h

@@ -42,8 +42,6 @@ public:
 	DynamicZone(uint32_t zone_id, uint32_t version, uint32_t duration, DynamicZoneType type);
 
 	static DynamicZone* FindDynamicZoneByID(uint32_t dz_id);
-	static std::unordered_map<uint32_t, DynamicZone> LoadMultipleDzFromDatabase(
-		const std::vector<uint32_t>& dynamic_zone_ids);
 	static void HandleWorldMessage(ServerPacket* pack);
 
 	void SetSecondsRemaining(uint32_t seconds_remaining) override;

zone/expedition.cpp

@@ -27,6 +27,8 @@
 #include "zonedb.h"
 #include "../common/eqemu_logsys.h"
 #include "../common/expedition_lockout_timer.h"
+#include "../common/repositories/expedition_lockouts_repository.h"
+#include "../common/repositories/expedition_members_repository.h"
 #include "../common/util/uuid.h"
 
 extern WorldServer worldserver;
@@ -49,13 +51,7 @@ const int32_t Expedition::EVENT_TIMER_ID  = 1;
 Expedition::Expedition(
 	uint32_t id, const std::string& uuid, DynamicZone&& dz, const std::string& expedition_name,
 	const ExpeditionMember& leader, uint32_t min_players, uint32_t max_players
-) :
-	m_id(id),
-	m_uuid(uuid),
-	m_expedition_name(expedition_name),
-	m_leader(leader),
-	m_min_players(min_players),
-	m_max_players(max_players)
+) : ExpeditionBase(id, uuid, expedition_name, leader, min_players, max_players)
 {
 	SetDynamicZone(std::move(dz));
 }
@@ -122,7 +118,7 @@ Expedition* Expedition::TryCreate(
 			"Created [{}] [{}] instance id: [{}] leader: [{}] minplayers: [{}] maxplayers: [{}]",
 			expedition->GetID(),
 			expedition->GetName(),
-			expedition->GetInstanceID(),
+			expedition->GetDynamicZone().GetInstanceID(),
 			expedition->GetLeaderName(),
 			expedition->GetMinPlayers(),
 			expedition->GetMaxPlayers()
@@ -150,113 +146,88 @@ Expedition* Expedition::TryCreate(
 	return nullptr;
 }
 
-void Expedition::CacheExpeditions(MySQLRequestResult& results)
+void Expedition::CacheExpeditions(
+	std::vector<ExpeditionsRepository::ExpeditionWithLeader>&& expedition_entries)
 {
-	if (!results.Success() || !zone)
+	if (!zone)
 	{
 		return;
 	}
 
+	// bulk load expedition dzs, members, and internal lockouts before caching
 	std::vector<uint32_t> expedition_ids;
-	std::vector<uint32_t> dynamic_zone_ids;;
-	std::vector<std::pair<uint32_t, uint32_t>> expedition_character_ids;
-
-	using col = LoadExpeditionColumns::eLoadExpeditionColumns;
-
-	uint32_t last_expedition_id = 0;
-
-	for (auto row = results.begin(); row != results.end(); ++row)
+	std::vector<uint32_t> dynamic_zone_ids;
+	for (const auto& entry : expedition_entries)
 	{
-		auto expedition_id = strtoul(row[col::id], nullptr, 10);
+		expedition_ids.emplace_back(entry.id);
+		dynamic_zone_ids.emplace_back(entry.dynamic_zone_id);
+	}
 
-		if (expedition_id != last_expedition_id)
+	auto dynamic_zones = DynamicZonesRepository::GetWithInstance(database, dynamic_zone_ids);
+	auto expedition_members = ExpeditionMembersRepository::GetWithNames(database, expedition_ids);
+	auto expedition_lockouts = ExpeditionLockoutsRepository::GetWithTimestamp(database, expedition_ids);
+
+	std::vector<std::pair<uint32_t, uint32_t>> expedition_character_ids; // for online status request
+
+	for (auto& entry : expedition_entries)
+	{
+		auto expedition = std::make_unique<Expedition>();
+		expedition->LoadRepositoryResult(std::move(entry));
+
+		auto dz_entry_iter = std::find_if(dynamic_zones.begin(), dynamic_zones.end(),
+			[&](const DynamicZonesRepository::DynamicZoneInstance& dz_entry) {
+				return dz_entry.id == entry.dynamic_zone_id;
+			});
+
+		if (dz_entry_iter != dynamic_zones.end())
 		{
-			expedition_ids.emplace_back(expedition_id);
-
-			uint32_t leader_id = strtoul(row[col::leader_id], nullptr, 10);
-			uint32_t dynamic_zone_id = strtoul(row[col::dz_id], nullptr, 10);
-
-			dynamic_zone_ids.emplace_back(dynamic_zone_id);
-
-			std::unique_ptr<Expedition> expedition = std::make_unique<Expedition>(
-				expedition_id,
-				row[col::uuid],                                         // expedition uuid
-				DynamicZone{ dynamic_zone_id },
-				row[col::expedition_name],                              // expedition name
-				ExpeditionMember{ leader_id, row[col::leader_name] },   // expedition leader id, name
-				strtoul(row[col::min_players], nullptr, 10),            // min_players
-				strtoul(row[col::max_players], nullptr, 10)             // max_players
-			);
-
-			bool add_replay_on_join = (strtoul(row[col::add_replay_on_join], nullptr, 10) != 0);
-			bool is_locked = (strtoul(row[col::is_locked], nullptr, 10) != 0);
-
-			expedition->SetReplayLockoutOnMemberJoin(add_replay_on_join);
-			expedition->SetLocked(is_locked, ExpeditionLockMessage::None);
-
-			zone->expedition_cache.emplace(expedition_id, std::move(expedition));
+			expedition->SetDynamicZone(std::move(*dz_entry_iter));
 		}
 
-		last_expedition_id = expedition_id;
-
-		// looping expedition members
-		auto current_expedition = Expedition::FindCachedExpeditionByID(last_expedition_id);
-		if (current_expedition)
+		for (auto& member : expedition_members)
 		{
-			auto member_id = strtoul(row[col::member_id], nullptr, 10);
-			current_expedition->AddInternalMember(
-				row[col::member_name], member_id, ExpeditionMemberStatus::Offline);
-			expedition_character_ids.emplace_back(expedition_id, member_id);
+			if (member.expedition_id == expedition->GetID())
+			{
+				expedition->AddMemberFromRepositoryResult(std::move(member));
+				expedition_character_ids.emplace_back(expedition->GetID(), member.character_id);
+			}
 		}
+
+		for (auto& lockout_entry : expedition_lockouts)
+		{
+			if (lockout_entry.expedition_id == expedition->GetID())
+			{
+				ExpeditionLockoutTimer lockout{
+					std::move(lockout_entry.from_expedition_uuid),
+					expedition->GetName(),
+					std::move(lockout_entry.event_name),
+					static_cast<uint64_t>(lockout_entry.expire_time),
+					static_cast<uint32_t>(lockout_entry.duration)
+				};
+
+				std::string event_name = lockout.GetEventName(); // copy for key since we're moving it
+				expedition->m_lockouts.emplace(std::move(event_name), std::move(lockout));
+			}
+		}
+
+		auto inserted = zone->expedition_cache.emplace(entry.id, std::move(expedition));
+		inserted.first->second->SendUpdatesToZoneMembers();
 	}
 
 	// ask world for online members from all cached expeditions at once
 	Expedition::SendWorldGetOnlineMembers(expedition_character_ids);
-
-	// bulk load dynamic zone data and expedition lockouts for cached expeditions
-	auto dynamic_zones = DynamicZone::LoadMultipleDzFromDatabase(dynamic_zone_ids);
-	auto expedition_lockouts = ExpeditionDatabase::LoadMultipleExpeditionLockouts(expedition_ids);
-
-	for (const auto& expedition_id : expedition_ids)
-	{
-		auto expedition = Expedition::FindCachedExpeditionByID(expedition_id);
-		if (expedition)
-		{
-			auto dz_iter = dynamic_zones.find(expedition->GetDynamicZoneID());
-			if (dz_iter != dynamic_zones.end())
-			{
-				expedition->SetDynamicZone(std::move(dz_iter->second));
-			}
-
-			auto lockout_iter = expedition_lockouts.find(expedition->GetID());
-			if (lockout_iter != expedition_lockouts.end())
-			{
-				expedition->m_lockouts = lockout_iter->second;
-			}
-
-			// send member updates now that all data is loaded for the cached expedition
-			expedition->SendUpdatesToZoneMembers();
-		}
-	}
 }
 
 void Expedition::CacheFromDatabase(uint32_t expedition_id)
 {
-	if (zone)
+	if (zone && expedition_id != 0)
 	{
 		BenchTimer benchmark;
 
-		auto results = ExpeditionDatabase::LoadExpedition(expedition_id);
-		if (!results.Success())
-		{
-			LogExpeditions("Failed to load Expedition [{}] for zone cache", expedition_id);
-			return;
-		}
+		auto expedition = ExpeditionsRepository::GetWithLeaderName(database, expedition_id);
+		CacheExpeditions({ std::move(expedition) });
 
-		CacheExpeditions(results);
-
-		auto elapsed = benchmark.elapsed();
-		LogExpeditions("Caching new expedition [{}] took [{}s]", expedition_id, elapsed);
+		LogExpeditions("Caching new expedition [{}] took [{}s]", expedition_id, benchmark.elapsed());
 	}
 }
 
@@ -269,20 +240,13 @@ bool Expedition::CacheAllFromDatabase()
 
 	BenchTimer benchmark;
 
+	auto expeditions = ExpeditionsRepository::GetAllWithLeaderName(database);
 	zone->expedition_cache.clear();
+	zone->expedition_cache.reserve(expeditions.size());
 
-	// load all active expeditions and members to current zone cache
-	auto results = ExpeditionDatabase::LoadAllExpeditions();
-	if (!results.Success())
-	{
-		LogExpeditions("Failed to load Expeditions for zone cache");
-		return false;
-	}
+	CacheExpeditions(std::move(expeditions));
 
-	CacheExpeditions(results);
-
-	auto elapsed = benchmark.elapsed();
-	LogExpeditions("Caching [{}] expedition(s) took [{}s]", zone->expedition_cache.size(), elapsed);
+	LogExpeditions("Caching [{}] expedition(s) took [{}s]", zone->expedition_cache.size(), benchmark.elapsed());
 
 	return true;
 }
@@ -391,48 +355,6 @@ bool Expedition::HasReplayLockout()
 	return HasLockout(DZ_REPLAY_TIMER_NAME);
 }
 
-bool Expedition::HasMember(uint32_t character_id)
-{
-	return std::any_of(m_members.begin(), m_members.end(), [&](const ExpeditionMember& member) {
-		return member.char_id == character_id;
-	});
-}
-
-bool Expedition::HasMember(const std::string& character_name)
-{
-	return std::any_of(m_members.begin(), m_members.end(), [&](const ExpeditionMember& member) {
-		return (strcasecmp(member.name.c_str(), character_name.c_str()) == 0);
-	});
-}
-
-ExpeditionMember Expedition::GetMemberData(uint32_t character_id)
-{
-	auto it = std::find_if(m_members.begin(), m_members.end(), [&](const ExpeditionMember& member) {
-		return member.char_id == character_id;
-	});
-
-	ExpeditionMember member_data;
-	if (it != m_members.end())
-	{
-		member_data = *it;
-	}
-	return member_data;
-}
-
-ExpeditionMember Expedition::GetMemberData(const std::string& character_name)
-{
-	auto it = std::find_if(m_members.begin(), m_members.end(), [&](const ExpeditionMember& member) {
-		return (strcasecmp(member.name.c_str(), character_name.c_str()) == 0);
-	});
-
-	ExpeditionMember member_data;
-	if (it != m_members.end())
-	{
-		member_data = *it;
-	}
-	return member_data;
-}
-
 void Expedition::SetReplayLockoutOnMemberJoin(bool add_on_join, bool update_db)
 {
 	m_add_replay_on_join = add_on_join;
@@ -526,20 +448,6 @@ void Expedition::RemoveLockout(const std::string& event_name)
 	SendWorldLockoutUpdate(lockout, true);
 }
 
-void Expedition::AddInternalMember(
-	const std::string& char_name, uint32_t character_id, ExpeditionMemberStatus status)
-{
-	auto it = std::find_if(m_members.begin(), m_members.end(),
-		[character_id](const ExpeditionMember& member) {
-			return member.char_id == character_id;
-		});
-
-	if (it == m_members.end())
-	{
-		m_members.emplace_back(character_id, char_name, status);
-	}
-}
-
 bool Expedition::AddMember(const std::string& add_char_name, uint32_t add_char_id)
 {
 	if (HasMember(add_char_id))
@@ -644,10 +552,7 @@ void Expedition::UpdateMemberStatus(uint32_t update_member_id, ExpeditionMemberS
 	}
 
 	// if zone already had this member status cached avoid packet update to clients
-	auto it = std::find_if(m_members.begin(), m_members.end(),
-		[&](const ExpeditionMember& member) { return member.char_id == update_member_id; });
-
-	if (it != m_members.end() && it->status == status)
+	if (member_data.status == status)
 	{
 		return;
 	}
@@ -1197,7 +1102,7 @@ void Expedition::ProcessMemberAdded(const std::string& char_name, uint32_t added
 		leader_client->MessageString(Chat::Yellow, EXPEDITION_MEMBER_ADDED, char_name.c_str(), m_expedition_name.c_str());
 	}
 
-	AddInternalMember(char_name, added_char_id, ExpeditionMemberStatus::Online);
+	AddInternalMember({ added_char_id, char_name, ExpeditionMemberStatus::Online });
 
 	Client* member_client = entity_list.GetClientByCharID(added_char_id);
 	if (member_client)

zone/expedition.h

@@ -22,8 +22,9 @@
 #define EXPEDITION_H
 
 #include "dynamic_zone.h"
-#include "../common/eq_constants.h"
+#include "../common/expedition_base.h"
 #include "../common/expedition_lockout_timer.h"
+#include "../common/repositories/expeditions_repository.h"
 #include <cstdint>
 #include <memory>
 #include <string>
@@ -34,21 +35,11 @@ class Client;
 class EQApplicationPacket;
 struct ExpeditionInvite;
 class ExpeditionRequest;
-class MySQLRequestResult;
 class ServerPacket;
 
 extern const char* const DZ_YOU_NOT_ASSIGNED;
 extern const char* const EXPEDITION_OTHER_BELONGS;
 
-enum class ExpeditionMemberStatus : uint8_t
-{
-	Unknown = 0,
-	Online,
-	Offline,
-	InDynamicZone,
-	LinkDead
-};
-
 enum class ExpeditionLockMessage : uint8_t
 {
 	None = 0,
@@ -56,25 +47,10 @@ enum class ExpeditionLockMessage : uint8_t
 	Begin
 };
 
-struct ExpeditionMember
-{
-	uint32_t char_id = 0;
-	std::string name;
-	ExpeditionMemberStatus status = ExpeditionMemberStatus::Online;
-
-	ExpeditionMember() = default;
-	ExpeditionMember(uint32_t char_id_, const std::string& name_)
-		: char_id(char_id_), name(name_) {}
-	ExpeditionMember(uint32_t char_id_, const std::string& name_, ExpeditionMemberStatus status_)
-		: char_id(char_id_), name(name_), status(status_) {}
-
-	bool IsValid() const { return char_id != 0 && !name.empty(); }
-};
-
-class Expedition
+class Expedition : public ExpeditionBase
 {
 public:
-	Expedition() = delete;
+	Expedition() = default;
 	Expedition(uint32_t id, const std::string& uuid, DynamicZone&& dz, const std::string& expedition_name,
 		const ExpeditionMember& leader, uint32_t min_players, uint32_t max_players);
 
@@ -103,23 +79,10 @@ public:
 		const std::string& expedition_name = {}, const std::string& event_name = {});
 	static void AddLockoutClients(const ExpeditionLockoutTimer& lockout, uint32_t exclude_id = 0);
 
-	uint32_t GetDynamicZoneID() const { return m_dynamiczone.GetID(); }
-	uint32_t GetID() const { return m_id; }
-	uint16_t GetInstanceID() const { return m_dynamiczone.GetInstanceID(); }
-	uint32_t GetLeaderID() const { return m_leader.char_id; }
-	uint32_t GetMinPlayers() const { return m_min_players; }
-	uint32_t GetMaxPlayers() const { return m_max_players; }
-	uint32_t GetMemberCount() const { return static_cast<uint32_t>(m_members.size()); }
 	DynamicZone& GetDynamicZone() { return m_dynamiczone; }
-	const std::string& GetName() const { return m_expedition_name; }
-	const std::string& GetLeaderName() const { return m_leader.name; }
-	const std::string& GetUUID() const { return m_uuid; }
 	const std::unordered_map<std::string, ExpeditionLockoutTimer>& GetLockouts() const { return m_lockouts; }
-	const std::vector<ExpeditionMember>& GetMembers() const { return m_members; }
 
 	bool AddMember(const std::string& add_char_name, uint32_t add_char_id);
-	bool HasMember(const std::string& character_name);
-	bool HasMember(uint32_t character_id);
 	void RemoveAllMembers(bool enable_removal_timers = true);
 	bool RemoveMember(const std::string& remove_char_name);
 	void SetMemberStatus(Client* client, ExpeditionMemberStatus status);
@@ -164,13 +127,12 @@ public:
 	static const int32_t EVENT_TIMER_ID;
 
 private:
-	static void CacheExpeditions(MySQLRequestResult& results);
+	static void CacheExpeditions(std::vector<ExpeditionsRepository::ExpeditionWithLeader>&& expeditions);
 	static void SendWorldGetOnlineMembers(const std::vector<std::pair<uint32_t, uint32_t>>& expedition_character_ids);
 	static void SendWorldCharacterLockout(uint32_t character_id, const ExpeditionLockoutTimer& lockout, bool remove);
 
 	void AddLockout(const ExpeditionLockoutTimer& lockout, bool members_only = false);
 	void AddLockoutDurationClients(const ExpeditionLockoutTimer& lockout, int seconds, uint32_t exclude_id = 0);
-	void AddInternalMember(const std::string& char_name, uint32_t char_id, ExpeditionMemberStatus status);
 	bool ConfirmLeaderCommand(Client* requester);
 	bool ProcessAddConflicts(Client* leader_client, Client* add_client, bool swapping);
 	void ProcessLeaderChanged(uint32_t new_leader_id);
@@ -207,8 +169,6 @@ private:
 		const std::string& swap_remove_name, Client* leader_client = nullptr);
 	void UpdateMemberStatus(uint32_t update_character_id, ExpeditionMemberStatus status);
 
-	ExpeditionMember GetMemberData(uint32_t character_id);
-	ExpeditionMember GetMemberData(const std::string& character_name);
 	std::unique_ptr<EQApplicationPacket> CreateExpireWarningPacket(uint32_t minutes_remaining);
 	std::unique_ptr<EQApplicationPacket> CreateInfoPacket(bool clear = false);
 	std::unique_ptr<EQApplicationPacket> CreateInvitePacket(const std::string& inviter_name, const std::string& swap_remove_name);
@@ -217,16 +177,7 @@ private:
 	std::unique_ptr<EQApplicationPacket> CreateMemberListStatusPacket(const std::string& name, ExpeditionMemberStatus status);
 	std::unique_ptr<EQApplicationPacket> CreateLeaderNamePacket();
 
-	uint32_t    m_id                 = 0;
-	uint32_t    m_min_players        = 0;
-	uint32_t    m_max_players        = 0;
-	bool        m_is_locked          = false;
-	bool        m_add_replay_on_join = true;
-	std::string m_uuid;
-	std::string m_expedition_name;
 	DynamicZone m_dynamiczone { DynamicZoneType::Expedition };
-	ExpeditionMember m_leader;
-	std::vector<ExpeditionMember> m_members;
 	std::unordered_map<std::string, ExpeditionLockoutTimer> m_lockouts;
 	std::unordered_map<uint32_t, std::string> m_npc_loot_events;   // only valid inside dz zone
 	std::unordered_map<uint32_t, std::string> m_spawn_loot_events; // only valid inside dz zone

zone/expedition_database.cpp

@@ -51,52 +51,6 @@ uint32_t ExpeditionDatabase::InsertExpedition(
 	return results.LastInsertedID();
 }
 
-std::string ExpeditionDatabase::LoadExpeditionsSelectQuery()
-{
-	return std::string(SQL(
-		SELECT
-			expeditions.id,
-			expeditions.uuid,
-			expeditions.dynamic_zone_id,
-			expeditions.expedition_name,
-			expeditions.leader_id,
-			expeditions.min_players,
-			expeditions.max_players,
-			expeditions.add_replay_on_join,
-			expeditions.is_locked,
-			character_data.name leader_name,
-			expedition_members.character_id,
-			member_data.name
-		FROM expeditions
-			INNER JOIN character_data ON expeditions.leader_id = character_data.id
-			INNER JOIN expedition_members ON expeditions.id = expedition_members.expedition_id
-				AND expedition_members.is_current_member = TRUE
-			INNER JOIN character_data member_data ON expedition_members.character_id = member_data.id
-	));
-}
-
-MySQLRequestResult ExpeditionDatabase::LoadExpedition(uint32_t expedition_id)
-{
-	LogExpeditionsDetail("Loading expedition [{}]", expedition_id);
-
-	std::string query = fmt::format(SQL(
-		{} WHERE expeditions.id = {};
-	), LoadExpeditionsSelectQuery(), expedition_id);
-
-	return database.QueryDatabase(query);
-}
-
-MySQLRequestResult ExpeditionDatabase::LoadAllExpeditions()
-{
-	LogExpeditionsDetail("Loading all expeditions from database");
-
-	std::string query = fmt::format(SQL(
-		{} ORDER BY expeditions.id;
-	), LoadExpeditionsSelectQuery());
-
-	return database.QueryDatabase(query);
-}
-
 std::vector<ExpeditionLockoutTimer> ExpeditionDatabase::LoadCharacterLockouts(uint32_t character_id)
 {
 	LogExpeditionsDetail("Loading character [{}] lockouts", character_id);
@@ -170,54 +124,6 @@ std::vector<ExpeditionLockoutTimer> ExpeditionDatabase::LoadCharacterLockouts(
 	return lockouts;
 }
 
-std::unordered_map<uint32_t, std::unordered_map<std::string, ExpeditionLockoutTimer>>
-ExpeditionDatabase::LoadMultipleExpeditionLockouts(
-	const std::vector<uint32_t>& expedition_ids)
-{
-	LogExpeditionsDetail("Loading internal lockouts for [{}] expeditions", expedition_ids.size());
-
-	std::string in_expedition_ids_query = fmt::format("{}", fmt::join(expedition_ids, ","));
-
-	// these are loaded into the same container type expeditions use to store lockouts
-	std::unordered_map<uint32_t, std::unordered_map<std::string, ExpeditionLockoutTimer>> lockouts;
-
-	if (!in_expedition_ids_query.empty())
-	{
-		std::string query = fmt::format(SQL(
-			SELECT
-				expedition_lockouts.expedition_id,
-				expedition_lockouts.from_expedition_uuid,
-				expeditions.expedition_name,
-				expedition_lockouts.event_name,
-				UNIX_TIMESTAMP(expedition_lockouts.expire_time),
-				expedition_lockouts.duration
-			FROM expedition_lockouts
-				INNER JOIN expeditions ON expedition_lockouts.expedition_id = expeditions.id
-			WHERE expedition_id IN ({})
-			ORDER BY expedition_id;
-		), in_expedition_ids_query);
-
-		auto results = database.QueryDatabase(query);
-
-		if (results.Success())
-		{
-			for (auto row = results.begin(); row != results.end(); ++row)
-			{
-				auto expedition_id = strtoul(row[0], nullptr, 10);
-				lockouts[expedition_id].emplace(row[3], ExpeditionLockoutTimer{
-					row[1],                                               // expedition_uuid
-					row[2],                                               // expedition_name
-					row[3],                                               // event_name
-					strtoull(row[4], nullptr, 10),                        // expire_time
-					static_cast<uint32_t>(strtoul(row[5], nullptr, 10))   // original duration
-				});
-			}
-		}
-	}
-
-	return lockouts;
-}
-
 void ExpeditionDatabase::DeleteAllCharacterLockouts(uint32_t character_id)
 {
 	LogExpeditionsDetail("Deleting all character [{}] lockouts", character_id);

zone/expedition_database.h

@@ -38,14 +38,9 @@ namespace ExpeditionDatabase
 	uint32_t InsertExpedition(
 		const std::string& uuid, uint32_t instance_id, const std::string& expedition_name,
 		uint32_t leader_id, uint32_t min_players, uint32_t max_players);
-	std::string LoadExpeditionsSelectQuery();
-	MySQLRequestResult LoadExpedition(uint32_t expedition_id);
-	MySQLRequestResult LoadAllExpeditions();
 	std::vector<ExpeditionLockoutTimer> LoadCharacterLockouts(uint32_t character_id);
 	std::vector<ExpeditionLockoutTimer> LoadCharacterLockouts(uint32_t character_id,
 		const std::string& expedition_name);
-	std::unordered_map<uint32_t, std::unordered_map<std::string, ExpeditionLockoutTimer>>
-		LoadMultipleExpeditionLockouts(const std::vector<uint32_t>& expedition_ids);
 	void DeleteAllMembers(uint32_t expedition_id);
 	void DeleteMember(uint32_t expedition_id, uint32_t character_id);
 	void DeleteAllCharacterLockouts(uint32_t character_id);
@@ -73,23 +68,4 @@ namespace ExpeditionDatabase
 		const ExpeditionLockoutTimer& lockout, int seconds);
 };
 
-namespace LoadExpeditionColumns
-{
-	enum eLoadExpeditionColumns
-	{
-		id = 0,
-		uuid,
-		dz_id,
-		expedition_name,
-		leader_id,
-		min_players,
-		max_players,
-		add_replay_on_join,
-		is_locked,
-		leader_name,
-		member_id,
-		member_name
-	};
-};
-
 #endif

zone/lua_expedition.cpp

@@ -59,7 +59,7 @@ void Lua_Expedition::AddReplayLockoutDuration(int seconds, bool members_only) {
 
 uint32_t Lua_Expedition::GetDynamicZoneID() {
 	Lua_Safe_Call_Int();
-	return self->GetDynamicZoneID();
+	return self->GetDynamicZone().GetID();
 }
 
 uint32_t Lua_Expedition::GetID() {

zone/perl_expedition.cpp

@@ -142,7 +142,7 @@ XS(XS_Expedition_GetDynamicZoneID) {
 	Expedition* THIS = nullptr;
 	VALIDATE_THIS_IS_EXPEDITION;
 
-	XSRETURN_UV(THIS->GetDynamicZoneID());
+	XSRETURN_UV(THIS->GetDynamicZone().GetID());
 }
 
 XS(XS_Expedition_GetID);
@@ -168,7 +168,7 @@ XS(XS_Expedition_GetInstanceID) {
 	Expedition* THIS = nullptr;
 	VALIDATE_THIS_IS_EXPEDITION;
 
-	XSRETURN_UV(THIS->GetInstanceID());
+	XSRETURN_UV(THIS->GetDynamicZone().GetInstanceID());
 }
 
 XS(XS_Expedition_GetLeaderName);