public override ValueTask <ReactionAddedEventArgs> HandleDispatchAsync(IGatewayApiClient shard, MessageReactionAddJsonModel model)
{
CachedUserMessage message;
IMember member = null;
if (CacheProvider.TryGetMessages(model.ChannelId, out var messageCache))
{
message = messageCache.GetValueOrDefault(model.MessageId);
message?.Update(model);
}
else
{
message = null;
}
if (model.GuildId.HasValue)
{
member = Dispatcher.GetOrAddMember(model.GuildId.Value, model.Member.Value);
if (member == null)
{
member = new TransientMember(Client, model.GuildId.Value, model.Member.Value);
}
}
var e = new ReactionAddedEventArgs(model.UserId, model.ChannelId, model.MessageId, message, model.GuildId.GetValueOrNullable(), member, Emoji.Create(model.Emoji));
return(new(e));
}
// TODO
// {A48C75B3-07B4-4D84-8803-250D6406695D}
// this is a bit weird
// it is get or create
// but like if something as already made a hopeful member it will just throw
// that is probably a bug
// x.y := 5
// 5 > x
// boom, probably
public TransientMember GetReturns(IValue value)
{
if (value.Hopeful is IIsDefinately <InferredType> inferredType)
{
return(inferredType.Value.Returns.GetOrThrow());
}
else
{
var inferredMethodType = new InferredType(this, "generated infered method type");
value.Hopeful = Possibly.Is(inferredMethodType);
// shared code {A9E37392-760B-427D-852E-8829EEFCAE99}
// we don't use has member input/output doesn't go in the member list
// it is not a public member
// and infered to do not have private members
var methodInputKey = new NameKey("generated infered method input - " + Guid.NewGuid());
var inputMember = new Member(this, methodInputKey.ToString() !);
inputMember.LooksUp = Possibly.Is(Prototypist.Toolbox.OrType.Make <MethodType, Type, Object, OrType, InferredType, GenericTypeParameter, IError>(new InferredType(this, "implicit input")));
inferredMethodType.Input = Possibly.Is(inputMember);
var returnMember = new TransientMember(this, "generated infered method return -" + Guid.NewGuid());
returnMember.LooksUp = Possibly.Is(Prototypist.Toolbox.OrType.Make <MethodType, Type, Object, OrType, InferredType, GenericTypeParameter, IError>(new InferredType(this, "implicit return")));
inferredMethodType.Returns = Possibly.Is(returnMember);
return(returnMember);
}
}
public TransientMember CreateTransientMember(IScope parent, string debugName)
{
var res = new TransientMember(this, debugName);
HasTransientMember(parent, res);
res.Context = Possibly.Is(parent);
return(res);
}
public TransientMember CreateTransientMember(IScope parent, IKey typeKey, string debugName)
{
var res = new TransientMember(this, debugName);
HasTransientMember(parent, res);
res.Context = Possibly.Is(parent);
res.TypeKey = Prototypist.Toolbox.OrType.Make <IKey, IError, Unset>(typeKey);
return(res);
}
public override ValueTask <VoiceStateUpdatedEventArgs> HandleDispatchAsync(IGatewayApiClient shard, VoiceStateJsonModel model)
{
if (!model.GuildId.HasValue)
{
return(new(result : null));
}
CachedVoiceState oldVoiceState = null;
IVoiceState newVoiceState = null;
if (CacheProvider.TryGetVoiceStates(model.GuildId.Value, out var cache))
{
if (model.ChannelId != null)
{
if (cache.TryGetValue(model.UserId, out var voiceState))
{
newVoiceState = voiceState;
oldVoiceState = voiceState.Clone() as CachedVoiceState;
newVoiceState.Update(model);
}
else
{
newVoiceState = new CachedVoiceState(Client, model.GuildId.Value, model);
cache.Add(model.UserId, newVoiceState as CachedVoiceState);
}
}
else
{
cache.TryRemove(model.UserId, out oldVoiceState);
}
}
newVoiceState ??= new TransientVoiceState(Client, model);
IMember member = Dispatcher.GetOrAddMember(model.GuildId.Value, model.Member.Value);
if (member == null)
{
member = new TransientMember(Client, model.GuildId.Value, model.Member.Value);
}
var e = new VoiceStateUpdatedEventArgs(member, oldVoiceState, newVoiceState);
return(new(e));
}
public ValueTask HandleChunkAsync(GuildMembersChunkJsonModel model)
{
var members = new List <IMember>();
if (model.Members.Length != 0)
{
if (Client.CacheProvider.TryGetUsers(out var userCache) && Client.CacheProvider.TryGetMembers(model.GuildId, out var memberCache))
{
foreach (var memberModel in model.Members)
{
var member = Client.Dispatcher.GetOrAddMemberTransient(userCache, memberCache, model.GuildId, memberModel);
members.Add(member);
}
}
else
{
foreach (var memberModel in model.Members)
{
var member = new TransientMember(Client, model.GuildId, memberModel);
members.Add(member);
}
}
}
public override ValueTask <MemberUpdatedEventArgs> HandleDispatchAsync(IGatewayApiClient shard, GuildMemberUpdateJsonModel model)
{
CachedMember oldMember;
IMember newMember;
if (CacheProvider.TryGetMembers(model.GuildId, out var cache) && cache.TryGetValue(model.User.Value.Id, out var member))
{
newMember = member;
var oldUser = member.SharedUser.Clone() as CachedSharedUser;
oldMember = member.Clone() as CachedMember;
oldMember.SharedUser = oldUser;
newMember.Update(model);
}
else
{
oldMember = null;
newMember = new TransientMember(Client, model.GuildId, model);
}
var e = new MemberUpdatedEventArgs(oldMember, newMember);
return(new(e));
}
public void Update(MessageUpdateJsonModel model)
{
if (model.Author.HasValue)
{
if (_transientAuthor != null)
{
if (model.Member.HasValue)
{
model.Member.Value.User = model.Author;
_transientAuthor = new TransientMember(Client, GuildId.Value, model.Member.Value);
}
else
{
_transientAuthor = new TransientUser(Client, model.Author.Value);
}
}
}
if (model.Content.HasValue)
{
Content = model.Content.Value;
}
if (model.Mentions.HasValue)
{
MentionedUsers = model.Mentions.Value.ToReadOnlyList(Client, (x, client) =>
{
var user = client.GetUser(x.Id);
if (user != null)
{
return(user);
}
return(new TransientUser(client, x) as IUser);
});
}
if (model.Reactions.HasValue)
{
Reactions = Optional.Convert(model.Reactions, x => x.ToReadOnlyDictionary(x => Emoji.Create(x.Emoji), x => new MessageReaction(x)));
}
if (model.EditedTimestamp.HasValue)
{
EditedAt = model.EditedTimestamp.Value;
}
if (model.Pinned.HasValue)
{
IsPinned = model.Pinned.Value;
}
if (model.MentionEveryone.HasValue)
{
MentionsEveryone = model.MentionEveryone.Value;
}
if (model.MentionRoles.HasValue)
{
MentionedRoleIds = model.MentionRoles.Value.ReadOnly();
}
if (model.Attachments.HasValue)
{
Attachments = model.Attachments.Value.ToReadOnlyList(x => new Attachment(x));
}
if (model.Embeds.HasValue)
{
Embeds = model.Embeds.Value.ToReadOnlyList(x => new Embed(x));
}
if (model.Activity.HasValue)
{
Activity = Optional.ConvertOrDefault(model.Activity, x => new MessageActivity(x));
}
if (model.Application.HasValue)
{
Application = Optional.ConvertOrDefault(model.Application, x => new MessageApplication(x));
}
if (model.MessageReference.HasValue)
{
Reference = Optional.ConvertOrDefault(model.MessageReference, x => new MessageReference(x));
}
if (model.Flags.HasValue)
{
Flags = model.Flags.Value;
}
if (model.ReferencedMessage.HasValue)
{
ReferencedMessage = Optional.Convert(model.ReferencedMessage, x => new TransientUserMessage(Client, x) as IUserMessage);
}
if (model.Components.HasValue)
{
Components = Optional.ConvertOrDefault(model.Components, (models, client) => models.ToReadOnlyList(client, (model, client) => TransientComponent.Create(client, model)), Client) ?? Array.Empty <IComponent>();
}
if (model.StickerItems.HasValue)
{
Stickers = Optional.ConvertOrDefault(model.StickerItems, x => x.ToReadOnlyList(y => new MessageSticker(y)), Array.Empty <MessageSticker>());
}
}
public static void HasTransientMember(IScope parent, TransientMember member)
{
parent.TransientMembers.Add(member);
}
