[Expeditions] Refactor expedition requests (#1301)

Move ExpeditionLockoutTimer to common

This simplifies expedition request conflict checks and uses repository
for the queries instead of processing the query result directly.

common/CMakeLists.txt

@@ -31,6 +31,7 @@ SET(common_sources
 	eq_stream_proxy.cpp
 	eqtime.cpp
 	event_sub.cpp
+	expedition_lockout_timer.cpp
 	extprofile.cpp
 	faction.cpp
 	file_util.cpp
@@ -488,6 +489,7 @@ SET(common_headers
 	eqtime.h
 	errmsg.h
 	event_sub.h
+	expedition_lockout_timer.h
 	extprofile.h
 	faction.h
 	file_util.h

common/expedition_lockout_timer.cpp

@@ -0,0 +1,101 @@
+/**
+ * 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
+ *
+ */
+
+#include "expedition_lockout_timer.h"
+#include "../common/string_util.h"
+#include "../common/rulesys.h"
+#include "../common/util/uuid.h"
+#include <fmt/format.h>
+
+const char* const DZ_REPLAY_TIMER_NAME = "Replay Timer"; // see December 14, 2016 patch notes
+
+ExpeditionLockoutTimer::ExpeditionLockoutTimer(
+	std::string expedition_uuid, std::string expedition_name,
+	std::string event_name, uint64_t expire_time, uint32_t duration
+) :
+	m_expedition_uuid{std::move(expedition_uuid)},
+	m_expedition_name{std::move(expedition_name)},
+	m_event_name{std::move(event_name)},
+	m_expire_time(std::chrono::system_clock::from_time_t(expire_time)),
+	m_duration(duration)
+{
+	if (m_event_name == DZ_REPLAY_TIMER_NAME)
+	{
+		m_is_replay_timer = true;
+	}
+}
+
+ExpeditionLockoutTimer ExpeditionLockoutTimer::CreateLockout(
+	const std::string& expedition_name, const std::string& event_name, uint32_t seconds, std::string uuid)
+{
+	seconds = static_cast<uint32_t>(seconds * RuleR(Expedition, LockoutDurationMultiplier));
+
+	if (uuid.empty())
+	{
+		uuid = EQ::Util::UUID::Generate().ToString();
+	}
+
+	ExpeditionLockoutTimer lockout{uuid, expedition_name, event_name, 0, seconds};
+	lockout.Reset(); // sets expire time
+	return lockout;
+}
+
+uint32_t ExpeditionLockoutTimer::GetSecondsRemaining() const
+{
+	auto now = std::chrono::system_clock::now();
+	if (m_expire_time > now)
+	{
+		auto remaining = m_expire_time - now;
+		return static_cast<uint32_t>(std::chrono::duration_cast<std::chrono::seconds>(remaining).count());
+	}
+	return 0;
+}
+
+ExpeditionLockoutTimer::DaysHoursMinutes ExpeditionLockoutTimer::GetDaysHoursMinutesRemaining() const
+{
+	auto seconds = GetSecondsRemaining();
+	return ExpeditionLockoutTimer::DaysHoursMinutes{
+		fmt::format_int(seconds / 86400).str(),       // days
+		fmt::format_int((seconds / 3600) % 24).str(), // hours
+		fmt::format_int((seconds / 60) % 60).str()    // minutes
+	};
+}
+
+bool ExpeditionLockoutTimer::IsSameLockout(const ExpeditionLockoutTimer& compare_lockout) const
+{
+	return compare_lockout.IsSameLockout(GetExpeditionName(), GetEventName());
+}
+
+bool ExpeditionLockoutTimer::IsSameLockout(
+	const std::string& expedition_name, const std::string& event_name) const
+{
+	return GetExpeditionName() == expedition_name && GetEventName() == event_name;
+}
+
+void ExpeditionLockoutTimer::AddLockoutTime(int seconds)
+{
+	seconds = static_cast<uint32_t>(seconds * RuleR(Expedition, LockoutDurationMultiplier));
+
+	auto new_duration = std::max(0, static_cast<int>(m_duration.count()) + seconds);
+
+	auto start_time = m_expire_time - m_duration;
+	m_duration = std::chrono::seconds(new_duration);
+	m_expire_time = start_time + m_duration;
+}

common/expedition_lockout_timer.h

@@ -0,0 +1,76 @@
+/**
+ * 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 EXPEDITION_LOCKOUT_TIMER_H
+#define EXPEDITION_LOCKOUT_TIMER_H
+
+#include <chrono>
+#include <string>
+
+extern const char* const DZ_REPLAY_TIMER_NAME;
+
+class ExpeditionLockoutTimer
+{
+public:
+	ExpeditionLockoutTimer() = default;
+	ExpeditionLockoutTimer(
+		std::string expedition_uuid, std::string expedition_name,
+		std::string event_name, uint64_t expire_time, uint32_t duration);
+
+	static ExpeditionLockoutTimer CreateLockout(
+		const std::string& expedition_name, const std::string& event_name,
+		uint32_t seconds, std::string uuid = {});
+
+	struct DaysHoursMinutes
+	{
+		std::string days;
+		std::string hours;
+		std::string mins;
+	};
+
+	void AddLockoutTime(int seconds);
+	uint32_t GetDuration() const { return static_cast<uint32_t>(m_duration.count()); }
+	uint64_t GetExpireTime() const { return std::chrono::system_clock::to_time_t(m_expire_time); }
+	uint64_t GetStartTime() const { return std::chrono::system_clock::to_time_t(m_expire_time - m_duration); }
+	uint32_t GetSecondsRemaining() const;
+	DaysHoursMinutes GetDaysHoursMinutesRemaining() const;
+	const std::string& GetExpeditionName() const { return m_expedition_name; }
+	const std::string& GetExpeditionUUID() const { return m_expedition_uuid; }
+	const std::string& GetEventName() const { return m_event_name; }
+	bool IsExpired() const { return GetSecondsRemaining() == 0; }
+	bool IsFromExpedition(const std::string& uuid) const { return uuid == m_expedition_uuid; }
+	bool IsReplayTimer() const { return m_is_replay_timer; }
+	bool IsSameLockout(const ExpeditionLockoutTimer& compare_lockout) const;
+	bool IsSameLockout(const std::string& expedition_name, const std::string& event_name) const;
+	void Reset() { m_expire_time = std::chrono::system_clock::now() + m_duration; }
+	void SetDuration(uint32_t seconds) { m_duration = std::chrono::seconds(seconds); }
+	void SetExpireTime(uint64_t expire_time) { m_expire_time = std::chrono::system_clock::from_time_t(expire_time); }
+	void SetUUID(const std::string& uuid) { m_expedition_uuid = uuid; }
+
+private:
+	bool m_is_replay_timer = false;
+	std::string m_expedition_uuid; // expedition received in
+	std::string m_expedition_name;
+	std::string m_event_name;
+	std::chrono::seconds m_duration;
+	std::chrono::time_point<std::chrono::system_clock> m_expire_time;
+};
+
+#endif

common/repositories/base/base_character_expedition_lockouts_repository.h

@@ -81,7 +81,7 @@ public:
 		entry.character_id         = 0;
 		entry.expedition_name      = "";
 		entry.event_name           = "";
-		entry.expire_time          = current_timestamp();
+		entry.expire_time          = "";
 		entry.duration             = 0;
 		entry.from_expedition_uuid = "";
 

common/repositories/character_expedition_lockouts_repository.h

@@ -22,8 +22,10 @@
 #define EQEMU_CHARACTER_EXPEDITION_LOCKOUTS_REPOSITORY_H
 
 #include "../database.h"
+#include "../expedition_lockout_timer.h"
 #include "../string_util.h"
 #include "base/base_character_expedition_lockouts_repository.h"
+#include <unordered_map>
 
 class CharacterExpeditionLockoutsRepository: public BaseCharacterExpeditionLockoutsRepository {
 public:
@@ -65,6 +67,78 @@ public:
 
 	// Custom extended repository methods here
 
+	struct CharacterExpeditionLockoutsTimeStamp {
+		int         id;
+		int         character_id;
+		std::string expedition_name;
+		std::string event_name;
+		time_t      expire_time;
+		int         duration;
+		std::string from_expedition_uuid;
+	};
+
+	static ExpeditionLockoutTimer GetExpeditionLockoutTimerFromEntry(
+		CharacterExpeditionLockoutsTimeStamp&& entry)
+	{
+		ExpeditionLockoutTimer lockout_timer{
+			std::move(entry.from_expedition_uuid),
+			std::move(entry.expedition_name),
+			std::move(entry.event_name),
+			static_cast<uint64_t>(entry.expire_time),
+			static_cast<uint32_t>(entry.duration)
+		};
+
+		return lockout_timer;
+	}
+
+	static std::unordered_map<uint32_t, std::vector<ExpeditionLockoutTimer>> GetManyCharacterLockoutTimers(
+		Database& db, const std::vector<uint32_t>& character_ids,
+		const std::string& expedition_name, const std::string& ordered_event_name)
+	{
+		auto joined_character_ids = fmt::join(character_ids, ",");
+
+		auto results = db.QueryDatabase(fmt::format(SQL(
+			SELECT
+				character_id,
+				UNIX_TIMESTAMP(expire_time),
+				duration,
+				event_name,
+				from_expedition_uuid
+			FROM character_expedition_lockouts
+			WHERE
+				character_id IN ({})
+				AND expire_time > NOW()
+				AND expedition_name = '{}'
+			ORDER BY
+				FIELD(character_id, {}),
+				FIELD(event_name, '{}') DESC
+		),
+			joined_character_ids,
+			EscapeString(expedition_name),
+			joined_character_ids,
+			EscapeString(ordered_event_name)
+		));
+
+		std::unordered_map<uint32_t, std::vector<ExpeditionLockoutTimer>> lockouts;
+
+		for (auto row = results.begin(); row != results.end(); ++row)
+		{
+			CharacterExpeditionLockoutsTimeStamp entry{};
+
+			int col = 0;
+			entry.character_id         = std::strtoul(row[col++], nullptr, 10);
+			entry.expire_time          = std::strtoull(row[col++], nullptr, 10);
+			entry.duration             = std::strtoul(row[col++], nullptr, 10);
+			entry.event_name           = row[col++];
+			entry.expedition_name      = expedition_name;
+			entry.from_expedition_uuid = row[col++];
+
+			auto lockout = GetExpeditionLockoutTimerFromEntry(std::move(entry));
+			lockouts[entry.character_id].emplace_back(std::move(lockout));
+		}
+
+		return lockouts;
+	}
 };
 
 #endif //EQEMU_CHARACTER_EXPEDITION_LOCKOUTS_REPOSITORY_H

common/repositories/expeditions_repository.h

@@ -65,6 +65,61 @@ public:
 
 	// Custom extended repository methods here
 
+	struct CharacterExpedition
+	{
+		uint32_t    id;
+		std::string name;
+		uint32_t    expedition_id;
+	};
+
+	static std::vector<CharacterExpedition> GetCharactersWithExpedition(
+		Database& db, const std::vector<std::string>& character_names)
+	{
+		if (character_names.empty())
+		{
+			return {};
+		}
+
+		std::vector<CharacterExpedition> entries;
+
+		auto joined_character_names = fmt::format("'{}'", fmt::join(character_names, "','"));
+
+		auto results = db.QueryDatabase(fmt::format(SQL(
+			SELECT
+				character_data.id,
+				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 expeditions
+					ON expedition_members.expedition_id = expeditions.id
+			WHERE character_data.name IN ({})
+			GROUP BY character_data.id
+			ORDER BY FIELD(character_data.name, {})
+		),
+			joined_character_names,
+			joined_character_names
+		));
+
+		if (results.Success())
+		{
+			entries.reserve(results.RowCount());
+
+			for (auto row = results.begin(); row != results.end(); ++row)
+			{
+				CharacterExpedition entry{};
+				entry.id            = std::strtoul(row[0], nullptr, 10);
+				entry.name          = row[1];
+				entry.expedition_id = row[2] ? std::strtoul(row[2], nullptr, 10) : 0;
+
+				entries.emplace_back(std::move(entry));
+			}
+		}
+
+		return entries;
+	}
 };
 
 #endif //EQEMU_EXPEDITIONS_REPOSITORY_H