vk_cozy 0.1 → 0.3.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 84172a36d37fa7b748679799a2baedad22b63e88f03a59ede5742e0d44731221
-  data.tar.gz: d5370aa9ca6b774890ebeb52006102d1d28e5aa6f2acbd38c67bbdcbd9bcab18
+  metadata.gz: 3ff934ed3de889cad7691093027e24648bd20cbc8bfcc7302c0fbcc53a34e79e
+  data.tar.gz: e824e451aa36108fb9b5fee80c7e0c289aefc65cb9c0afb65e23e9d371c79421
 SHA512:
-  metadata.gz: 9fcd0cf360e2f41524459621f8e1f388a2bb037629218ccd7274d5946e3a3cf805237302b092d4f3c4b1a084526c2057dbefb781c4485e2b876c1da6759f996e
-  data.tar.gz: e89c98542748a160e64ab434873e3330f9a8124f981f2d56b2b003795d9d4994f10dacb1a1a404c65f9b75561b73f26e3aca4770a4857832288b4a6499c6aad2
+  metadata.gz: f7b7b564065b60f8e789e56c82ed9da73600650a05c7a71bc9057d966e04262ecf683d24c2304e7570c284e94209b37fb5166c5ea94ac3e13e094e344c759510
+  data.tar.gz: b076661eaab47055f6e7ee4f705892dbbc1c1f02d9069858b06c42361cae86a38139639a61072a33736eab2f7e4a524b4b2cfa3e5d9b511d37b8e3d94279a7cc

data/Gemfile

@@ -2,4 +2,8 @@
 
 source 'http://rubygems.org'
 
+gem 'hash_dot', '~> 2.5'
+gem 'inum', '~> 5.2'
+gem 'ruby-enum', '~> 0.9.0'
+
 gemspec

data/lib/vk_cozy/api/api.rb

@@ -0,0 +1,49 @@
+require 'json'
+require 'uri'
+require 'net/http'
+require "resolv-replace"
+
+class Api
+  attr_accessor :access_token, :version
+
+  SCHEME = 'https'
+  HOST = 'api.vk.com'
+  PATH = '/method/'
+  PORT = 443
+
+  def initialize(access_token, version=5.92)
+    @access_token = access_token
+    @version = version
+  end
+
+  def request_thr(method_vk, data)
+    thr = Thread.new {
+      request(method_vk, data)
+    }
+    thr.run
+  end
+
+  def request(method_vk, data)
+    data = data.to_hash
+    data = data.merge(v: version)
+    data = data.merge(access_token: access_token)
+    data.each do |argument, value|
+      data[argument] = value.join(',') if value.is_a?(Array)
+    end
+    http_response = Net::HTTP.post_form(url_for_method(method_vk), data).body
+    # return unless http_response.present?
+    json_response = JSON.parse(http_response)
+    if json_response['error']
+      raise json_response['error']['error_msg']
+    end
+    json_response
+  end
+
+  def url_for_method(method_vk)
+    URI.parse("#{SCHEME}://#{HOST}#{PATH}#{method_vk}")
+  end
+
+  def method_missing name, **kwargs
+    return request(name.to_s.sub('_', '.'), kwargs)['response']
+  end
+end

data/lib/vk_cozy/bot.rb

@@ -0,0 +1,67 @@
+require_relative 'types/events/bot_events'
+require_relative 'dispatch/views/bot/event'
+require_relative 'framework/labeler/bot'
+require_relative 'polling/bot_polling'
+require_relative 'dev/keyboard/keyboard'
+
+module VkCozy
+  class Bot
+    attr_reader :api
+
+    CLASS_BY_EVENT_TYPE = {
+      BotEventType::MESSAGE_NEW => BotMessageEvent,
+      BotEventType::MESSAGE_REPLY => BotMessageEvent,
+      BotEventType::MESSAGE_EDIT => BotMessageEvent
+    }
+
+    DEFAULT_EVENT_CLASS = BotEvent
+
+    def initialize(access_token, version=5.92)
+      @access_token = access_token
+      @api = Api.new(access_token, version)
+      
+      @polling = VkCozy::BotPolling.new(@api)
+      @labeler = VkCozy::BotLabeler.new(@api)
+    end
+
+    def on
+      return @labeler
+    end
+
+    def on_startup
+      puts 'Run polling'
+    end
+
+    def run_polling(startup=nil)
+      if startup.nil?
+        on_startup
+      elsif startup.is_a?(Proc)
+        startup.call
+      else
+        startup
+      end
+      @polling.listen do |event|
+        for event_raw in event['updates']
+          begin
+            event_raw = parse_event(event_raw)
+            if @labeler.filter(event_raw)
+              next
+            end
+          rescue Exception => e 
+            raise e
+          end
+        end
+      end
+    end
+
+    private
+
+    def parse_event(event_raw)
+      event_class = CLASS_BY_EVENT_TYPE.fetch(
+        event_raw['type'],
+        DEFAULT_EVENT_CLASS
+      )
+      return event_class.new(@api, event_raw)
+    end
+  end
+end

data/lib/vk_cozy/dev/keyboard/action.rb

@@ -0,0 +1,72 @@
+module Keyboard
+  class BaseAction
+    attr_reader :type
+    
+    def get_data
+      instance_variables.each_with_object({}) do |k, h|
+        var = instance_variable_get("#{k}")
+        if not var.nil?
+          h[k.to_s.gsub('@', '')] = var
+        end
+      end
+    end
+  end
+
+  class Text < BaseAction
+    def initialize(label, payload: nil)
+      @type = 'text'
+
+      @label = label
+      @payload = payload
+    end
+  end
+
+  class OpenLink < BaseAction
+    def initialize(label, link, payload: nil)
+      @type = 'open_link'
+
+      @label = label
+      @link = link
+      @payload = payload
+    end
+  end
+
+  class Location < BaseAction
+    def initialize(payload: nil)
+      @type = 'location'
+
+      @payload = payload
+    end
+  end
+
+  class VkPay < BaseAction
+    def initialize(payload: nil, hash: nil)
+      @type = 'vkpay'
+
+      @payload = payload
+      @hash = hash
+    end
+  end
+
+  class VkApps < BaseAction
+    def initialize(app_id, owner_id, payload: nil, label: nil, hash: nil)
+      @type = 'open_app'
+
+      @app_id = app_id
+      @owner_id = owner_id
+      @payload = payload
+      @label = label
+      @hash = hash
+    end
+  end
+
+
+  class Callback < BaseAction
+    def initialize(label, payload)
+      @type = 'callback'
+
+      @label = label
+      @payload = payload
+    end
+  end
+end

data/lib/vk_cozy/dev/keyboard/button.rb

@@ -0,0 +1,34 @@
+module Keyboard
+  class KeyboardButton
+    def initialize(action, color: nil, data: nil)
+      @action = action
+      @color = color
+      @data = data
+    end
+
+    def self.from_typed(action, color: nil)
+      return self.new(action, color: color, data: nil)
+    end
+
+    def self.from_hash(data)
+      color = data.key('color')
+      keyboard_data = {'action' => data}
+      if color.nil?
+        keyboard_data['action'].delete('color')
+        keyboard_data['color'] = color
+      end
+      return self.new(self.action, self.color, keyboard_data)
+    end
+
+    def get_data
+      if not @data.nil?
+        return @data
+      end
+      data = {'action' => @action.get_data()}
+      if ['text', 'callback'].include?(@action.type) and not @color.nil?
+        data['color'] = @color
+      end
+      return data
+    end
+  end
+end

data/lib/vk_cozy/dev/keyboard/color.rb

@@ -0,0 +1,10 @@
+module Keyboard
+  class Color
+    include Ruby::Enum
+
+		define :PRIMARY, 'primary'
+    define :SECONDARY, 'secondary'
+    define :NEGATIVE, 'negative'
+    define :POSITIVE, 'positive'
+  end
+end

data/lib/vk_cozy/dev/keyboard/keyboard.rb

@@ -0,0 +1,48 @@
+require_relative 'action'
+require_relative 'button'
+require_relative 'color'
+
+module Keyboard
+  class Keyboard
+    def initialize(one_time: false, inline: false)
+      @one_time = one_time
+      @inline = inline
+      @buttons = []
+    end
+
+    def row()
+      @buttons << []
+      return self
+    end
+
+    def add(action, color=nil)
+      if @buttons.length == 0
+        row()
+      end
+      button = KeyboardButton.from_typed(action, color: color)
+      @buttons[-1] << button
+      return self
+    end
+
+    def get_json()
+      _buttons = []
+      for row in @buttons
+        buttons = []
+        for button in row
+          buttons << button.get_data()
+        end
+        _buttons << buttons
+      end
+      data = {
+        'one_time' => @one_time,
+        'inline' => @inline,
+        'buttons' => _buttons
+      }
+      return data
+    end
+
+    def to_s
+      return JSON.generate(get_json())
+    end
+  end
+end

data/lib/vk_cozy/dispatch/views/bot/event.rb

@@ -0,0 +1,67 @@
+module VkCozy
+  class BotEvent
+    attr_reader :api, :raw, :t, :type, :obj, :object, :client_info, :message, :group_id
+    def initialize(api, event_raw)
+      @api = api
+      @raw = event_raw
+
+      @type = event_raw['type']
+      @t = @type 
+
+      @object = event_raw['object'].to_dot
+      @obj = @object
+
+      @message = @obj['message']
+
+      @client_info = @obj['client_info']
+
+      @group_id = @raw['group_id']
+      
+    end
+
+    def [] key
+      instance_variable_get("@#{key}")
+    end
+
+    def to_s
+      "BotEvent(#{@raw.to_s})"
+    end
+  end
+
+  class BotMessageEvent < BotEvent
+    attr_reader :from_user, :from_chat, :from_group, :chat_id
+    def initialize(api, event_raw)
+      super(api, event_raw)
+      @from_user = false
+      @from_chat = false
+      @from_group = false
+
+
+      peer_id = @raw['object']['peer_id']
+      if peer_id.nil?
+        peer_id = @raw['object']['message']['peer_id']
+      end
+
+      if peer_id < 0
+        @from_group = true
+      elsif peer_id < 2e9
+        @from_user = true
+      else
+        from_user = true
+        @chat_id = peer_id - 2e9
+      end
+    end
+
+    def answer(text)
+      return @api.messages_send(
+        peer_id: @message.peer_id,
+        message: text,
+        random_id: 0
+      )
+    end
+
+    def to_s
+      "BotMessageEvent(#{@raw.to_s})"
+    end
+  end
+end

data/lib/vk_cozy/dispatch/views/user/event.rb

@@ -0,0 +1,81 @@
+module VkCozy
+  class UserEvent
+    attr_accessor :api, :raw, :type,
+          :from_user, :from_chat, :from_group, :from_me, :to_me, 
+          :attachments, :message_data,
+          :message_id, :timestamp, :text, :peer_id, :flags, :extra, :extra_values, :type_id
+
+    def initialize(api, raw_event)
+      @api = api
+      @raw = raw_event
+
+      @from_user = false
+      @from_chat = false
+      @from_group = false
+      @from_me = false
+      @to_me = false
+
+      begin
+        @type = UserEventType.parse(@raw[0])
+        list_to_attr(@raw[1, @raw.length], EVENT_ATTRS_MAPPING[@type])
+      rescue StandardError => e
+        @type = @raw[0]
+      end
+
+      if VkCozy::PARSE_PEER_ID_EVENTS.include?(@type)
+        parse_peer_id()
+      end
+
+      if VkCozy::PARSE_MESSAGE_FLAGS_EVENTS
+        parse_message()
+      end
+    end
+
+    def to_s
+      instance_variables.each_with_object({}) do |k, h|
+        h[k] = instance_variable_get("#{k}")
+      end.to_json
+    end
+
+    def answer(text)
+      return @api.messages_send(
+        peer_id: @peer_id,
+        message: text,
+        random_id: 0
+      )
+    end
+
+    private
+
+    def list_to_attr(raw, attrs)
+      for i in (0..[raw.length, attrs.length].min)
+        instance_variable_set("@#{attrs[i]}", raw[i]) if respond_to? "#{attrs[i]}="
+      end
+    end
+
+    def parse_peer_id
+      if @peer_id < 0
+        @from_group = true
+        @group_id = peer_id
+
+      elsif @peer_id > 2e9
+        @from_chat = true 
+        @chat_id = @peer_id-2e9
+
+        if @extra_values and @extra_values.include?('from')
+          @user_id = @extra_values['from'].to_i
+        end
+      else
+        @from_user = true 
+        @user_id = @peer_id
+      end
+      
+    end
+
+    def parse_message
+      if @type == UserEventType::MESSAGE_NEW
+
+      end
+    end
+  end
+end

data/lib/vk_cozy/framework/labeler/bot.rb

@@ -0,0 +1,39 @@
+module VkCozy
+  class BotLabeler
+    attr_reader :api
+
+    def initialize(api)
+      @api = api
+      @rules = []
+    end
+
+    def filter(event)
+      for i in @rules
+        f = i[:filter]
+        check = f.check_bot(event)
+        if check
+          if check.is_a?(Symbol)
+            check = [Symbol]
+          elsif check.is_a?(Array)
+            i[:func].call(event, *check)
+          elsif check.is_a?(Hash)
+            i[:func].call(event, **check)
+          else
+            i[:func].call(event)
+          end
+          return true
+        end
+      end
+    end
+
+    def message_handler(filter, func)
+      if func.is_a?(Symbol)
+        func = method(func)
+      end
+      @rules << { 
+        :func => func,
+        :filter => filter
+      }
+    end
+  end
+end

data/lib/vk_cozy/framework/labeler/filters/filters.rb

@@ -0,0 +1,84 @@
+module VkCozy
+  class BaseFilter
+    def check_user(event) # Method check for user-bot
+      raise 'Method check_user not implemented'
+    end
+
+    def check_bot(event) # Method check for group-bot
+      raise 'Method check_bot not implemented'
+    end
+  end
+
+  class YaScan < VkCozy::BaseFilter
+    def initialize(pattern, flags: Regexp::IGNORECASE)
+      @flags = flags
+      @pattern = valid_pattern(pattern) # Pattern example: my name is <name> 
+    end
+
+    def valid_pattern(pattern)
+      arguments = pattern.scan(/<([\w_]*)>/).flatten
+      for i in arguments
+        pattern = pattern.sub("<#{i}>", "(?<#{i}>.*)")
+      end
+      return Regexp.new(pattern, @flags)
+    end
+
+    def check_text(text) # Text example: my name is Volk
+      text_match = @pattern.match(text)
+      if text_match.nil?
+        return false
+      end
+      return Hash[ text_match.names.zip( text_match.captures ) ] # Return: {'name' => 'Volk'}
+    end
+
+    def check_bot(event)
+      if event.type == VkCozy::BotEventType::MESSAGE_NEW
+        check_text(event.message.text)
+      end
+    end
+
+    def check_user(event)
+      if event.type == VkCozy::UserEventType::MESSAGE_NEW
+        if event.from_me
+          return false
+        end
+        check_text(event.text)
+      end
+    end
+  end
+
+  class Text < BaseFilter
+    def initialize(regex, **kwargs)
+      @regex = regex
+      @raw = kwargs
+    end
+
+    def check_user(event)
+      if event.type == VkCozy::UserEventType::MESSAGE_NEW
+
+        if event.from_me
+          return false
+        end
+        if event.text == @regex
+          return true
+        else
+          return false
+        end
+      else
+        return false
+      end
+    end
+
+    def check_bot(event)
+      if event.type == VkCozy::BotEventType::MESSAGE_NEW
+        if event.message.text == @regex
+          return true
+        else
+          return false
+        end
+      else
+        return false
+      end
+    end
+  end
+end

data/lib/vk_cozy/framework/labeler/user.rb

@@ -0,0 +1,40 @@
+module VkCozy
+  class UserLabeler
+    attr_reader :api
+
+    def initialize(api)
+      @api = api
+      @rules = []
+    end
+
+    def filter(event_raw)
+      event = VkCozy::UserEvent.new(@api, event_raw)
+      for i in @rules
+        f = i[:filter]
+        check = f.check_user(event)
+        if check
+          if check.is_a?(Symbol)
+            check = [Symbol]
+          elsif check.is_a?(Array)
+            i[:func].call(event, *check)
+          elsif check.is_a?(Hash)
+            i[:func].call(event, **check)
+          else
+            i[:func].call(event)
+          end
+          return true
+        end
+    	end
+    end
+
+    def message_handler(filter, func)
+      if func.is_a?(Symbol)
+        func = method(func)
+      end
+      @rules << { 
+        :func => func,
+        :filter => filter
+      }
+    end
+	end
+end

data/lib/vk_cozy/polling/bot_polling.rb

@@ -0,0 +1,38 @@
+module VkCozy
+  class BotPolling
+    def initialize(api, group_id=nil, wait=25, rps_delay=0)
+      @api = api
+      if group_id.nil?
+        @group_id = @api.request('groups.getById', {})['response'][0]['id']
+      else
+        @group_id = group_id
+      end
+
+      @rps_delay = rps_delay
+      @stop = false
+    end
+
+    def get_server
+      return @api.request('groups.getLongPollServer', {:group_id => @group_id})['response']
+    end
+
+    def get_event(server)
+      uri = URI.parse('%s?act=a_check&key=%s&ts=%s&wait=%s&rps_delay=%s' % [server['server'], server['key'], server['ts'], @wait, @rps_delay])
+      http_response = Net::HTTP.get(uri)
+      return JSON.parse(http_response)
+    end
+
+    def listen
+      server = get_server
+      until @stop do
+        event = get_event(server)
+        if not event['ts']
+          server = get_server
+          next
+        end
+        server['ts'] = event['ts']
+        yield event
+      end
+    end
+  end
+end

data/lib/vk_cozy/polling/user_polling.rb

@@ -0,0 +1,39 @@
+module VkCozy
+  class UserPolling
+    def initialize(api=nil, user_id=nil, mode=234, wait=25, rps_delay=0, error_handler=nil)
+      @api = api
+      if user_id.nil?
+        @user_id = @api.request('users.get', {})['response'][0]['id']
+      else
+        @user_id = user_id
+      end
+      @mode = mode 
+      @wait = wait
+      @rps_delay = rps_delay
+      @stop = false
+    end
+
+    def get_event(server)
+      uri = URI.parse('https://%s?act=a_check&key=%s&ts=%s&wait=%s&mode=%s&rps_delay=%s&version=%s' % [server['server'], server['key'], server['ts'], @wait, @mode, @rps_delay, 3])
+      http_response = Net::HTTP.get(uri)
+      return JSON.parse(http_response)
+    end
+
+    def get_server
+      return @api.request('messages.getLongPollServer', {})['response']
+    end
+
+    def listen
+      server = get_server
+      until @stop do
+        event = get_event(server)
+        if not event['ts']
+          server = get_server
+          next
+        end
+        server['ts'] = event['ts']
+        yield event
+      end
+    end
+  end
+end

data/lib/vk_cozy/types/events/bot_events.rb

@@ -0,0 +1,73 @@
+module VkCozy
+  class BotEventType
+    include Ruby::Enum
+
+    define :MESSAGE_NEW, 'message_new'
+    define :MESSAGE_REPLY, 'message_reply'
+    define :MESSAGE_EDIT, 'message_edit'
+    define :MESSAGE_EVENT, 'message_event'
+
+    define :MESSAGE_TYPING_STATE, 'message_typing_state'
+
+    define :MESSAGE_ALLOW, 'message_allow'
+
+    define :MESSAGE_DENY, 'message_deny'
+
+    define :PHOTO_NEW, 'photo_new'
+
+    define :PHOTO_COMMENT_NEW, 'photo_comment_new'
+    define :PHOTO_COMMENT_EDIT, 'photo_comment_edit'
+    define :PHOTO_COMMENT_RESTORE, 'photo_comment_restore'
+
+    define :PHOTO_COMMENT_DELETE, 'photo_comment_delete'
+
+    define :AUDIO_NEW, 'audio_new'
+
+    define :VIDEO_NEW, 'video_new'
+
+       define :VIDEO_COMMENT_NEW, 'video_comment_new'
+    define :VIDEO_COMMENT_EDIT, 'video_comment_edit'
+    define :VIDEO_COMMENT_RESTORE, 'video_comment_restore'
+
+    define :VIDEO_COMMENT_DELETE, 'video_comment_delete'
+
+    define :WALL_POST_NEW, 'wall_post_new'
+    define :WALL_REPOST, 'wall_repost'
+
+    define :WALL_REPLY_NEW, 'wall_reply_new'
+    define :WALL_REPLY_EDIT, 'wall_reply_edit'
+    define :WALL_REPLY_RESTORE, 'wall_reply_restore'
+
+    define :WALL_REPLY_DELETE, 'wall_reply_delete'
+
+    define :BOARD_POST_NEW, 'board_post_new'
+    define :BOARD_POST_EDIT, 'board_post_edit'
+    define :BOARD_POST_RESTORE, 'board_post_restore'
+
+    define :BOARD_POST_DELETE, 'board_post_delete'
+
+    define :MARKET_COMMENT_NEW, 'market_comment_new'
+    define :MARKET_COMMENT_EDIT, 'market_comment_edit'
+    define :MARKET_COMMENT_RESTORE, 'market_comment_restore'
+
+    define :MARKET_COMMENT_DELETE, 'market_comment_delete'
+
+    define :GROUP_LEAVE, 'group_leave'
+
+    define :GROUP_JOIN, 'group_join'
+
+    define :USER_BLOCK, 'user_block'
+
+    define :USER_UNBLOCK, 'user_unblock'
+
+    define :POLL_VOTE_NEW, 'poll_vote_new'
+
+    define :GROUP_OFFICERS_EDIT, 'group_officers_edit'
+
+    define :GROUP_CHANGE_SETTINGS, 'group_change_settings'
+
+    define :GROUP_CHANGE_PHOTO, 'group_change_photo'
+    
+    define :VKPAY_TRANSACTION, 'vkpay_transaction'
+  end
+end

data/lib/vk_cozy/types/events/user_events.rb

@@ -0,0 +1,67 @@
+module VkCozy
+  class UserEventType < Inum::Base
+    define :UNDEFINED_EVENT, -1
+
+    define :REPLACE_MESSAGE_FLAGS, 1
+    define :INSTALL_MESSAGE_FLAGS, 2
+    define :RESET_MESSAGE_FLAGS, 3
+
+    define :MESSAGE_NEW, 4
+    define :MESSAGE_EDIT, 5
+    define :IN_READ, 6
+    define :OUT_READ, 7
+    define :FRIEND_ONLINE, 8
+    define :FRIEND_OFFLINE, 9
+    define :RESET_DIALOG_FLAGS, 10
+    define :REPLACE_DIALOG_FLAGS, 11
+    define :INSTALL_DIALOG_FLAGS, 12
+    define :MESSAGES_DELETE, 13
+    define :MESSAGES_RESTORE, 14
+
+    define :MESSAGE_CHANGE, 18
+    define :CLEAR_MESSAGE_CACHE, 19
+
+    define :CHANGE_MAJOR_ID, 20
+    define :CHANGE_MINOR_ID, 21
+
+    define :CHAT_EDIT, 51
+    define :CHAT_INFO_EDIT, 52
+    define :DIALOG_TYPING_STATE, 61
+
+    define :CHAT_TYPING_STATE, 62
+    define :USERS_TYPING_STATE, 63
+    define :CHAT_VOICE_MESSAGE_STATES, 64
+    define :PHOTO_UPLOAD_STATE, 65
+    define :VIDEO_UPLOAD_STATE, 66
+    define :FILE_UPLOAD_STAE, 67
+
+    define :CALL, 70
+    define :COUNTER, 80
+    define :USER_INVISIBLE_CHANGE, 81
+    define :NOTIFICATIONS_SETTINGS_CHANGED, 114
+    define :CHAT_CALL, 115
+    define :CALLBACK_BUTTON_REPLY, 119
+  end
+
+  MESSAGE_EXTRA_FIELDS = [
+    'peer_id', 'timestamp', 'text', 'extra_values', 'attachments', 'random_id'
+  ]
+  MSGID = 'message_id'
+  EVENT_ATTRS_MAPPING = {
+    VkCozy::UserEventType::REPLACE_MESSAGE_FLAGS => [MSGID, 'flags'] + MESSAGE_EXTRA_FIELDS,
+    VkCozy::UserEventType::INSTALL_MESSAGE_FLAGS => [MSGID, 'mask'] + MESSAGE_EXTRA_FIELDS,
+    VkCozy::UserEventType::RESET_MESSAGE_FLAGS => [MSGID, 'mask'] + MESSAGE_EXTRA_FIELDS,
+    VkCozy::UserEventType::MESSAGE_NEW => [MSGID, 'flags'] + MESSAGE_EXTRA_FIELDS,
+    VkCozy::UserEventType::MESSAGE_EDIT => [MSGID, 'mask'] + MESSAGE_EXTRA_FIELDS,
+    VkCozy::UserEventType::IN_READ => ['peer_id', 'local_id'],
+    VkCozy::UserEventType::OUT_READ => ['peer_id', 'local_id'],
+    VkCozy::UserEventType::FRIEND_ONLINE => ['user_id', 'extra', 'timestamp'],
+    VkCozy::UserEventType::FRIEND_OFFLINE => ['user_id', 'flags', 'timestamp'],
+    VkCozy::UserEventType::DIALOG_TYPING_STATE => ['user_id', 'flags']
+  }
+  PARSE_PEER_ID_EVENTS = EVENT_ATTRS_MAPPING.map{|k, v| if v.include?('peer_id') then k end}.select{ |i| not i.nil? }
+  PARSE_MESSAGE_FLAGS_EVENTS = [
+    VkCozy::UserEventType::REPLACE_MESSAGE_FLAGS,
+    VkCozy::UserEventType::MESSAGE_NEW
+  ]
+end

data/lib/vk_cozy/user.rb

@@ -0,0 +1,48 @@
+require_relative 'types/events/user_events'
+require_relative 'dispatch/views/user/event'
+require_relative 'framework/labeler/user'
+require_relative 'polling/user_polling'
+
+module VkCozy
+  class User
+    attr_reader :api
+
+    def initialize(access_token, version=5.92)
+      @access_token = access_token
+      @api = Api.new(access_token, version)
+      
+      @polling = VkCozy::UserPolling.new(@api)
+      @labeler = VkCozy::UserLabeler.new(@api)
+    end
+
+    def on
+      return @labeler
+    end
+
+    def on_startup
+      puts 'Run polling'
+    end
+
+    def run_polling(startup=nil)
+      if startup.nil?
+        on_startup
+      elsif startup.is_a?(Proc)
+        startup.call
+      else
+        startup
+      end
+
+      @polling.listen do |event|
+        for update in event['updates']
+          begin
+            if @labeler.filter(update)
+              next
+            end
+          rescue Exception => e 
+            raise e
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vk_cozy.rb

@@ -5,4 +5,4 @@ require 'hash_dot'
 require_relative 'vk_cozy/api/api'
 require_relative 'vk_cozy/bot'
 require_relative 'vk_cozy/user'
-require_relative 'vk_cozy\framework\labeler\filters\filters'
+require_relative 'vk_cozy/framework/labeler/filters/filters'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: vk_cozy
 version: !ruby/object:Gem::Version
-  version: '0.1'
+  version: 0.3.6
 platform: ruby
 authors:
 - Danil Konenko
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-06-10 00:00:00.000000000 Z
+date: 2022-06-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: inum
@@ -60,7 +60,23 @@ extra_rdoc_files: []
 files:
 - Gemfile
 - lib/vk_cozy.rb
-homepage: https://rubygems.org/gems/hola
+- lib/vk_cozy/api/api.rb
+- lib/vk_cozy/bot.rb
+- lib/vk_cozy/dev/keyboard/action.rb
+- lib/vk_cozy/dev/keyboard/button.rb
+- lib/vk_cozy/dev/keyboard/color.rb
+- lib/vk_cozy/dev/keyboard/keyboard.rb
+- lib/vk_cozy/dispatch/views/bot/event.rb
+- lib/vk_cozy/dispatch/views/user/event.rb
+- lib/vk_cozy/framework/labeler/bot.rb
+- lib/vk_cozy/framework/labeler/filters/filters.rb
+- lib/vk_cozy/framework/labeler/user.rb
+- lib/vk_cozy/polling/bot_polling.rb
+- lib/vk_cozy/polling/user_polling.rb
+- lib/vk_cozy/types/events/bot_events.rb
+- lib/vk_cozy/types/events/user_events.rb
+- lib/vk_cozy/user.rb
+homepage: https://github.com/VkCozy/vk_cozy
 licenses:
 - MIT
 metadata: {}