public virtual async void OnMessageUpdate(IGatewayClient gatewayClient, Message message)
{
Channel guildChannel = await Channels.Find(message.ChannelId);
Message messageOld = null;
if (guildChannel is TextChannel textChannel)
{
messageOld = await textChannel.Messages.Find(message.Id);
textChannel.UpdateMessage(ref message);
message.Channel = textChannel;
}
else
{
Logger.Log(LoggingLevel.Warning, $"Fail cache message {message.Id}");
}
MessageUpdate?.Invoke(this, new ClientArgs <MessageUpdate>
{
GatewayClient = gatewayClient,
Data = new MessageUpdate
{
Message = message,
OldMessage = messageOld
}
});
}
void openMessage(MainData.FriendBody friend)
{
GameObject result = transform.FindChild("list").FindChild("result").gameObject;
if (result.activeSelf)
{
backFromSearchReult();
}
backEvent = new EventDelegate(backFromMessage);
transform.FindChild("title").FindChild("label").GetComponent <UILabel>().text = "和" + friend.fName + "的聊天";
messageListContainer.parent.parent.parent.gameObject.SetActive(false);
messageDetailContainer.parent.parent.gameObject.SetActive(true);
MessageUpdate messageUpdate = messageDetailContainer.GetComponent <MessageUpdate>();
messageUpdate.friend = friend;
messageUpdate.count = 0;
//聊天内容显示
refreshMessage(friend);
Transform inputers = messageDetailContainer.parent.parent.FindChild("inputers");
//发送文字逻辑
UIButton send_button = inputers.FindChild("send").GetComponent <UIButton>();
EventDelegate send_event = new EventDelegate(this, "sendStringMessage");
send_event.parameters[0] = new EventDelegate.Parameter();
send_event.parameters[0].obj = friend;
send_button.onClick.Clear();
send_button.onClick.Add(send_event);
//发送图片逻辑
send_button = inputers.FindChild("add-pic").GetComponent <UIButton>();
send_event = new EventDelegate(this, "openPhotogapher");
send_event.parameters[0] = new EventDelegate.Parameter();
send_event.parameters[0].obj = friend;
send_button.onClick.Clear();
send_button.onClick.Add(send_event);
}
public void sendMove(int checker, int[] pos)
{
var msg = new MessageUpdate();
msg.checkerMoved = checker;
msg.winCondition = 0;
msg.movedTo = pos;
manager.client.Send(MyMsgType.Move, msg);
Debug.Log("sent");
}
public bool MessageUpdate(MessageUpdate messageUpdate)
{
var entity = _ctx.Messages.Single(m => m.MessageId == messageUpdate.MessageId);
entity.MessageId = messageUpdate.MessageId;
entity.Content = messageUpdate.Content;
entity.IsRead = messageUpdate.IsRead;
entity.ModifiedDate = DateTimeOffset.UtcNow;
return(_ctx.SaveChanges() == 1);
}
private void ModifyElementFromCode(MessageUpdate msg, Configurations config)
{
InitializeSaveChanges(msg, config, out TestALMethod testALMethod, out int scenarioLine, out int elementLine, false, out List <string> fileContent, out ScenarioElementType scenarioElementType, out string oldProcedureNameOfElement, out string newProcedureNameOfElement);
if (scenarioLine == 0 || elementLine == 0)
{
return;
}
fileContent.RemoveAt(elementLine);
Library.Helpers.ALTestMethodHelper.AddElement(ref fileContent, msg.NewValue, scenarioElementType, ref elementLine);
Library.Helpers.ALTestCodeunitHelper.RenameOrOnlyAddNewProcedure(oldProcedureNameOfElement, newProcedureNameOfElement, ref fileContent, ref elementLine, config.addException);
WriteFile(msg.FsPath, fileContent);
}
private void InitializeSaveChanges(MessageUpdate msg, Configurations config, out TestALMethod testALMethod, out int scenarioLine, out int elementLine, bool elementOfNewValue, out List <string> fileContent, out ScenarioElementType scenarioElementType, out string oldProcedureNameOfElement, out string newProcedureNameOfElement)
{
string scenarioName = msg.Scenario;
string fsPath = msg.FsPath;
string elementOldValue = msg.OldValue;
string elementNewValue = msg.NewValue;
TypeChanged typeChanged = msg.Type;
ALTestCodeunitReader alTestCodeunitReader = new ALTestCodeunitReader();
TestALCodeunit testCodeunit = (TestALCodeunit)alTestCodeunitReader.ReadSingle(fsPath);
testALMethod = testCodeunit.Methods.First(m => (m.Scenario != null) && (m.Scenario.Name == scenarioName));
scenarioElementType = Library.ALMethodHelper.ToEnum <ScenarioElementType>(typeChanged.ToString().ToUpper());
if (elementOldValue == null)
{
oldProcedureNameOfElement = "";
}
else
{
oldProcedureNameOfElement = Library.ALMethodHelper.GetProcedurename(scenarioElementType, elementOldValue, config.prefixGiven, config.prefixWhen, config.prefixThen);
}
if (elementNewValue == null)
{
newProcedureNameOfElement = "";
}
else
{
newProcedureNameOfElement = Library.ALMethodHelper.GetProcedurename(scenarioElementType, elementNewValue, config.prefixGiven, config.prefixWhen, config.prefixThen);
}
fileContent = File.ReadAllLines(fsPath).ToList();
elementLine = 0;
scenarioLine = Library.Helpers.ALTestCodeunitHelper.FindScenarioLine(testALMethod.Scenario.Name, fileContent);
if (scenarioLine == 0)
{
return;
}
if (elementOfNewValue)
{
elementLine = Library.Helpers.ALTestCodeunitHelper.FindElementLine(fileContent, scenarioElementType, elementNewValue, scenarioLine);
}
else
{
elementLine = Library.Helpers.ALTestCodeunitHelper.FindElementLine(fileContent, scenarioElementType, elementOldValue, scenarioLine);
}
if (elementLine == 0)
{
return;
}
}
// api/Message/Update
public IHttpActionResult Put(MessageUpdate message)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (!_messageService.MessageUpdate(message))
{
return(InternalServerError());
}
return(Ok());
}
public void SaveChanges(MessageUpdate msg, Configurations config)
{
if (msg.State == MessageState.New)
{
AddNewElementToCode(msg, config);
}
else if (msg.State == MessageState.Deleted)
{
DeleteElementFromCode(msg, config);
}
else if (msg.State == MessageState.Modified)
{
ModifyElementFromCode(msg, config);
}
}
private void DeleteElementFromCode(MessageUpdate msg, Configurations config)
{
InitializeSaveChanges(msg, config, out TestALMethod testALMethod, out int scenarioLine, out int elementLine, true, out List <string> fileContent, out ScenarioElementType scenarioElementType, out string dummyProcedureNameOfElement, out string procedureNameOfElement);
if (scenarioLine == 0 || elementLine == 0)
{
return;
}
Library.Helpers.ALTestMethodHelper.DeleteElementWithProcedureCall(ref fileContent, procedureNameOfElement, elementLine);
if (msg.DeleteProcedure)
{
Library.Helpers.ALTestCodeunitHelper.DeleteProcedure(ref fileContent, procedureNameOfElement);
}
WriteFile(msg.FsPath, fileContent);
}
public bool checkSaveChanges(MessageUpdate msg, Configurations config)
{
bool procedureCanBeRemovedAfterwards = false;
if (msg.State == MessageState.Deleted)
{
ScenarioElementType scenarioElementType = Library.ALMethodHelper.ToEnum <ScenarioElementType>(msg.Type.ToString().ToUpper());
string procedureNameOfElement = Library.ALMethodHelper.GetProcedurename(scenarioElementType, msg.NewValue, config.prefixGiven, config.prefixWhen, config.prefixThen);
List <string> fileContent = File.ReadAllLines(msg.FsPath).ToList();
Range? range = Library.Helpers.ALTestCodeunitHelper.FindProcedureDeclarationRange(fileContent, procedureNameOfElement);
if (range.HasValue)
{
int[] usagesOfProcedure = Library.Helpers.ALTestCodeunitHelper.FindLinesWhereProcedureIsCalled(fileContent, procedureNameOfElement);
procedureCanBeRemovedAfterwards = usagesOfProcedure.Length <= 1;
}
}
return(procedureCanBeRemovedAfterwards);
}
private void updateBranch_Click(object sender, EventArgs e)
{
Int32 selectedRowCount = dataGridView1.Rows.GetRowCount(DataGridViewElementStates.Selected);
if (selectedRowCount > 0)
{
//int lignes = 0;
for (int i = 0; i < selectedRowCount; i++)
{
int id = Int32.Parse(dataGridView1.SelectedRows[i].Cells["Id_Filière"].Value.ToString());
string branchNameTable = dataGridView1.SelectedRows[i].Cells["Nom_Filière"].Value.ToString();
try
{
MessageUpdate msg = new MessageUpdate();
msg.UpdateNamebranch.Text = branchNameTable;
msg.ShowDialog();
Request request = new Request(RequestType.UpdateBranch, new Branch(id, msg.UpdateNamebranch.Text));
byte[] buffer = SerializeDeserializeObject.Serialize(request);
socket.Send(buffer);
buffer = new byte[1024];
int size = socket.Receive(buffer);
Array.Resize(ref buffer, size);
bool answer = (bool)SerializeDeserializeObject.Deserialize(buffer);
if (answer)
{
new MessageBx("La modification a réussi", "Modification").ShowDialog();
actualiserLeTableau();
}
else
{
new MessageBx("Nous avons rencontré un problème!\nRéessayer plus tard.", "Problème de serveur").ShowDialog();
}
}
catch (Exception)
{
new MessageBx("Nous avons rencontré un problème!\nRéessayer plus tard.", "Problème de serveur").ShowDialog();
}
}
}
else
{
new MessageBx("Veuillez sélectionner une ligne", "Attention").ShowDialog();
}
}
private void AddNewElementToCode(MessageUpdate msg, Configurations config)
{
string scenarioName = msg.Scenario;
TypeChanged typeChanged = msg.Type;
string fsPath = msg.FsPath;
string elementValue = msg.NewValue;
if (typeChanged == TypeChanged.Feature)
{
List <string> fileContent = new List <string>();
fileContent.AddRange(Library.Helpers.ALTestCodeunitHelper.GetDefaultTestCodeunitText(elementValue));
WriteFile(fsPath, fileContent);
}
else
{
InitializeSaveChanges(msg, config, out TestALMethod testALMethod, out int scenarioLine, out int elementLine, false, out List <string> fileContent, out ScenarioElementType scenarioElementType, out string dummyProcedureNameOfElement, out string procedureNameToCall);
if (scenarioLine == 0)
{
return;
}
int lineToInsert = Library.ALMethodHelper.FindLineToInsertElement(testALMethod, fileContent, scenarioLine, scenarioElementType);
if (lineToInsert == 0)
{
return;
}
bool addLineBreak = testALMethod.Scenario.Elements.Where(e => e.Type == scenarioElementType).Count() == 0;
Library.Helpers.ALTestMethodHelper.AddElement(ref fileContent, elementValue, scenarioElementType, ref lineToInsert);
Library.Helpers.ALTestMethodHelper.AddProcedureCall(ref fileContent, procedureNameToCall, ref lineToInsert);
Library.Helpers.ALTestCodeunitHelper.AddProcedure(ref fileContent, procedureNameToCall, config.addException);
WriteFile(fsPath, fileContent);
}
}
public override void MessageUpdated(TwilioChatClient client, Channel channel, Message message, MessageUpdate updated)
{
Logger.Info($"ChatClient: {client}", $"Channel: {channel.Sid} MessageUpdated: {message.Sid}, reason: {updated}");
}
public override void MessageUpdated(TwilioChatClient client, Channel channel, Message message, MessageUpdate updated)
{
Logger.Info($"ChatClient: {client}", $"Channel: {channel.Sid} MessageUpdated: {message.Sid}, reason: {updated}");
if (updated == MessageUpdate.Attributes)
{
Logger.Info($"ChatClient: {client}", $"Message attributes: {message.Attributes.ToDebugLog()}");
}
}
Task <MessageUpdateResponse> IChatApi.Update(MessageUpdate messageUpdate, CancellationToken?cancellationToken)
{
throw new NotImplementedException();
}
public async Task CheckSaveChanges(MessageUpdate msg, Configurations config)
{
bool procedureCanBeRemovedAfterwards = objectService.checkSaveChanges(msg, config);
await Clients.All.CheckSaveChangesResponse(procedureCanBeRemovedAfterwards);
}
public async Task SaveChanges(MessageUpdate msg, Configurations config)
{
objectService.SaveChanges(msg, config);
await Clients.All.SaveChangesResponse(true);
}
private void HandleDispatchEvent(GatewayPayload evnt, TaskCompletionSource <bool> readySignal)
{
switch (evnt.DispatchType)
{
case GatewayDispatchType.Ready:
var readyEvent = evnt.Data as ReadyEvent;
SetSession(readyEvent.SessionId);
readySignal.TrySetResult(true);
Ready?.Invoke(readyEvent);
break;
case GatewayDispatchType.Resumed:
readySignal.TrySetResult(true);
Resumed?.Invoke();
break;
case GatewayDispatchType.GuildCreate: GuildCreate?.Invoke(evnt.Data as GatewayGuild); break;
case GatewayDispatchType.GuildUpdate: GuildUpdate?.Invoke(evnt.Data as Guild); break;
case GatewayDispatchType.GuildDelete: GuildDelete?.Invoke(evnt.Data as UnavailableGuild); break;
case GatewayDispatchType.ChannelCreate: ChannelCreate?.Invoke(evnt.Data as Channel); break;
case GatewayDispatchType.ChannelUpdate: ChannelUpdate?.Invoke(evnt.Data as Channel); break;
case GatewayDispatchType.ChannelDelete: ChannelDelete?.Invoke(evnt.Data as Channel); break;
case GatewayDispatchType.ChannelPinsUpdate: ChannelPinsUpdate?.Invoke(evnt.Data as ChannelPinsUpdateEvent); break;
case GatewayDispatchType.GuildMemberAdd: GuildMemberAdd?.Invoke(evnt.Data as GuildMemberAddEvent); break;
case GatewayDispatchType.GuildMemberUpdate: GuildMemberUpdate?.Invoke(evnt.Data as GuildMemberUpdateEvent); break;
case GatewayDispatchType.GuildMemberRemove: GuildMemberRemove?.Invoke(evnt.Data as GuildMemberRemoveEvent); break;
case GatewayDispatchType.GuildMembersChunk: GuildMembersChunk?.Invoke(evnt.Data as GuildMembersChunkEvent); break;
case GatewayDispatchType.GuildRoleCreate: GuildRoleCreate?.Invoke(evnt.Data as GuildRoleCreateEvent); break;
case GatewayDispatchType.GuildRoleUpdate: GuildRoleUpdate?.Invoke(evnt.Data as GuildRoleUpdateEvent); break;
case GatewayDispatchType.GuildRoleDelete: GuildRoleDelete?.Invoke(evnt.Data as GuildRoleDeleteEvent); break;
case GatewayDispatchType.GuildBanAdd: GuildBanAdd?.Invoke(evnt.Data as GuildBanAddEvent); break;
case GatewayDispatchType.GuildBanRemove: GuildBanRemove?.Invoke(evnt.Data as GuildBanRemoveEvent); break;
case GatewayDispatchType.GuildEmojisUpdate: GuildEmojisUpdate?.Invoke(evnt.Data as GuildEmojiUpdateEvent); break;
case GatewayDispatchType.GuildIntegrationsUpdate: GuildIntegrationsUpdate?.Invoke(evnt.Data as GuildIntegrationsUpdateEvent); break;
case GatewayDispatchType.MessageCreate: MessageCreate?.Invoke(evnt.Data as Message); break;
case GatewayDispatchType.MessageUpdate: MessageUpdate?.Invoke(evnt.Data as Message); break;
case GatewayDispatchType.MessageDelete: MessageDelete?.Invoke(evnt.Data as MessageDeleteEvent); break;
case GatewayDispatchType.MessageDeleteBulk: MessageDeleteBulk?.Invoke(evnt.Data as MessageDeleteBulkEvent); break;
case GatewayDispatchType.MessageReactionAdd: MessageReactionAdd?.Invoke(evnt.Data as MessageReactionAddEvent); break;
case GatewayDispatchType.MessageReactionRemove: MessageReactionRemove?.Invoke(evnt.Data as MessageReactionRemoveEvent); break;
case GatewayDispatchType.MessageReactionRemoveAll: MessageReactionRemoveAll?.Invoke(evnt.Data as MessageReactionRemoveAllEvent); break;
case GatewayDispatchType.PresenceUpdate: PresenceUpdate?.Invoke(evnt.Data as Presence); break;
case GatewayDispatchType.UserUpdate: UserUpdate?.Invoke(evnt.Data as User); break;
case GatewayDispatchType.TypingStart: TypingStart?.Invoke(evnt.Data as TypingStartEvent); break;
case GatewayDispatchType.VoiceStateUpdate: VoiceStateUpdate?.Invoke(evnt.Data as VoiceState); break;
case GatewayDispatchType.VoiceServerUpdate: VoiceServerUpdate?.Invoke(evnt.Data as VoiceServerUpdateEvent); break;
case GatewayDispatchType.WebhooksUpdate: WebhooksUpdate?.Invoke(evnt.Data as WebhooksUpdateEvent); break;
}
}
//TODO: Typing Start
//TODO: Integrations
//TODO: User Updates
//TODO: Voice Chat
private void GatewayMessageHandler(string eventName, string payload)
{
_Logger?.Debug($"{eventName} - {payload}");
var eventValue = (Events)Enum.Parse(typeof(Events), eventName);
var eventPayload = JObject.Parse(payload);
switch (eventValue)
{
case Events.READY:
{
var guilds = eventPayload["guilds"] as JArray;
foreach (var guild in guilds)
{
var g = new Guild {
Id = guild["id"].ToString(), Unavailable = guild["unavailable"].ToObject <bool>()
};
Guilds.Add(g.Id, g);
}
break;
}
case Events.GUILD_CREATE:
{
Guild g = null;
if (Guilds.ContainsKey(eventPayload["id"].ToString()))
{
g = Guilds[eventPayload["id"].ToString()];
}
else
{
g = new Guild()
{
Id = eventPayload["id"].ToString()
};
Guilds.Add(g.Id, g);
}
JsonConvert.PopulateObject(payload, g);
foreach (var channel in g.Channels)
{
if (!Channels.ContainsKey(channel.Key))
{
Channels.Add(channel.Key, channel.Value);
}
channel.Value.Guild_Id = g.Id;
channel.Value.Guild = g;
}
foreach (var member in g.Members)
{
if (!Users.ContainsKey(member.Key))
{
Users.Add(member.Key, member.Value.User);
}
else if (member.Value.User != Users[member.Key])
{
member.Value.User = Users[member.Key];
}
member.Value.Guild = g;
}
foreach (var presence in g.Presences.Values)
{
presence.User = Users[presence.User.Id];
}
g.UpdateAllUserPermissions();
GuildCreated?.Invoke(g);
break;
}
case Events.GUILD_UPDATE:
{
var g = Guilds[eventPayload["id"].ToString()];
// TODO: Double check that this is the correct behavior.
JsonConvert.PopulateObject(payload, g);
GuildUpdated?.Invoke(g);
break;
}
case Events.GUILD_DELETE:
{
var g = Guilds[eventPayload["id"].ToString()];
Guilds.Remove(eventPayload["id"].ToString());
GuildDeleted?.Invoke(g);
break;
}
case Events.CHANNEL_CREATE:
{
var c = eventPayload.ToObject <GuildChannel>();
var g = Guilds[c.Guild_Id];
c.Guild = g;
g.Channels.Add(c.Id, c);
Channels.Add(c.Id, c);
ChannelCreate?.Invoke(g, c);
break;
}
case Events.CHANNEL_UPDATE:
{
var g = Guilds[eventPayload["guild_id"].ToString()];
var c = g.Channels[eventPayload["id"].ToString()];
JsonConvert.PopulateObject(payload, c);
ChannelUpdate?.Invoke(g, c);
break;
}
case Events.CHANNEL_DELETE:
{
var g = Guilds[eventPayload["guild_id"].ToString()];
var c = g.Channels[eventPayload["id"].ToString()];
g.Channels.Remove(c.Id);
Channels.Remove(c.Id);
ChannelDelete?.Invoke(g, c);
break;
}
case Events.GUILD_BAN_ADD:
{
// TODO: User knows about bans
var g = Guilds[eventPayload["guild_id"].ToString()];
var m = g.Members[eventPayload["id"].ToString()];
Users[m.User.Id].Guilds.Remove(g);
g.Members.Remove(m.User.Id);
BanAdd?.Invoke(g, m.User);
break;
}
case Events.GUILD_BAN_REMOVE:
{
var g = Guilds[eventPayload["guild_id"].ToString()];
BanRemove?.Invoke(g, eventPayload.ToObject <DiscordUser>());
break;
}
case Events.GUILD_EMOJIS_UPDATE:
{
var g = Guilds[eventPayload["guild_id"].ToString()];
g.Emojis.Clear();
JsonConvert.PopulateObject(payload, g);
EmojiUpdate?.Invoke(g, eventPayload["emojis"].ToObject <List <Guild.Emoji> >());
break;
}
case Events.GUILD_MEMBER_ADD:
{
var g = Guilds[eventPayload["guild_id"].ToString()];
var m = eventPayload.ToObject <GuildMember>();
if (!Users.ContainsKey(m.User.Id))
{
Users.Add(m.User.Id, m.User);
}
else
{
m.User = Users[m.User.Id];
}
g.Members.Add(m.User.Id, m);
m.User.Guilds.Add(g);
m.Guild = g;
g.UpdateUserPermission(m);
MemberAdd?.Invoke(g, m);
break;
}
case Events.GUILD_MEMBER_REMOVE:
{
var g = Guilds[eventPayload["guild_id"].ToString()];
var m = g.Members[eventPayload["user"]["id"].ToString()];
g.Members.Remove(m.User.Id);
m.User.Guilds.Remove(g);
MemberRemove?.Invoke(g, m);
break;
}
case Events.GUILD_MEMBER_UPDATE:
{
var g = Guilds[eventPayload["guild_id"].ToString()];
var m = g.Members[eventPayload["user"]["id"].ToString()];
JsonConvert.PopulateObject(payload, m);
g.UpdateUserPermission(m);
MemberUpdate?.Invoke(g, m);
break;
}
case Events.GUILD_MEMBERS_CHUNK:
{
var g = Guilds[eventPayload["guild_id"].ToString()];
var members = eventPayload["members"].ToObject <List <GuildMember> >();
foreach (var member in members)
{
if (Users.ContainsKey(member.User.Id))
{
member.User = Users[member.User.Id];
}
else
{
Users.Add(member.User.Id, member.User);
}
g.Members.Remove(member.User.Id);
g.Members.Add(member.User.Id, member);
}
MemberChunkUpdate?.Invoke(g, members);
break;
}
case Events.GUILD_ROLE_CREATE:
{
var g = Guilds[eventPayload["guild_id"].ToString()];
var r = eventPayload["role"].ToObject <Guild.Role>();
g.Roles.Add(r.Id, r);
RoleCreate?.Invoke(g, r);
break;
}
case Events.GUILD_ROLE_UPDATE:
{
var g = Guilds[eventPayload["guild_id"].ToString()];
var r = g.Roles[eventPayload["role"]["id"].ToString()];
JsonConvert.PopulateObject(eventPayload["role"].ToString(), r);
RoleUpdate?.Invoke(g, r);
break;
}
case Events.GUILD_ROLE_DELETE:
{
var g = Guilds[eventPayload["guild_id"].ToString()];
var r = g.Roles[eventPayload["role_id"].ToString()];
g.Roles.Remove(r.Id);
RoleDelete?.Invoke(g, r);
break;
}
case Events.MESSAGE_CREATE:
{
var message = eventPayload.ToObject <Message>();
var c = Channels[message.Channel_Id];
message.Channel = c;
if (string.IsNullOrEmpty(message.Webhook_Id))
{
if (Users.ContainsKey(message.Author.Id))
{
message.Author = Users[message.Author.Id];
}
}
MessageCreate?.Invoke(c, message);
break;
}
case Events.MESSAGE_UPDATE:
{
var message = eventPayload.ToObject <Message>();
var c = Channels[message.Channel_Id];
MessageUpdate?.Invoke(c, message);
break;
}
case Events.MESSAGE_DELETE:
{
var message = eventPayload.ToObject <Message>();
var c = Channels[message.Channel_Id];
MessageDelete?.Invoke(c, message);
break;
}
case Events.MESSAGE_DELETE_BULK:
{
var messages = eventPayload.ToObject <List <Message> >();
var c = Channels[eventPayload["channel_id"].ToString()];
MessagesBulkDelete?.Invoke(c, messages);
break;
}
case Events.PRESENCE_UPDATE:
{
var presense = eventPayload.ToObject <Guild.Presence>();
var g = Guilds[eventPayload["guild_id"].ToString()];
if (g.Presences.ContainsKey(presense.User.Id))
{
var p = g.Presences[presense.User.Id];
p.Game = presense.Game;
p.Status = presense.Status;
presense = p;
}
else
{
presense.User = Users[presense.User.Id];
g.Presences.Add(presense.User.Id, presense);
}
PresenceUpdate?.Invoke(g, presense);
break;
}
}
}
protected internal override void RaiseMessageUpdate(IClientInfo client, string msg, string header, MessageType msgType, MessageState state)
{
MessageUpdate?.Invoke(client, msg, header, msgType, state);
}
protected virtual void OnMessageReceived(string message)
{
MessageUpdate?.Invoke(this, new MessageEventArgs(message));
}
