public void SendCalendarEventInvite(CalendarInvite invite)
{
CalendarEvent calendarEvent = GetEvent(invite.EventId);
ObjectGuid invitee = invite.InviteeGuid;
Player player = Global.ObjAccessor.FindPlayer(invitee);
uint level = player ? player.GetLevel() : Global.CharacterCacheStorage.GetCharacterLevelByGuid(invitee);
SCalendarEventInvite packet = new SCalendarEventInvite();
packet.EventID = calendarEvent != null ? calendarEvent.EventId : 0;
packet.InviteGuid = invitee;
packet.InviteID = calendarEvent != null ? invite.InviteId : 0;
packet.Level = (byte)level;
packet.ResponseTime = invite.ResponseTime;
packet.Status = invite.Status;
packet.Type = (byte)(calendarEvent != null ? calendarEvent.IsGuildEvent() ? 1 : 0 : 0); // Correct ?
packet.ClearPending = calendarEvent != null ? !calendarEvent.IsGuildEvent() : true; // Correct ?
if (calendarEvent == null) // Pre-invite
{
player = Global.ObjAccessor.FindPlayer(invite.SenderGuid);
if (player)
{
player.SendPacket(packet);
}
}
else
{
if (calendarEvent.OwnerGuid != invite.InviteeGuid) // correct?
{
SendPacketToAllEventRelatives(packet, calendarEvent);
}
}
}
public void RemoveInvite(ulong inviteId, ulong eventId, ObjectGuid remover)
{
CalendarEvent calendarEvent = GetEvent(eventId);
if (calendarEvent == null)
{
return;
}
CalendarInvite calendarInvite = null;
foreach (var invite in _invites[eventId])
{
if (invite.InviteId == inviteId)
{
calendarInvite = invite;
break;
}
}
if (calendarInvite == null)
{
return;
}
SQLTransaction trans = new SQLTransaction();
PreparedStatement stmt = DB.Characters.GetPreparedStatement(CharStatements.DEL_CALENDAR_INVITE);
stmt.AddValue(0, calendarInvite.InviteId);
trans.Append(stmt);
DB.Characters.CommitTransaction(trans);
if (!calendarEvent.IsGuildEvent())
{
SendCalendarEventInviteRemoveAlert(calendarInvite.InviteeGuid, calendarEvent, CalendarInviteStatus.Removed);
}
SendCalendarEventInviteRemove(calendarEvent, calendarInvite, (uint)calendarEvent.Flags);
// we need to find out how to use CALENDAR_INVITE_REMOVED_MAIL_SUBJECT to force client to display different mail
//if (itr._invitee != remover)
// MailDraft(calendarEvent.BuildCalendarMailSubject(remover), calendarEvent.BuildCalendarMailBody())
// .SendMailTo(trans, MailReceiver(itr.GetInvitee()), calendarEvent, MAIL_CHECK_MASK_COPIED);
_invites.Remove(eventId, calendarInvite);
}
public void AddInvite(CalendarEvent calendarEvent, CalendarInvite invite, SQLTransaction trans = null)
{
if (!calendarEvent.IsGuildAnnouncement() && calendarEvent.OwnerGuid != invite.InviteeGuid)
{
SendCalendarEventInvite(invite);
}
if (!calendarEvent.IsGuildEvent() || invite.InviteeGuid == calendarEvent.OwnerGuid)
{
SendCalendarEventInviteAlert(calendarEvent, invite);
}
if (!calendarEvent.IsGuildAnnouncement())
{
_invites.Add(invite.EventId, invite);
UpdateInvite(invite, trans);
}
}
void SendCalendarEventInviteAlert(CalendarEvent calendarEvent, CalendarInvite invite)
{
CalendarEventInviteAlert packet = new CalendarEventInviteAlert();
packet.Date = calendarEvent.Date;
packet.EventID = calendarEvent.EventId;
packet.EventName = calendarEvent.Title;
packet.EventType = calendarEvent.EventType;
packet.Flags = calendarEvent.Flags;
packet.InviteID = invite.InviteId;
packet.InvitedByGuid = invite.SenderGuid;
packet.ModeratorStatus = invite.Rank;
packet.OwnerGuid = calendarEvent.OwnerGuid;
packet.Status = invite.Status;
packet.TextureID = calendarEvent.TextureId;
Guild guild = Global.GuildMgr.GetGuildById(calendarEvent.GuildId);
packet.EventGuildID = guild ? guild.GetGUID() : ObjectGuid.Empty;
if (calendarEvent.IsGuildEvent() || calendarEvent.IsGuildAnnouncement())
{
guild = Global.GuildMgr.GetGuildById(calendarEvent.GuildId);
if (guild)
{
guild.BroadcastPacket(packet);
}
}
else
{
Player player = Global.ObjAccessor.FindPlayer(invite.InviteeGuid);
if (player)
{
player.SendPacket(packet);
}
}
}
void HandleCalendarEventSignup(CalendarEventSignUp calendarEventSignUp)
{
ObjectGuid guid = GetPlayer().GetGUID();
CalendarEvent calendarEvent = Global.CalendarMgr.GetEvent(calendarEventSignUp.EventID);
if (calendarEvent != null)
{
if (calendarEvent.IsGuildEvent() && calendarEvent.GuildId != GetPlayer().GetGuildId())
{
Global.CalendarMgr.SendCalendarCommandResult(guid, CalendarError.GuildPlayerNotInGuild);
return;
}
CalendarInviteStatus status = calendarEventSignUp.Tentative ? CalendarInviteStatus.Tentative : CalendarInviteStatus.SignedUp;
CalendarInvite invite = new(Global.CalendarMgr.GetFreeInviteId(), calendarEventSignUp.EventID, guid, guid, GameTime.GetGameTime(), status, CalendarModerationRank.Player, "");
Global.CalendarMgr.AddInvite(calendarEvent, invite);
Global.CalendarMgr.SendCalendarClearPendingAction(guid);
}
else
{
Global.CalendarMgr.SendCalendarCommandResult(guid, CalendarError.EventInvalid);
}
}
public void RemovePlayerGuildEventsAndSignups(ObjectGuid guid, ulong guildId)
{
foreach (var calendarEvent in _events)
{
if (calendarEvent.OwnerGuid == guid && (calendarEvent.IsGuildEvent() || calendarEvent.IsGuildAnnouncement()))
{
RemoveEvent(calendarEvent.EventId, guid);
}
}
List <CalendarInvite> playerInvites = GetPlayerInvites(guid);
foreach (var playerCalendarEvent in playerInvites)
{
CalendarEvent calendarEvent = GetEvent(playerCalendarEvent.EventId);
if (calendarEvent != null)
{
if (calendarEvent.IsGuildEvent() && calendarEvent.GuildId == guildId)
{
RemoveInvite(playerCalendarEvent.InviteId, playerCalendarEvent.EventId, guid);
}
}
}
}
void HandleCalendarGetCalendar(CalendarGetCalendar calendarGetCalendar)
{
ObjectGuid guid = GetPlayer().GetGUID();
long currTime = GameTime.GetGameTime();
CalendarSendCalendar packet = new();
packet.ServerTime = currTime;
var invites = Global.CalendarMgr.GetPlayerInvites(guid);
foreach (var invite in invites)
{
CalendarSendCalendarInviteInfo inviteInfo = new();
inviteInfo.EventID = invite.EventId;
inviteInfo.InviteID = invite.InviteId;
inviteInfo.InviterGuid = invite.SenderGuid;
inviteInfo.Status = invite.Status;
inviteInfo.Moderator = invite.Rank;
CalendarEvent calendarEvent = Global.CalendarMgr.GetEvent(invite.EventId);
if (calendarEvent != null)
{
inviteInfo.InviteType = (byte)(calendarEvent.IsGuildEvent() && calendarEvent.GuildId == _player.GetGuildId() ? 1 : 0);
}
packet.Invites.Add(inviteInfo);
}
var playerEvents = Global.CalendarMgr.GetPlayerEvents(guid);
foreach (var calendarEvent in playerEvents)
{
CalendarSendCalendarEventInfo eventInfo;
eventInfo.EventID = calendarEvent.EventId;
eventInfo.Date = calendarEvent.Date;
eventInfo.EventClubID = calendarEvent.GuildId;
eventInfo.EventName = calendarEvent.Title;
eventInfo.EventType = calendarEvent.EventType;
eventInfo.Flags = calendarEvent.Flags;
eventInfo.OwnerGuid = calendarEvent.OwnerGuid;
eventInfo.TextureID = calendarEvent.TextureId;
packet.Events.Add(eventInfo);
}
foreach (var difficulty in CliDB.DifficultyStorage.Values)
{
var boundInstances = _player.GetBoundInstances((Difficulty)difficulty.Id);
if (boundInstances != null)
{
foreach (var boundInstance in boundInstances.Values)
{
if (boundInstance.perm)
{
CalendarSendCalendarRaidLockoutInfo lockoutInfo;
InstanceSave save = boundInstance.save;
lockoutInfo.MapID = (int)save.GetMapId();
lockoutInfo.DifficultyID = (uint)save.GetDifficultyID();
lockoutInfo.ExpireTime = save.GetResetTime() - currTime;
lockoutInfo.InstanceID = save.GetInstanceId(); // instance save id as unique instance copy id
packet.RaidLockouts.Add(lockoutInfo);
}
}
}
}
SendPacket(packet);
}
void HandleCalendarInvite(CalendarInvitePkt calendarInvite)
{
ObjectGuid playerGuid = GetPlayer().GetGUID();
ObjectGuid inviteeGuid = ObjectGuid.Empty;
Team inviteeTeam = 0;
ulong inviteeGuildId = 0;
if (!ObjectManager.NormalizePlayerName(ref calendarInvite.Name))
{
return;
}
Player player = Global.ObjAccessor.FindPlayerByName(calendarInvite.Name);
if (player)
{
// Invitee is online
inviteeGuid = player.GetGUID();
inviteeTeam = player.GetTeam();
inviteeGuildId = player.GetGuildId();
}
else
{
// Invitee offline, get data from database
ObjectGuid guid = Global.CharacterCacheStorage.GetCharacterGuidByName(calendarInvite.Name);
if (!guid.IsEmpty())
{
CharacterCacheEntry characterInfo = Global.CharacterCacheStorage.GetCharacterCacheByGuid(guid);
if (characterInfo != null)
{
inviteeGuid = guid;
inviteeTeam = Player.TeamForRace(characterInfo.RaceId);
inviteeGuildId = characterInfo.GuildId;
}
}
}
if (inviteeGuid.IsEmpty())
{
Global.CalendarMgr.SendCalendarCommandResult(playerGuid, CalendarError.PlayerNotFound);
return;
}
if (GetPlayer().GetTeam() != inviteeTeam && !WorldConfig.GetBoolValue(WorldCfg.AllowTwoSideInteractionCalendar))
{
Global.CalendarMgr.SendCalendarCommandResult(playerGuid, CalendarError.NotAllied);
return;
}
SQLResult result1 = DB.Characters.Query("SELECT flags FROM character_social WHERE guid = {0} AND friend = {1}", inviteeGuid, playerGuid);
if (!result1.IsEmpty())
{
if (Convert.ToBoolean(result1.Read <byte>(0) & (byte)SocialFlag.Ignored))
{
Global.CalendarMgr.SendCalendarCommandResult(playerGuid, CalendarError.IgnoringYouS, calendarInvite.Name);
return;
}
}
if (!calendarInvite.Creating)
{
CalendarEvent calendarEvent = Global.CalendarMgr.GetEvent(calendarInvite.EventID);
if (calendarEvent != null)
{
if (calendarEvent.IsGuildEvent() && calendarEvent.GuildId == inviteeGuildId)
{
// we can't invite guild members to guild events
Global.CalendarMgr.SendCalendarCommandResult(playerGuid, CalendarError.NoGuildInvites);
return;
}
CalendarInvite invite = new(Global.CalendarMgr.GetFreeInviteId(), calendarInvite.EventID, inviteeGuid, playerGuid, SharedConst.CalendarDefaultResponseTime, CalendarInviteStatus.Invited, CalendarModerationRank.Player, "");
Global.CalendarMgr.AddInvite(calendarEvent, invite);
}
else
{
Global.CalendarMgr.SendCalendarCommandResult(playerGuid, CalendarError.EventInvalid);
}
}
else
{
if (calendarInvite.IsSignUp && inviteeGuildId == GetPlayer().GetGuildId())
{
Global.CalendarMgr.SendCalendarCommandResult(playerGuid, CalendarError.NoGuildInvites);
return;
}
CalendarInvite invite = new(calendarInvite.EventID, 0, inviteeGuid, playerGuid, SharedConst.CalendarDefaultResponseTime, CalendarInviteStatus.Invited, CalendarModerationRank.Player, "");
Global.CalendarMgr.SendCalendarEventInvite(invite);
}
}
void HandleCalendarEventInvite(CalendarEventInvite calendarEventInvite)
{
ObjectGuid playerGuid = GetPlayer().GetGUID();
ObjectGuid inviteeGuid = ObjectGuid.Empty;
Team inviteeTeam = 0;
ulong inviteeGuildId = 0;
Player player = Global.ObjAccessor.FindPlayerByName(calendarEventInvite.Name);
if (player)
{
// Invitee is online
inviteeGuid = player.GetGUID();
inviteeTeam = player.GetTeam();
inviteeGuildId = player.GetGuildId();
}
else
{
// Invitee offline, get data from database
PreparedStatement stmt = DB.Characters.GetPreparedStatement(CharStatements.SEL_GUID_RACE_ACC_BY_NAME);
stmt.AddValue(0, calendarEventInvite.Name);
SQLResult result = DB.Characters.Query(stmt);
if (!result.IsEmpty())
{
inviteeGuid = ObjectGuid.Create(HighGuid.Player, result.Read <ulong>(0));
inviteeTeam = Player.TeamForRace((Race)result.Read <byte>(1));
inviteeGuildId = Player.GetGuildIdFromDB(inviteeGuid);
}
}
if (inviteeGuid.IsEmpty())
{
Global.CalendarMgr.SendCalendarCommandResult(playerGuid, CalendarError.PlayerNotFound);
return;
}
if (GetPlayer().GetTeam() != inviteeTeam && !WorldConfig.GetBoolValue(WorldCfg.AllowTwoSideInteractionCalendar))
{
Global.CalendarMgr.SendCalendarCommandResult(playerGuid, CalendarError.NotAllied);
return;
}
SQLResult result1 = DB.Characters.Query("SELECT flags FROM character_social WHERE guid = {0} AND friend = {1}", inviteeGuid, playerGuid);
if (!result1.IsEmpty())
{
if (Convert.ToBoolean(result1.Read <byte>(0) & (byte)SocialFlag.Ignored))
{
Global.CalendarMgr.SendCalendarCommandResult(playerGuid, CalendarError.IgnoringYouS, calendarEventInvite.Name);
return;
}
}
if (!calendarEventInvite.Creating)
{
CalendarEvent calendarEvent = Global.CalendarMgr.GetEvent(calendarEventInvite.EventID);
if (calendarEvent != null)
{
if (calendarEvent.IsGuildEvent() && calendarEvent.GuildId == inviteeGuildId)
{
// we can't invite guild members to guild events
Global.CalendarMgr.SendCalendarCommandResult(playerGuid, CalendarError.NoGuildInvites);
return;
}
CalendarInvite invite = new CalendarInvite(Global.CalendarMgr.GetFreeInviteId(), calendarEventInvite.EventID, inviteeGuid, playerGuid, SharedConst.CalendarDefaultResponseTime, CalendarInviteStatus.Invited, CalendarModerationRank.Player, "");
Global.CalendarMgr.AddInvite(calendarEvent, invite);
}
else
{
Global.CalendarMgr.SendCalendarCommandResult(playerGuid, CalendarError.EventInvalid);
}
}
else
{
if (calendarEventInvite.IsSignUp && inviteeGuildId == GetPlayer().GetGuildId())
{
Global.CalendarMgr.SendCalendarCommandResult(playerGuid, CalendarError.NoGuildInvites);
return;
}
CalendarInvite invite = new CalendarInvite(calendarEventInvite.EventID, 0, inviteeGuid, playerGuid, SharedConst.CalendarDefaultResponseTime, CalendarInviteStatus.Invited, CalendarModerationRank.Player, "");
Global.CalendarMgr.SendCalendarEventInvite(invite);
}
}
void HandleCalendarCopyEvent(CalendarCopyEvent calendarCopyEvent)
{
ObjectGuid guid = GetPlayer().GetGUID();
// prevent events in the past
// To Do: properly handle timezones and remove the "- time_t(86400L)" hack
if (calendarCopyEvent.Date < (GameTime.GetGameTime() - 86400L))
{
Global.CalendarMgr.SendCalendarCommandResult(guid, CalendarError.EventPassed);
return;
}
CalendarEvent oldEvent = Global.CalendarMgr.GetEvent(calendarCopyEvent.EventID);
if (oldEvent != null)
{
// Ensure that the player has access to the event
if (oldEvent.IsGuildEvent() || oldEvent.IsGuildAnnouncement())
{
if (oldEvent.GuildId != _player.GetGuildId())
{
Global.CalendarMgr.SendCalendarCommandResult(guid, CalendarError.EventInvalid);
return;
}
}
else
{
if (oldEvent.OwnerGuid != guid)
{
Global.CalendarMgr.SendCalendarCommandResult(guid, CalendarError.EventInvalid);
return;
}
}
// Check if the player reached the max number of events allowed to create
if (oldEvent.IsGuildEvent() || oldEvent.IsGuildAnnouncement())
{
if (Global.CalendarMgr.GetGuildEvents(_player.GetGuildId()).Count >= SharedConst.CalendarMaxGuildEvents)
{
Global.CalendarMgr.SendCalendarCommandResult(guid, CalendarError.GuildEventsExceeded);
return;
}
}
else
{
if (Global.CalendarMgr.GetEventsCreatedBy(guid).Count >= SharedConst.CalendarMaxEvents)
{
Global.CalendarMgr.SendCalendarCommandResult(guid, CalendarError.EventsExceeded);
return;
}
}
if (GetCalendarEventCreationCooldown() > GameTime.GetGameTime())
{
Global.CalendarMgr.SendCalendarCommandResult(guid, CalendarError.Internal);
return;
}
SetCalendarEventCreationCooldown(GameTime.GetGameTime() + SharedConst.CalendarCreateEventCooldown);
CalendarEvent newEvent = new(oldEvent, Global.CalendarMgr.GetFreeEventId());
newEvent.Date = calendarCopyEvent.Date;
Global.CalendarMgr.AddEvent(newEvent, CalendarSendEventType.Copy);
var invites = Global.CalendarMgr.GetEventInvites(calendarCopyEvent.EventID);
SQLTransaction trans = null;
if (invites.Count > 1)
{
trans = new SQLTransaction();
}
foreach (var invite in invites)
{
Global.CalendarMgr.AddInvite(newEvent, new CalendarInvite(invite, Global.CalendarMgr.GetFreeInviteId(), newEvent.EventId), trans);
}
if (invites.Count > 1)
{
DB.Characters.CommitTransaction(trans);
}
// should we change owner when somebody makes a copy of event owned by another person?
}
else
{
Global.CalendarMgr.SendCalendarCommandResult(guid, CalendarError.EventInvalid);
}
}
void HandleCalendarAddEvent(CalendarAddEvent calendarAddEvent)
{
ObjectGuid guid = GetPlayer().GetGUID();
// prevent events in the past
// To Do: properly handle timezones and remove the "- time_t(86400L)" hack
if (calendarAddEvent.EventInfo.Time < (GameTime.GetGameTime() - 86400L))
{
Global.CalendarMgr.SendCalendarCommandResult(guid, CalendarError.EventPassed);
return;
}
// If the event is a guild event, check if the player is in a guild
if (CalendarEvent.IsGuildEvent(calendarAddEvent.EventInfo.Flags) || CalendarEvent.IsGuildAnnouncement(calendarAddEvent.EventInfo.Flags))
{
if (_player.GetGuildId() == 0)
{
Global.CalendarMgr.SendCalendarCommandResult(guid, CalendarError.GuildPlayerNotInGuild);
return;
}
}
// Check if the player reached the max number of events allowed to create
if (CalendarEvent.IsGuildEvent(calendarAddEvent.EventInfo.Flags) || CalendarEvent.IsGuildAnnouncement(calendarAddEvent.EventInfo.Flags))
{
if (Global.CalendarMgr.GetGuildEvents(_player.GetGuildId()).Count >= SharedConst.CalendarMaxGuildEvents)
{
Global.CalendarMgr.SendCalendarCommandResult(guid, CalendarError.GuildEventsExceeded);
return;
}
}
else
{
if (Global.CalendarMgr.GetEventsCreatedBy(guid).Count >= SharedConst.CalendarMaxEvents)
{
Global.CalendarMgr.SendCalendarCommandResult(guid, CalendarError.EventsExceeded);
return;
}
}
if (GetCalendarEventCreationCooldown() > GameTime.GetGameTime())
{
Global.CalendarMgr.SendCalendarCommandResult(guid, CalendarError.Internal);
return;
}
SetCalendarEventCreationCooldown(GameTime.GetGameTime() + SharedConst.CalendarCreateEventCooldown);
CalendarEvent calendarEvent = new(Global.CalendarMgr.GetFreeEventId(), guid, 0, (CalendarEventType)calendarAddEvent.EventInfo.EventType, calendarAddEvent.EventInfo.TextureID,
calendarAddEvent.EventInfo.Time, (CalendarFlags)calendarAddEvent.EventInfo.Flags, calendarAddEvent.EventInfo.Title, calendarAddEvent.EventInfo.Description, 0);
if (calendarEvent.IsGuildEvent() || calendarEvent.IsGuildAnnouncement())
{
calendarEvent.GuildId = _player.GetGuildId();
}
if (calendarEvent.IsGuildAnnouncement())
{
CalendarInvite invite = new(0, calendarEvent.EventId, ObjectGuid.Empty, guid, SharedConst.CalendarDefaultResponseTime, CalendarInviteStatus.NotSignedUp, CalendarModerationRank.Player, "");
// WARNING: By passing pointer to a local variable, the underlying method(s) must NOT perform any kind
// of storage of the pointer as it will lead to memory corruption
Global.CalendarMgr.AddInvite(calendarEvent, invite);
}
else
{
SQLTransaction trans = null;
if (calendarAddEvent.EventInfo.Invites.Length > 1)
{
trans = new SQLTransaction();
}
for (int i = 0; i < calendarAddEvent.EventInfo.Invites.Length; ++i)
{
CalendarInvite invite = new(Global.CalendarMgr.GetFreeInviteId(), calendarEvent.EventId,
calendarAddEvent.EventInfo.Invites[i].Guid, guid, SharedConst.CalendarDefaultResponseTime, (CalendarInviteStatus)calendarAddEvent.EventInfo.Invites[i].Status,
(CalendarModerationRank)calendarAddEvent.EventInfo.Invites[i].Moderator, "");
Global.CalendarMgr.AddInvite(calendarEvent, invite, trans);
}
if (calendarAddEvent.EventInfo.Invites.Length > 1)
{
DB.Characters.CommitTransaction(trans);
}
}
Global.CalendarMgr.AddEvent(calendarEvent, CalendarSendEventType.Add);
}
