vk 0.0.4 → 0.6.5.53

data/lib/vk/dsl/friends.rb

@@ -0,0 +1,24 @@
+require 'vk/exceptions'
+
+module Vk
+  module DSL
+    module Friends
+      # Friends information
+      # @param [Fixnum] user_id user identifier
+      # @param [Hash] options
+      # @option options [Array<String>] :fields ([:user_id, :first_name, :last_name]) what fields to request
+      # @option options [Fixnum] :count how many friends to request
+      # @option options [Fixnum] :offset offset of friends to request
+      # @return [<Fixnum>, <Vk::User>]
+      def get_friends(user_id, options = {})
+        options[:user_id] = user_id
+
+        if options[:fields]
+          Vk::Result.new('friends.get', Vk::User, options).all
+        else
+          request('friends.get', options)['items']
+        end
+      end
+    end
+  end
+end

data/lib/vk/dsl/groups.rb

@@ -0,0 +1,40 @@
+require 'vk/exceptions'
+
+module Vk
+  module DSL
+    module Groups
+      # Identifiers of groups in which user participates
+      # @param [Integer] user_id user’s identifier
+      # @param [Hash] options
+      # @option options [Boolean] :extended (0)
+      # @option options [<:admin, :editor, :moder, :groups, :publics, :events>] :filter
+      # @option options [<:city, :country, :place, :description, :wiki_page, :members_count, :counters, :start_date, :end_date, :can_post, :can_see_all_posts, :activity, :status, :contacts, :links, :fixed_post, :verified, :site, :can_create_topic>] :fields
+      # @option options [Fixnum] :offset
+      # @option options [Fixnum] :count
+      # @return [Array] array of group identifiers
+      def get_groups(user_id, options = {})
+        options[:user_id] = user_id
+        options[:extended] = !!options[:extended] ? 1 : 0 if options[:extended]
+        options[:filter] = options[:filter].map(&:to_s).join(',') if options[:filter]
+        options[:fields] = options[:fields].map(&:to_s).join(',') if options[:fields]
+        Vk::Result.new('groups.get', Vk::Group, options)
+      end
+
+      # @param [String] group_ids
+      # @param [Hash] options
+      # @option options [<:city, :country, :place, :description, :wiki_page, :members_count, :counters, :start_date, :end_date, :can_post, :can_see_all_posts, :activity, :status, :contacts, :links, :fixed_post, :verified, :site, :can_create_topic>] :fields
+      def get_groups_by_id(group_ids, options = {})
+        options[:group_ids] = Array(group_ids).join(',')
+        (request('groups.getById', options) || []).map { |group| Vk::Group.new(group) }
+      end
+
+      # @param [String] group_id
+      # @param [Hash] options
+      # @option options [<:city, :country, :place, :description, :wiki_page, :members_count, :counters, :start_date, :end_date, :can_post, :can_see_all_posts, :activity, :status, :contacts, :links, :fixed_post, :verified, :site, :can_create_topic>] :fields
+      def get_group_by_id(group_id, options = {})
+        get_groups_by_id(group_id, options).first
+      end
+      alias get_group get_group_by_id
+    end
+  end
+end

data/lib/vk/dsl/newsfeed.rb

@@ -0,0 +1,137 @@
+require 'vk/exceptions'
+
+module Vk
+  module DSL
+    module Newsfeed
+      FIELDS = %i(
+        sex bdate city country photo_50 photo_100 photo_200_orig photo_200 photo_400_orig photo_max photo_max_orig
+        online online_mobile domain has_mobile contacts connections site education universities schools
+        can_post can_see_all_posts can_see_audio can_write_private_message status last_seen common_count
+        relation relatives screen_name maiden_name timezone occupation activities interests music movies tv books games
+        about quotes
+      )
+
+      class SearchItem < Vk::Base
+        self.fields = ([
+          :id, :owner_id, :from_id, :signer_id, :date, :text, :comments, :likes, :attachments, :geo
+        ] + FIELDS).uniq.compact
+
+        # @return [SearchResult]
+        attr_accessor :search_result
+
+        def as_search_result_of(search_result)
+          self.search_result = search_result
+          self
+        end
+
+        # @return [Vk::User, Vk::Group]
+        def owner
+          find_group_or_user(owner_id)
+        end
+
+        # @return [Vk::User, Vk::Group]
+        def from
+          find_group_or_user(from_id)
+        end
+
+        # @return [Vk::User]
+        def signer
+          find_group_or_user(signer_id)
+        end
+
+        def time
+          Time.at(date)
+        end
+
+        private
+
+        def find_group_or_user(user_or_group_id)
+          user_or_group_id = user_or_group_id.to_i
+          return if user_or_group_id == 0
+          if search_result
+            if user_or_group_id < 0
+              search_result.groups.detect { |group| group.id == -user_or_group_id }
+            else
+              search_result.profiles.detect { |user| user.id == user_or_group_id }
+            end
+          else
+            if user_or_group_id < 0
+              Vk::Group.new(-user_or_group_id)
+            else
+              Vk::User.new(user_or_group_id)
+            end
+          end
+        end
+      end
+
+      class SearchResult
+        # @return [Hash]
+        attr_accessor :options
+
+        # @param [Vk::Client] client
+        # @param [Hash] options
+        def initialize(client, options = {})
+          @client = client
+          @options = options
+        end
+
+        def result
+          @result ||= @client.request('newsfeed.search', @options)
+        end
+
+        def fetch!
+          result
+          self
+        end
+
+        # @return [Array<SearchItem>]
+        def items
+          @items ||= result['items'].map do |item|
+            SearchItem.new(item).as_search_result_of(self)
+          end
+        end
+
+        # @return [Array<Vk::User>]
+        def profiles
+          @profiles ||= result['profiles'].map { |user| Vk::User.new(user) }
+        end
+
+        # @return [Array<Vk::Group>]
+        def groups
+          @groups ||= result['groups'].map { |group| Vk::Group.new(group) }
+        end
+
+        # @return [String]
+        def next_from
+          @next_from ||= result['next_from']
+        end
+
+        # @return [SearchResult]
+        def next_page
+          self.class.new(@client, options.merge(start_from: next_from))
+        end
+      end
+
+
+      # Friends information
+      # @param [Hash] options
+      # @option options [String] :q search query string
+      # @option options [Boolean] :extended search query string
+      # @option options [Fixnum] :count (1000) how many posts to request
+      # @option options [Numeric] :latitude -90 to 90
+      # @option options [Numeric] :longitude -180 to 180
+      # @option options [DateTime] :start_time
+      # @option options [DateTime] :end_time
+      # @option options [String] :start_from
+      # @option options [Array<Symbol>] :fields see {FIELDS}
+      # @return [SearchResult]
+      def search(options = {})
+        options[:extended] = !!options[:extended] ? 1 : 0 if options[:extended]
+        options[:start_time] = options[:start_time].to_i if options[:start_time]
+        options[:end_time] = options[:end_time].to_i if options[:end_time]
+        options[:fields] = Array.wrap(options[:fields]).compact.join(',') if options[:fields]
+        SearchResult.new(self, options).fetch!
+      end
+    end
+  end
+end

data/lib/vk/dsl/photos.rb

@@ -0,0 +1,36 @@
+require 'vk/exceptions'
+
+module Vk
+  module DSL
+    module Photos
+      # @param [String] owner_id
+      # @param [Hash] options
+      # @option options :offset [Fixnum] offset for loaded countries
+      # @option options :count [Fixnum] (100) amount of countries to load
+      # @return [Vk::Result<Vk::Album>]
+      def get_albums(owner_id, options = {})
+        options[:owner_id] = owner_id
+        options[:need_system] = !!options[:need_system] ? 1 : 0 if options.key?(:need_system)
+        options[:photo_sizes] = !!options[:photo_sizes] ? 1 : 0 if options.key?(:photo_sizes)
+        options[:need_covers] = !!options[:need_covers] ? 1 : 0 if options.key?(:need_covers)
+        options[:album_ids] = Array(options[:album_ids]).map(&:to_s).join(',') if options.key?(:album_ids)
+        require 'vk/album'
+        Vk::Result.new('photos.getAlbums', Vk::Album, options)
+      end
+
+      # @return [Vk::Album]
+      def get_album(owner_id, album_id, options = {})
+        options[:album_ids] = album_id
+        get_albums(owner_id, options).all.first
+      end
+
+      # @return [Vk::Result<Vk::Photo>]
+      def get_photos(owner_id, album_id, options = {})
+        options[:owner_id] = owner_id
+        options[:album_id] = album_id
+        require 'vk/photo'
+        Vk::Result.new('photos.get', Vk::Photo, options)
+      end
+    end
+  end
+end

data/lib/vk/dsl/users.rb

@@ -0,0 +1,34 @@
+require 'vk/exceptions'
+require 'active_support/core_ext/array/wrap'
+
+module Vk
+  module DSL
+    module Users
+      # Have user installed app?
+      # @param  [String] user_id user’s identifier
+      # @return [Boolean] does user installed app
+      def app_user?(user_id)
+        request('users.isAppUser', user_id: user_id) == '1'
+      end
+
+      def get_users(user_ids, options = {})
+        options[:user_ids] = Array.wrap(user_ids).join(',')
+        (request('users.get', options) || []).map do |user|
+          Vk::User.new(user)
+        end
+      end
+
+      # @param [String] user_id
+      # @param [Hash] options
+      # @return [Vk::User]
+      def get_user(user_id, options = {})
+        get_users(user_id, options).first
+      end
+
+      # @return [Vk::User]
+      def get_me
+        @me ||= Vk::User.new(request('users.get').first)
+      end
+    end
+  end
+end

data/lib/vk/dsl/wall.rb

@@ -0,0 +1,24 @@
+require 'vk/exceptions'
+
+module Vk
+  module DSL
+    module Wall
+      # Statuses from user’s wall
+      # @param [Fixnum] user_id user identifier
+      # @param [Hash] options
+      # @option options [Fixnum] :count how many statuses to request
+      # @option options [Fixnum] :offset offset of statuses to request
+      # @option options [:owner, :others, :all] :filter (:all) what kind of statuses to request
+      # @return [Array<Fixnum, *Hash>] count of statuses and each status in hash
+      def get_wall(user_id, options = {})
+        options[:filter] ||= :all
+        options[:owner_id] = user_id
+        Vk::Result.new('groups.get', Vk::Post, options)
+      end
+
+      def get_wall_statuses(posts)
+        request('wall.getById', posts: posts)
+      end
+    end
+  end
+end

data/lib/vk/error.rb

@@ -0,0 +1,18 @@
+# coding: utf-8
+require 'vk'
+
+module Vk
+  # Class for requesting vk.com api data
+  # @author Alexander Semyonov
+  class Error < StandardError
+    def initialize(msg, details = {})
+      if msg.is_a?(Hash)
+        details, msg = msg, msg['error']['error_msg']
+      end
+      super(msg)
+      @details = details
+    end
+
+    attr_reader :details
+  end
+end

data/lib/vk/exceptions.rb

@@ -0,0 +1,10 @@
+module Vk
+  class Error < StandardError
+  end
+
+  class TooMuchArguments < Error
+    def initialize(method, argument, count)
+      super("Argument #{argument.inspect} of method #{method.inspect} cannot contain more than #{count} values")
+    end
+  end
+end

data/lib/vk/group.rb

@@ -0,0 +1,47 @@
+require 'vk/base'
+
+module Vk
+  class Group < Base
+    self.fields = [
+      :id, :name, :screen_name, :is_closed, :type, :is_admin, :admin_level, :is_member,
+      :photo_50, :photo_100, :photo_200,
+      :city, :country, :place,  :description, :wiki_page, :members_count, :counters,
+      :start_date, :finish_date, :can_post, :can_see_all_posts, :activity, :status,
+      :contacts, :links, :fixed_post, :verified, :site
+    ]
+
+    def to_s
+      name
+    end
+
+    # @return [Time]
+    def start_at
+      Time.at(start_date) if start_date
+    end
+
+    # @return [Time]
+    def finish_at
+      Time.at(finish_date) if finish_date
+    end
+
+    # @return [Vk::Album]
+    def albums
+      @albums ||= loader.get_albums("-#{id}").all
+    end
+
+    # @return [Vk::Audio::Album]
+    def audio_albums
+      @audio_albums ||= loader.get_audio_albums("-#{id}").all
+    end
+
+    def get_wall(options = {})
+      loader.get_wall("-#{id}", options)
+    end
+
+    protected
+
+    def load_data(options = {fields: self.class.fields})
+      @attributes = @attributes.merge(loader.get_group_by_id(id, options)) unless @attributes.size > 1
+    end
+  end
+end

data/lib/vk/photo.rb

@@ -0,0 +1,38 @@
+require 'vk/base'
+
+module Vk
+  class Photo < Base
+    self.fields = [
+      :id, :album_id, :owner_id, :user_id, :photo_75, :photo_130, :photo_604, :photo_807, :photo_1280, :photo_2560,
+      :width, :height, :text, :date
+    ]
+
+    def uploaded_at
+      @uploaded_at ||= Time.at(read_attribute(:date))
+    end
+
+    def to_s
+      text.to_s
+    end
+
+    # @return [75, 130, 604, 807, 1280, 2560] maximum available picture size
+    def max_photo_size
+      @max_photo_size ||=
+        attributes.keys.grep(/photo_/).inject(75) do |maximum, size|
+          real_size = size.to_s.gsub(/\Aphoto_/, '').to_i
+          real_size > maximum ? real_size : maximum
+        end
+    end
+
+    # @return [String] url to photo with maximum available size
+    def max_photo
+      public_send("photo_#{max_photo_size}")
+    end
+
+    protected
+
+    def load_data(options = {})
+      @attributes = @attributes.merge(loader.get_group_by_id(id, options)) unless @attributes.size > 1
+    end
+  end
+end

data/lib/vk/post.rb

@@ -36,34 +36,28 @@ module Vk
     end
 
     def post_id
-      "#{to_id}_#{id}"
+      @post_id ||= "#{to_id}_#{id}"
     end
-    memoize :post_id
 
     def to
-      Vk::User.find(read_attribute(:to_id))
+      @to ||= Vk::User.find(read_attribute(:to_id))
     end
-    memoize :to
 
     def from
-      Vk::User.find(read_attribute(:from_id))
+      @from ||= Vk::User.find(read_attribute(:from_id))
     end
-    memoize :from
 
     def date
-      Time.at(read_attribute(:date))
+      @date ||= Time.at(read_attribute(:date))
     end
-    memoize :date
 
     def copy_owner
-      Vk::User.find(read_attribute(:copy_owner_id))
+      @copy_owner ||= Vk::User.find(read_attribute(:copy_owner_id))
     end
-    memoize :copy_owner
 
     def copy_post
-      Vk::Post.find(read_attribute(:copy_owner_id))
+      @copy_post ||= Vk::Post.find(read_attribute(:copy_owner_id))
     end
-    memoize :copy_post
 
     def comments_count
       read_attribute(:comments)['count']