Implement new Invite event and new fields in User object.

discord/discord-api-docs#1309
[ci skip]

Author: l7ssha

nyxx/lib/nyxx.dart

@@ -53,6 +53,8 @@ part 'src/events/HttpEvents.dart';
 part 'src/events/ChannelEvents.dart';
 part 'src/events/GuildEvents.dart';
 
+part 'src/events/InviteEvents.dart';
+
 // BUILDERS
 
 part 'src/builders/Builder.dart';
@@ -116,6 +118,8 @@ part 'src/objects/user/Member.dart';
 part 'src/objects/guild/Status.dart';
 part 'src/objects/guild/Role.dart';
 part 'src/objects/user/User.dart';
+part 'src/objects/user/UserFlags.dart';
+part 'src/objects/user/NitroType.dart';
 part 'src/objects/guild/Ban.dart';
 part 'src/objects/guild/GuildEnums.dart';
 

nyxx/lib/src/Nyxx.dart

@@ -175,6 +175,15 @@ class Nyxx implements Disposable {
   /// Emitted when bot is mentioned
   late Stream<MessageReceivedEvent> onSelfMention;
 
+  /// Emitted when invite is created
+  late Stream<InviteCreatedEvent> onInviteCreated;
+
+  /// Emitted when invite is deleted
+  late Stream<InviteDeletedEvent> onInviteDeleted;
+
+  /// Emitted when a bot removes all instances of a given emoji from the reactions of a message
+  late Stream<MessageReactionRemoveEmojiEvent> onMessageReactionRemoveEmoji;
+
   /// Logger instance
   Logger _logger = Logger("Client");
 
@@ -262,9 +271,12 @@ class Nyxx implements Disposable {
   /// var user = client.getClient(Snowflake("302359032612651009"));
   /// ``
   Future<User?> getUser(Snowflake id) async {
-    if (this.users.hasKey(id)) return this.users[id];
+    //if (this.users.hasKey(id)) return this.users[id];
 
     var r = await this._http.send("GET", "/users/${id.toString()}");
+
+    print(r.body);
+
     return User._new(r.body as Map<String, dynamic>, this);
   }
 

nyxx/lib/src/Shard.dart

@@ -377,6 +377,21 @@ class Shard implements Disposable {
                 .add(UserUpdateEvent._new(msg, _ws._client));
             break;
 
+          case 'INVITE_CREATE':
+            _ws._client._events.onInviteCreated
+                .add(InviteCreatedEvent._new(msg, _ws._client));
+            break;
+
+          case 'INVITE_DELETE':
+            _ws._client._events.onInviteDelete
+                .add(InviteDeletedEvent._new(msg, _ws._client));
+            break;
+
+          case 'MESSAGE_REACTION_REMOVE_EMOJI':
+            _ws._client._events.onMessageReactionRemoveEmoji
+                .add(MessageReactionRemoveEmojiEvent._new(msg, _ws._client));
+            break;
+
           default:
             print("UNKNOWN OPCODE: ${jsonEncode(msg)}");
         }

nyxx/lib/src/events/InviteEvents.dart

@@ -0,0 +1,27 @@
+part of nyxx;
+
+/// Emitted when invite is creating
+class InviteCreatedEvent {
+  late final Invite invite;
+  
+  InviteCreatedEvent._new(Map<String, dynamic> json, Nyxx client) {
+    this.invite = Invite._new(json['d'] as Map<String, dynamic>, client);
+  }
+}
+
+/// Emitted when invite is deleted
+class InviteDeletedEvent {
+  Channel? channel;
+  Guild? guild;
+
+  late final String code;
+
+  InviteDeletedEvent._new(Map<String, dynamic> json, Nyxx client) {
+    this.code = json['d']['code'] as String;
+    this.channel = client.channels[Snowflake(json['d']['channel_id'])];
+
+    if(json['d']['guild_id'] != null) {
+      this.guild = client.guilds[Snowflake(json['d']['guild_id'])];
+    }
+  }
+}

nyxx/lib/src/events/MessageEvents.dart

@@ -130,6 +130,33 @@ class MessageReactionsRemovedEvent extends MessageEvent {
   }
 }
 
+class MessageReactionRemoveEmojiEvent extends MessageEvent {
+  /// Channel where reactions are removed
+  late final MessageChannel? channel;
+
+  @override
+
+  /// Message on which messages are removed
+  late final Message? message;
+
+  /// Guild where event occurs
+  late final Guild? guild;
+
+  /// The emoji that was removed
+  late final Emoji? emoji;
+
+  MessageReactionRemoveEmojiEvent._new(Map<String, dynamic> json, Nyxx client) {
+    this.channel = client.channels[Snowflake(json['d']['channel_id'])] as MessageChannel?;
+    this.message = channel?.messages[Snowflake(json['d']['message_id'])];
+
+    if(json['d']['guild_id'] != null) {
+      this.guild = client.guilds[Snowflake(json['d']['guild_id'])];
+
+      this.emoji = this.guild?.emojis[Snowflake(json['d']['emoji']['id'])];
+    }
+  }
+}
+
 /// Emitted when multiple messages are deleted at once.
 class MessageDeleteBulkEvent {
   /// List of deleted messages

nyxx/lib/src/internal/_EventController.dart

@@ -117,6 +117,15 @@ class _EventController implements Disposable {
   /// Emitted on any message related event
   late final StreamController<MessageEvent> onMessage;
 
+  /// Emitted when invite is creating
+  late final StreamController<InviteCreatedEvent> onInviteCreated;
+
+  /// Emitted when invite is deleted
+  late final StreamController<InviteDeletedEvent> onInviteDelete;
+
+  /// Emitted when a bot removes all instances of a given emoji from the reactions of a message
+  late final StreamController<MessageReactionRemoveEmojiEvent> onMessageReactionRemoveEmoji;
+
   /// Makes a new `EventController`.
   _EventController(Nyxx _client) {
     this.onRaw = StreamController.broadcast();
@@ -229,6 +238,15 @@ class _EventController implements Disposable {
 
     this.onMessage = StreamController.broadcast();
     _client.onMessage = this.onMessage.stream;
+
+    this.onInviteCreated = StreamController.broadcast();
+    _client.onInviteCreated = this.onInviteCreated.stream;
+
+    this.onInviteDelete = StreamController.broadcast();
+    _client.onInviteDeleted = this.onInviteDelete.stream;
+
+    this.onMessageReactionRemoveEmoji = StreamController.broadcast();
+    _client.onMessageReactionRemoveEmoji = this.onMessageReactionRemoveEmoji.stream;
   }
 
   @override
@@ -271,6 +289,10 @@ class _EventController implements Disposable {
     this.onMessageReactionsRemoved.close();
     this.onVoiceStateUpdate.close();
     this.onVoiceServerUpdate.close();
+    this.onMessageReactionRemoveEmoji.close();
+
+    this.onInviteCreated.close();
+    this.onInviteDelete.close();
 
     this.onUserUpdate.close();
   }

nyxx/lib/src/objects/Invite.dart

@@ -1,23 +1,23 @@
 part of nyxx;
 
 /// Represents invite to guild.
-class Invite {
+class Invite  {
   /// The invite's code.
   late final String code;
 
   /// A mini guild object for the invite's guild.
   late final Guild? guild;
 
   /// A mini channel object for the invite's channel.
-  late final GuildChannel channel;
+  late final Channel? channel;
 
   /// Returns url invite
   String get url => "https://discord.gg/$code";
 
   /// Date when invite was created
   late final DateTime createdAt;
 
-  /// True if invite is temporary
+  /// Whether this invite only grants temporary membership
   late final bool temporary;
 
   /// Number of uses of this invite
@@ -29,22 +29,64 @@ class Invite {
   /// User who created this invite
   late final User? inviter;
 
+  /// The target user for this invite
+  late final User? targetUser;
+
+  /// Duration (in seconds) after which the invite expires
+  late final int maxAge;
+
+  /// Date when invite will expire
+  DateTime get expiryDate {
+    return this.createdAt.add(Duration(seconds: maxAge));
+  }
+
+  /// True if Invite is valid and can be used
+  bool get isValid {
+    var ageValidity = true;
+    var expiryValidity = true;
+
+    if(this.maxUses > 0) {
+      ageValidity = this.uses <= this.maxUses;
+    }
+
+    if(this.maxAge > 0) {
+      expiryValidity = expiryDate.isAfter(DateTime.now());
+    }
+
+    return ageValidity && expiryValidity;
+  }
+
   /// Reference to bot instance
   Nyxx client;
 
   Invite._new(Map<String, dynamic> raw, this.client) {
     this.code = raw['code'] as String;
-    this.guild = client.guilds[Snowflake(raw['guild']['id'] as String)];
 
-    this.channel = client.channels[Snowflake(raw['channel']['id'] as String)]
-        as GuildChannel;
+    if(raw['guild'] != null) {
+      this.guild = client.guilds[Snowflake(raw['guild']['id'])];
+    }
+
+    if(raw['channel'] != null) {
+      this.channel = client.channels[Snowflake(raw['channel']['id'])];
+    }
+
+    if(raw['channel_id'] != null) {
+      this.channel = client.channels[Snowflake(raw['channel_id'])];
+    }
 
     this.createdAt = DateTime.parse(raw['created_at'] as String);
     this.temporary = raw['temporary'] as bool;
     this.uses = raw['uses'] as int;
     this.maxUses = raw['max_uses'] as int;
+    this.maxAge = raw['max_age'] as int;
+
+    if(raw['inviter'] != null) {
+      this.inviter = client.users[Snowflake(raw['inviter']['id'])];
+    }
 
-    this.inviter = client.users[Snowflake(raw['inviter']['id'] as String)];
+    if(raw['target_user'] != null) {
+      this.targetUser = client.users[Snowflake(raw['target_user']['id'])];
+    }
   }
 
   /// Deletes this Invite.

nyxx/lib/src/objects/user/NitroType.dart

@@ -0,0 +1,27 @@
+part of nyxx;
+
+///Premium types denote the level of premium a user has.
+class NitroType {
+  static const NitroType none = const NitroType._create(0);
+  static const NitroType classic = const NitroType._create(1);
+  static const NitroType nitro = const NitroType._create(2);
+
+  final int _value;
+
+  const NitroType._create(int? value) : _value = value ?? 0;
+  NitroType.from(int? value) : _value = value ?? 0;
+
+  @override
+  String toString() => _value.toString();
+
+  @override
+  int get hashCode => _value.hashCode;
+
+  @override
+  bool operator ==(other) {
+    if (other is NitroType || other is int)
+      return other == _value;
+
+    return false;
+  }
+}

nyxx/lib/src/objects/user/User.dart

@@ -15,7 +15,6 @@ class User extends SnowflakeEntity with ISend, Mentionable, IMessageAuthor {
   /// The user's avatar hash.
   late final String? avatar;
 
-
   /// The string to mention the user.
   @override
   String get mention => "<@!${this.id}>";
@@ -24,22 +23,41 @@ class User extends SnowflakeEntity with ISend, Mentionable, IMessageAuthor {
   @override
   String get tag => "${this.username}#${this.discriminator}";
 
-  /// Whether or not the user is a bot.
+  /// Whether the user belongs to an OAuth2 application
   @override
   late final bool bot;
 
+  /// Whether the user is an Official Discord System user (part of the urgent message system)
+  late final bool system;
+
   /// The member's status. `offline`, `online`, `idle`, or `dnd`.
   ClientStatus? status;
 
   /// The member's presence.
   Presence? presence;
 
+  /// Additional flags associated with user account. Describes if user has certain
+  /// features like joined into one of houses or is discord employee.
+  UserFlags? userFlags;
+
+  /// Premium types denote the level of premium a user has.
+  NitroType? nitroType;
+
   User._new(Map<String, dynamic> raw, this.client)
       : super(Snowflake(raw['id'] as String)) {
     this.username = raw['username'] as String;
     this.discriminator = raw['discriminator'] as String;
     this.avatar = raw['avatar'] as String?;
     this.bot = raw['bot'] as bool? ?? false;
+    this.system = raw['system'] as bool? ?? false;
+
+    if(raw['public_flags'] != null) {
+      this.userFlags = UserFlags._new(raw['public_flags'] as int);
+    }
+
+    if(raw['premium_type'] != null) {
+      this.nitroType = NitroType.from(raw['premium_type'] as int);
+    }
   }
 
   /// The user's avatar, represented as URL.