rubirai 0.0.2

data/lib/rubirai/events/bot_events.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'rubirai/events/event'
+
+module Rubirai
+  class BotEvent < Event
+    set_event nil, :qq
+  end
+
+  class BotOnlineEvent < BotEvent
+    set_event :BotOnlineEvent
+  end
+
+  class BotActiveOfflineEvent < BotEvent
+    set_event :BotOfflineEventActive
+  end
+
+  class BotForcedOfflineEvent < BotEvent
+    set_event :BotOfflineEventForce
+  end
+
+  class BotDroppedEvent < BotEvent
+    set_event :BotOfflineEventDropped
+  end
+
+  class BotReloginEvent < BotEvent
+    set_event :BotReloginEvent
+  end
+
+  class BotGroupPermissionChangedEvent < BotEvent
+    set_event :BotGroupPermissionChangeEvent, :origin, :new, :current, :group
+  end
+
+  class BotMutedEvent < BotEvent
+    set_event :BotMuteEvent, :duration_seconds, :operator
+  end
+
+  class BotUnmutedEvent < BotEvent
+    set_event :BotUnmuteEvent, :operator
+  end
+
+  class BotJoinGroupEvent < BotEvent
+    set_event :BotJoinGroupEvent, :group
+  end
+
+  class BotActiveLeaveEvent < BotEvent
+    set_event :BotLeaveEventActive, :group
+  end
+
+  class BotKickedEvent < BotEvent
+    set_event :BotLeaveEventKick, :group
+  end
+end

data/lib/rubirai/events/event.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require 'rubirai/objects/group'
+require 'rubirai/utils'
+
+module Rubirai
+  # @abstract
+  class Event
+    # @private
+    def self.gen_descendants
+      descs = ObjectSpace.each_object(Class).select do |klass|
+        klass < self
+      end
+
+      metaclass.instance_eval do
+        define_method(:descendants) do
+          descs
+        end
+        leaf_descs = descs.filter { |d| d.respond_to? :type }
+        all_types = leaf_descs.map(&:type)
+        define_method(:all_types) do
+          all_types
+        end
+        type_map = leaf_descs.to_h { |d| [d.type, d] }
+        define_method(:type_map) do
+          type_map
+        end
+      end
+
+      private_class_method :descendants
+    end
+
+    def self.type_to_klass(type)
+      # noinspection RubyResolve
+      type_map[type.to_sym]
+    end
+
+    def self.valid_type?(type)
+      # noinspection RubyResolve
+      all_types.include? type
+    end
+
+    def self.set_event(type, *attr_keys)
+      attr_reader(*attr_keys)
+
+      metaclass.instance_eval do
+        break if type.nil?
+        define_method(:type) do
+          type
+        end
+      end
+
+      class_eval do
+        define_method(:initialize) do |hash, bot = nil|
+          # noinspection RubySuperCallWithoutSuperclassInspection
+          super hash, bot
+          hash = hash.stringify_keys
+          attr_keys.each do |k|
+            k2 = k.to_s.snake_to_camel(lower: true)
+            val = hash[k2]
+            val = case k2
+                  when 'group'
+                    Group.new val, bot
+                  when 'operator', 'member'
+                    GroupUser.new val, bot
+                  when 'sender'
+                    if val.key? 'group'
+                      GroupUser.new val, bot
+                    else
+                      User.new val, bot
+                    end
+                  when 'messageChain'
+                    MessageChain.new bot, val
+                  else
+                    val
+                  end
+            instance_variable_set("@#{k}", val)
+          end
+        end
+      end
+    end
+
+    def self.metaclass
+      class << self
+        self
+      end
+    end
+
+    private_class_method :metaclass
+
+    # @param hash [Hash]
+    # @param bot [Rubirai::Bot, nil]
+    def self.parse(hash, bot = nil)
+      hash = hash.stringify_keys
+      type_to_klass(hash['type']).new hash, bot
+    end
+
+    # @!attribute [r] bot
+    #   @return [Bot]
+    # @!attribute [r] raw
+    #   The raw hash representation of the event
+    #   @return [Hash]
+    attr_reader :bot, :raw
+
+    def initialize(hash, bot = nil)
+      @raw = hash
+      @bot = bot
+    end
+  end
+end
+
+require_relative 'bot_events'
+require_relative 'message_events'
+
+Rubirai::Event.gen_descendants

data/lib/rubirai/events/message_events.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require 'rubirai/events/event'
+
+module Rubirai
+  # The base class for message events
+  # @abstract
+  class MessageEvent < Event
+    # @!attribute [r] message_chain
+    #   @return [MessageChain] the message chain
+    set_event nil, :message_chain, :sender
+  end
+
+  # Friend message event
+  class FriendMessageEvent < MessageEvent
+    # @!method initialize(hash, bot = nil)
+    #   @param hash [Hash]
+    #   @param bot [Rubirai::Bot]
+    # @!attribute [r] sender
+    #   @return [User] the sender
+    set_event :FriendMessage
+  end
+
+  # Group message event
+  class GroupMessageEvent < MessageEvent
+    # @!method initialize(hash, bot = nil)
+    #   @param hash [Hash]
+    #   @param bot [Rubirai::Bot]
+    # @!attribute [r] sender
+    #   @return [GroupUser] the sender
+    set_event :GroupMessage
+  end
+
+  # Temp message event
+  class TempMessageEvent < MessageEvent
+    # @!method initialize(hash, bot = nil)
+    #   @param hash [Hash]
+    #   @param bot [Rubirai::Bot]
+    # @!attribute [r] sender
+    #   @return [GroupUser] the sender
+    set_event :TempMessage
+  end
+
+  # The base class for recall events
+  # @abstract
+  class RecallEvent < Event
+    # @!attribute [r] author_id
+    #   @return [Integer] the author's id
+    # @!attribute [r] message_id
+    #   @return [Integer] the message id
+    # @!attribute [r] time
+    #   @return [Integer] the time the message is sent
+    set_event nil, :author_id, :message_id, :time
+  end
+
+  # Group recall event
+  class GroupRecallEvent < RecallEvent
+    # @!method initialize(hash, bot = nil)
+    #   @param hash [Hash]
+    #   @param bot [Rubirai::Bot]
+    # @!attribute [r] group
+    #   @return [Group] the group
+    # @!attribute [r] operator
+    #   @return [GroupUser] the operator
+    set_event :GroupRecallEvent, :group, :operator
+  end
+
+  # Friend recall event
+  class FriendRecallEvent < RecallEvent
+    # @!method initialize(hash, bot = nil)
+    #   @param hash [Hash]
+    #   @param bot [Rubirai::Bot]
+    # @!attribute [r] operator
+    #   @return [Integer] the operator id
+    set_event :FriendRecallEvent, :operator
+  end
+end

data/lib/rubirai/events/request_events.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'rubirai/events/event'
+
+module Rubirai
+  class RequestEvent < Event
+    # @!attribute [r] event_id
+    #   @return [Integer] the event id
+    # @!attribute [r] from_id
+    #   @return [Integer] the id of the sender of the request
+    # @!attribute [r] group_id
+    #   @return [Integer] the group where the request is from. 0 if not from group
+    # @!attribute [r] nick
+    #   @return [String] the nickname of the sender of the request
+    # @!attribute [r] message
+    #   @return [String] the message from the sender
+    set_event nil, :event_id, :from_id, :group_id, :nick, :message
+  end
+
+  class NewFriendRequestEvent < RequestEvent
+    set_event :NewFriendRequestEvent
+  end
+
+  class JoinGroupRequestEvent < RequestEvent
+    # @!attribute [r] group_name
+    #   @return [String] the group name
+    set_event :MemberJoinRequestEvent, :group_name
+  end
+
+  class BotInvitedToGroupEvent < RequestEvent
+    # @!attribute [r] group_name
+    #   @return [String] the group name
+    set_event :BotInvitedJoinGroupRequestEvent, :group_name
+  end
+end

data/lib/rubirai/events/rubirai_events.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'rubirai/events/event'
+
+module Rubirai
+  class RubiraiErrorEvent < Event
+    attr_reader :err
+
+    # An error event just for internal use
+    #
+    # @param err [RuntimeError] the error object
+    def initialize(err, bot = nil)
+      super nil, bot
+      @err = err
+    end
+  end
+end

data/lib/rubirai/listener.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'concurrent'
+require 'rubirai/events/rubirai_events'
+
+module Rubirai
+  class Bot
+    def start_listen(interval, is_blocking: false, ignore_error: false)
+      raise RubiraiError, 'listener is already running' if @listener&.running?
+      @listener_stop_event = Concurrent::Event.new if is_blocking
+      bot = self
+      @listener = Concurrent::TimerTask.new(execution_interval: interval) do
+        loop do
+          events = fetch_message
+          events.each do |e|
+            @listener_funcs.each { |f| f.call e }
+          rescue RuntimeError => e
+            @listener_funcs.each { |f| f.call RubiraiErrorEvent.new(e, bot) unless ignore_error }
+          end
+          break if events.length < 10
+        rescue RuntimeError => e
+          @listener_funcs.each { |f| f.call RubiraiErrorEvent.new(e, bot) unless ignore_error }
+          break
+        end
+      end
+      @listener.execute
+      @listener_stop_event.wait if is_blocking
+    end
+
+    def add_listener(&listener_block)
+      @listener_funcs << listener_block
+    end
+
+    def clear_listener
+      @listener_funcs.clear
+    end
+
+    def stop_listen
+      @listener.shutdown
+      @listener_stop_event&.set
+      @listener_stop_event = nil
+    end
+  end
+end

data/lib/rubirai/listing.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'rubirai/objects/user'
+require 'rubirai/objects/group'
+
+module Rubirai
+  class Bot
+    # Get friend list of the bot
+    # @return [Array<User>] list of friends
+    def friend_list
+      resp = call :get, '/friendList', params: {
+        sessionKey: @session
+      }
+      resp.map { |friend| User.new(friend, self) }
+    end
+
+    # Get group list of the bot
+    # @return [Array<Group>] list of groups
+    def group_list
+      resp = call :get, '/groupList', params: {
+        sessionKey: @session
+      }
+      resp.map { |group| Group.new(group, self) }
+    end
+
+    # Get member list of a group
+    # @param group_id [Integer, String] group id
+    # @return [Array<GroupUser>] list of members
+    def member_list(group_id)
+      resp = call :get, '/memberList', params: {
+        sessionKey: @session,
+        target: group_id
+      }
+      resp.map { |member| GroupUser.new(member, self) }
+    end
+  end
+end

data/lib/rubirai/management.rb

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+require 'rubirai/objects/info'
+
+module Rubirai
+  class Bot
+    # Mute a group member
+    #
+    # @param group_id [Integer] group id
+    # @param member_id [Integer] member id
+    # @param time [Integer] the mute time
+    def mute(group_id, member_id, time = 0)
+      call :post, '/mute', json: {
+        sessionKey: @session,
+        target: group_id,
+        memberId: member_id,
+        time: time
+      }
+      nil
+    end
+
+    # Unmute a group member
+    #
+    # @param group_id [Integer] group id
+    # @param member_id [Integer] member id
+    # @return [void]
+    def unmute(group_id, member_id)
+      call :post, '/unmute', json: {
+        sessionKey: @session,
+        target: group_id,
+        memberId: member_id
+      }
+      nil
+    end
+
+    # Kick a member from a group
+    #
+    # @param group_id [Integer] group id
+    # @param member_id [Integer] member id
+    # @param msg [String, nil] the message for the kicked
+    # @return [void]
+    def kick(group_id, member_id, msg = nil)
+      json = {
+        sessionKey: @session,
+        target: group_id,
+        memberId: member_id
+      }
+      json[:msg] = msg if msg
+      call :post, '/kick', json: json
+      nil
+    end
+
+    # Quit a group
+    #
+    # @param group_id [Integer] group id
+    # @return [void]
+    def quit(group_id)
+      call :post, '/quit', json: {
+        sessionKey: @session,
+        target: group_id
+      }
+      nil
+    end
+
+    # Mute all group
+    #
+    # @param group_id [Integer] group id
+    # @return [void]
+    def mute_all(group_id)
+      call :post, '/muteAll', json: {
+        sessionKey: @session,
+        target: group_id
+      }
+      nil
+    end
+
+    def unmute_all(group_id)
+      call :post, '/unmuteAll', json: {
+        sessionKey: @session,
+        target: group_id
+      }
+      nil
+    end
+
+    def get_group_config(group_id)
+      resp = call :get, '/groupConfig', params: {
+        sessionKey: @session,
+        target: group_id
+      }
+      GroupConfig.new resp, self
+    end
+
+    # Set group config
+    #
+    # @param group_id [Integer] group id
+    # @param config [GroupConfig, Hash{String => Object}] the configuration
+    # @return [void]
+    def set_group_config(group_id, config)
+      config.must_be! [GroupConfig, Hash], RubiraiError, 'must be GroupConfig or Hash'
+      config.stringify_keys! if config.is_a? Hash
+      config = config.to_h if config.is_a? GroupConfig
+      call :post, '/groupConfig', json: {
+        sessionKey: @session,
+        target: group_id,
+        config: config
+      }
+      nil
+    end
+
+    def get_member_info(group_id, member_id)
+      resp = call :get, '/memberInfo', params: {
+        sessionKey: @session,
+        target: group_id,
+        memberId: member_id
+      }
+      MemberInfo.new resp, self
+    end
+
+    def set_member_info(group_id, member_id, info)
+      info.must_be! [MemberInfo, Hash], RubiraiError, 'must be MemberInfo or Hash'
+      info.stringify_keys! if info.is_a? Hash
+      info = info.to_h if info.is_a? MemberInfo
+      call :post, '/memberInfo', json: {
+        sessionKey: @session,
+        target: group_id,
+        memberId: member_id,
+        info: info
+      }
+      nil
+    end
+
+    def get_group_file_list(group_id, dir = nil)
+      resp = call :get, '/groupFileList', params: {
+        sessionKey: @session,
+        target: group_id,
+        dir: dir
+      }.compact
+      resp.must_be! Array # assert resp is Array
+      resp.map { |f| GroupFileSimple.new(f, self) }
+    end
+
+    # Get the info about a group file
+    # @param group_id [Integer] the group id
+    # @param file_id [String] the file id, e.g. `/xxx-xxx-xxx-xxx`
+    def get_group_file_info(group_id, file_id)
+      resp = call :get, '/groupFileInfo', params: {
+        sessionKey: @session,
+        target: group_id,
+        id: file_id
+      }
+      GroupFile.new resp, self
+    end
+
+    def rename_group_file(group_id, file_id, new_name)
+      call :post, '/groupFileRename', json: {
+        sessionKey: @session,
+        target: group_id,
+        id: file_id,
+        rename: new_name
+      }
+      nil
+    end
+
+    def group_mkdir(group_id, dir)
+      call :post, '/groupMkdir', json: {
+        sessionKey: @session,
+        group: group_id,
+        dir: dir
+      }
+      nil
+    end
+
+    def group_file_mv(group_id, file_id, path)
+      call :post, '/groupFileMove', json: {
+        sessionKey: @session,
+        target: group_id,
+        id: file_id,
+        movePath: path
+      }
+      nil
+    end
+
+    def group_file_delete(group_id, file_id)
+      call :post, '/groupFileDelete', json: {
+        sessionKey: @session,
+        target: group_id,
+        id: file_id
+      }
+      nil
+    end
+
+    def group_set_essence(msg_id)
+      call :post, '/setEssence', json: {
+        sessionKey: @session,
+        target: msg_id
+      }
+      nil
+    end
+  end
+end