vk 0.0.4 → 0.6.5.53

data/lib/vk/city.rb

@@ -2,17 +2,27 @@ require 'vk/base'
 
 module Vk
   class City < Base
-    self.key_field = :cid
-    self.fields = [:cid, :name]
+    self.fields = [:id, :title, :important, :country_id, :region_id, :region, :area]
 
+    # @return [Vk::Country, nil]
+    def country
+      @country ||= Vk::Country.find(country_id) if country_id
+    end
+
+    # @return [Vk::Region, nil]
+    def region
+      @region ||= Vk::Region.find(region_id) if region_id
+    end
+
+    # @return [String]
     def to_s
-      name
+      title.to_s
     end
 
     protected
 
     def load_data(options = {})
-      @attributes = @attributes.merge(loader.get_city(id))
+      @attributes = @attributes.merge(loader.get_city_by_id(id)) if id
     end
   end
 end

data/lib/vk/client.rb

@@ -0,0 +1,104 @@
+# coding: utf-8
+require 'vk'
+require 'vk/prompt'
+
+require 'digest/md5'
+require 'uri'
+require 'net/http'
+
+require 'active_support/core_ext/object/to_query'
+require 'active_support/core_ext/object/blank'
+require 'json'
+
+module Vk
+  # Class for requesting vk.com api data
+  # @author Alexander Semyonov
+  class Client
+    include Vk::PromptExtension
+
+    SCHEME = 'https'
+    HOST = 'api.vk.com'
+    PATH = '/method/'
+    PORT = 443
+
+    # Generates auth_key for viewer
+    # @param [Fixnum, String] viewer_id viewer’s identifier
+    def self.auth_key(viewer_id)
+      Digest::MD5.hexdigest("#{Vk.app_id}_#{viewer_id}_#{Vk.app_secret}")
+    end
+
+    def self.authenticated?(viewer_id, auth_key)
+      auth_key == self.auth_key(viewer_id)
+    end
+
+    def self.dsl!
+      require 'vk/dsl'
+      include Vk::DSL
+    end
+
+    # @return [Vk::Client]
+    def self.authenticated!
+      require 'vk/access'
+      return new(ENV['VK_ACCESS_TOKEN']) if ENV['VK_ACCESS_TOKEN']
+      require 'oauth2'
+      token = oauth_client.get_access_token # => OAuth2::AccessToken
+      fail 'No token discovered' unless token.try(:token)
+      prompt.say 'Please run following command now to prevent asking for codes again:'
+      prompt.say
+      prompt.say "    export VK_ACCESS_TOKEN=#{token.token}"
+      prompt.say
+      Vk.client.access_token ||= token.token
+      ENV['VK_ACCESS_TOKEN'] ||= token.token
+      Vk.client
+    end
+
+    # @return [OAuth2::Client]
+    def self.oauth_client
+      require 'vk/client/oauth2'
+      @oauth_client ||= Vk::Client::OAuth2.new
+    end
+
+    # @param [#to_s] access_token
+    def initialize(access_token = ENV['VK_ACCESS_TOKEN'])
+      @access_token = access_token.to_s
+    end
+
+    def dsl!
+      self.class.dsl!
+      self
+    end
+
+    # @return [String]
+    attr_accessor :access_token
+
+    def request(method_name, data = {})
+      data = data.merge(app_id: Vk.app_id, v: Vk::VK_API)
+      data = data.merge(access_token: access_token) if access_token.present?
+      Vk.logger.info("vk.#{method_name}(#{data.inspect})")
+      http_response = Net::HTTP.post_form(url_for_method(method_name), data).body
+      return unless http_response.present?
+      json_response = JSON.parse(http_response)
+      if json_response['error']
+        Vk.logger.error(json_response['error']['error_msg'])
+        Vk.logger.debug(json_response)
+        raise Vk::Error.new(json_response)
+      end
+      Vk.logger.debug(json_response)
+      json_response['response']
+    end
+
+    # @param [URL::HTTP] method_name
+    def url_for_method(method_name)
+      URI.parse("#{SCHEME}://#{HOST}:#{PORT}#{PATH}#{method_name}")
+    end
+
+    private
+
+    def signature(data)
+      signature = data.keys.sort.inject('') do |result, key|
+        result << "#{key}=#{data[key]}"
+      end << Vk.app_secret
+      Digest::MD5.hexdigest(signature)
+    end
+  end
+end

data/lib/vk/client/oauth2.rb

@@ -0,0 +1,43 @@
+require 'vk'
+require 'vk/prompt'
+require 'oauth2'
+
+module Vk
+  class Client
+    class OAuth2 < ::OAuth2::Client
+      DEFAULT_OAUTH_OPTIONS = {
+        site: 'https://api.vk.com',
+        authorize_url: 'https://oauth.vk.com/authorize',
+        token_url: 'https://oauth.vk.com/access_token'
+      }
+
+      include Vk::PromptExtension
+
+      def initialize(app_id = Vk.app_id, app_secret = Vk.app_secret, options = DEFAULT_OAUTH_OPTIONS)
+        super(app_id, app_secret, options)
+      end
+
+      # @return [String]
+      def get_auth_code
+        url = auth_code.authorize_url(
+          redirect_uri: 'https://oauth.vk.com/blank.html',
+          display: 'page',
+          scope: Vk::Access::SCOPES.values.inject(0, :+)
+        )
+        prompt.say 'Open a link and allow access:'
+        prompt.say
+        prompt.say "    #{url}"
+        prompt.say
+        prompt.ask('Enter the code from the address of the opened page:')
+      end
+
+      # @return [OAuth2::AccessToken]
+      def get_access_token
+        auth_code.get_token(
+          get_auth_code,
+          redirect_uri: 'https://oauth.vk.com/blank.html'
+        )
+      end
+    end
+  end
+end

data/lib/vk/country.rb

@@ -2,17 +2,22 @@ require 'vk/base'
 
 module Vk
   class Country < Base
-    self.key_field = :cid
-    self.fields = [:cid, :name]
+    self.fields = [:id, :title]
 
+    # @return [<Vk::Region>]
+    def regions
+      @regions ||= loader.get_regions(id).all
+    end
+
+    # @return [String]
     def to_s
-      name
+      title.to_s
     end
 
     protected
 
     def load_data(options = {})
-      @attributes = @attributes.merge(loader.get_country(id))
+      @attributes = @attributes.merge(loader.get_country_by_id(id))
     end
   end
 end

data/lib/vk/dsl.rb

@@ -3,93 +3,25 @@ require 'vk'
 
 module Vk
   module DSL
-    # Have user installed app?
-    # @param  [String] uid user’s identifier
-    # @return [Boolean]             does user installed app
-    def app_user?(uid)
-      request('isAppUser', uid: uid) == '1'
-    end
-
-    # Profile information for provided uids or domain names
-    # @param [Array<String>] uids array of users’ identifiers in numbers or domain names
-    # @param [Hash] options the options to request profile information
-    # @option options [:uid, :first_name, :last_name, :nickname, :domain, :sex, :bdate, :birthdate, :city, :country, :timezone, :photo, :photo_medium, :photo_big, :has_mobile, :rate, :contacts, :education, :online] :fields ([:uid, :first_name, :last_name]) profile fields to requests
-    # @option options [:nom, :gen, :dat, :acc, :ins, :abl] :name_case (:nom) case of returned names
-    # @return [Array<Hash>] array of user profile data
-    def get_profiles(uids, options = {})
-      uids = Array(uids)
-      if uids.first.to_i == 0
-        options[:domains] = uids.join ','
-      else
-        options[:uids]    = uids.join ','
-      end
-      options[:fields] = Array(options[:fields]).join(',') if options.key?(:fields)
-      request('getProfiles', options)
-    end
-
-    def get_profile(uid, options = {})
-      get_profiles(uid, options)[0]
-    end
-
-    ## Identifiers of groups in which user participates
-    ## @param [Integer] uid user’s identifier
-    ## @return [Array] array of group identifiers
-    #def get_groups(uid)
-      #request('getGroups', uid: uid)
-    #end
-
-    # Cities’ names
-    # @param [Array<Fixnum>, Fixnum] cids cities identifiers
-    # @return [Array<Hash>] hash with city identifier and it’s name
-    def get_cities(cids)
-      cids = Array(cids).join(',')
-      request('getCities', cids: cids)
-    end
-
-    def get_city(cid)
-      get_cities(cid)[0]
-    end
-
-    # Countries’ names
-    # @param [Array<Fixnum>, Fixnum] cids cities identifiers
-    # @return [Array<Hash>] hash with city identifier and it’s name
-    def get_countries(cids)
-      cids = Array(cids).join(',')
-      request('getCountries', cids: cids)
-    end
-
-    def get_country(cid)
-      get_countries(cid)[0]
-    end
-
-    # Friends information
-    # @param [Fixnum] uid user identifier
-    # @param [Hash] options
-    # @option options [Array<String>] :fields ([:uid, :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
-    def get_friends(uid, options = {})
-      request('friends.get', options.merge(uid: uid))
-    end
-
-    # Statuses from user’s wall
-    # @param [Fixnum] uid 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(uid, options = {})
-      options[:filter] ||= :all
-      request('wall.get', options.merge(owner_id: uid))
-    end
-
-    def get_wall_statuses(posts)
-      request('wall.getById', posts: posts)
-    end
-
-    def get_wall_status(id)
-      get_wall_statuses(id)[0]
-    end
   end
 end
+
+require 'vk/dsl/audio'
+require 'vk/dsl/database'
+require 'vk/dsl/friends'
+require 'vk/dsl/groups'
+require 'vk/dsl/wall'
+require 'vk/dsl/photos'
+require 'vk/dsl/newsfeed'
+require 'vk/dsl/users'
+
+module Vk::DSL
+  include Audio
+  include Database
+  include Friends
+  include Groups
+  include Wall
+  include Photos
+  include Newsfeed
+  include Users
+end

data/lib/vk/dsl/audio.rb

@@ -0,0 +1,51 @@
+require 'vk/exceptions'
+require 'vk/audio'
+
+module Vk
+  module DSL
+    module Audio
+      AUDIO_SORT = {
+        popularity: 2,
+        duration: 1,
+        date: 0
+      }
+
+      # @param [Integer] owner_id user’s identifier
+      # @param [Hash] options
+      # @option options [Fixnum] :offset
+      # @option options [Fixnum] :count
+      def get_audios(owner_id, options = {})
+        fail NotImplementedError, ':need_user is not supported for audio.get method' if options.key?(:need_user)
+        Vk::Result.new('audio.get', Vk::Audio, options.merge(owner_id: owner_id))
+      end
+
+      # @param [Integer] owner_id user’s identifier
+      # @param [Hash] options
+      # @option options [Fixnum] :offset
+      # @option options [Fixnum] :count
+      def get_audio_albums(owner_id, options = {})
+        Vk::Result.new('audio.getAlbums', Vk::Audio::Album, options.merge(owner_id: owner_id))
+      end
+
+      # @param [Fixnum] lyrics_id
+      # @return [Vk::Audio::Lyrics]
+      def get_lyrics(lyrics_id)
+        Vk::Audio::Lyrics.new(request('audio.getLyrics', {lyrics_id: lyrics_id}))
+      end
+
+      # @param [String] q
+      # @param [Hash] options
+      # @option options [Fixnum] :offset
+      # @option options [Fixnum] :count
+      # @option options [Fixnum] :auto_complete
+      def search_lyrics(q, options = {})
+        options[:auto_complete] = !!options[:auto_complete] ? 1 : 0 if options.key?(:auto_complete)
+        options[:lyrics] = !!options[:lyrics] ? 1 : 0 if options.key?(:lyrics)
+        options[:performer_only] = !!options[:performer_only] ? 1 : 0 if options.key?(:performer_only)
+        options[:sort] = AUDIO_SORT[options[:sort]] if options[:sort].is_a?(Symbol)
+        options[:search_own] = !!options[:search_own] ? 1 : 0 if options.key?(:search_own)
+        Vk::Result.new('audio.search', Vk::Audio, options.merge(q: q))
+      end
+    end
+  end
+end

data/lib/vk/dsl/database.rb

@@ -0,0 +1,108 @@
+require 'vk/exceptions'
+
+module Vk
+  module DSL
+    module Database
+      # @param [Hash] options
+      # @option options :need_all [Boolean, 1] load all countries
+      # @option options :code [<String>] country codes to load
+      # @option options :offset [Fixnum] offset for loaded countries
+      # @option options :count [Fixnum] (100) amount of countries to load
+      def get_countries(options = {})
+        options[:need_all] = 1 if options[:need_all]
+        options[:code] = options[:code].join(',') if options[:code]
+        Vk::Result.new('database.getCountries', Vk::Country, options)
+      end
+
+      # Countries’ names
+      # @param [Array<Fixnum>, Fixnum] country_ids cities identifiers
+      # @return [Array<Vk::Country>] array of Vk::Country
+      def get_countries_by_id(country_ids)
+        require 'vk/country'
+        country_ids = Array(country_ids)
+        raise Vk::TooMuchArguments.new('database.getCountriesById', 'country_ids', 1000) if country_ids > 1000
+        request('database.getCountriesById', country_ids: country_ids.join(',')).map do |country|
+          Vk::Country.new(country)
+        end
+      end
+
+      # @param [String] country_id
+      # @return [Vk::Country]
+      def get_country_by_id(country_id)
+        get_countries_by_id(country_id).first
+      end
+
+      alias get_country get_country_by_id
+
+      # @param [Hash] options
+      # @option options :country_id [<String>] required attribute. Country identifier
+      # @option options :q [String] search query
+      # @option options :offset [Fixnum] offset for loaded countries
+      # @option options :count [Fixnum] (100) amount of countries to load
+      # @return [Vk::Result<Vk::Region>]
+      def get_regions(country_id, options = {})
+        if country_id.is_a?(:hash)
+          country_id = options.delete(:country_id) do
+            raise 'No country_id attribute given for database.getRegions'
+          end
+        end
+        require 'vk/region'
+        options[:code] = options[:code].join(',') if options[:code]
+        Vk::Result.new('database.getRegions', Vk::Region, options, country_id: country_id)
+      end
+
+      # Countries’ names
+      # @param [Array<Fixnum>, Fixnum] street_ids cities identifiers
+      # @return [Array<Vk::Country>] array of Vk::Country
+      def get_streets_by_id(street_ids)
+        require 'vk/street'
+        street_ids = Array(street_ids)
+        raise Vk::TooMuchArguments.new('database.getCountriesById', 'street_ids', 1000) if street_ids > 1000
+        request('database.getCountriesById', street_ids: street_ids.join(',')).map do |street|
+          Vk::Street.new(street)
+        end
+      end
+
+      # @param [Fixnum] street_id
+      def get_street_by_id(street_id)
+        get_streets_by_id(street_id).first
+      end
+
+      alias get_street get_street_by_id
+
+      # Cities’ names
+      # @param [Array<Fixnum>, Fixnum] city_ids cities identifiers
+      # @return [Array<Hash>] hash with city identifier and it’s name
+      def get_cities_by_id(city_ids)
+        require 'vk/city'
+        city_ids = Array(city_ids)
+        raise Vk::TooMuchArguments.new('database.getCitiesById', 'city_ids', 1000) if city_ids > 1000
+        request('database.getCitiesById', city_ids: city_ids.join(',')).map do |city|
+          Vk::City.new(city)
+        end
+      end
+
+      # @return [Vk::City]
+      def get_city_by_id(cid)
+        get_cities_by_id(cid).first
+      end
+
+      alias get_city get_city_by_id
+
+      # @param [Hash] options
+      # @option options :country_id [<String>] required attribute. Country identifier
+      # @option options :region_id [<String>] optional attribute. Region identifier
+      # @option options :q [String] search query
+      # @option options :offset [Fixnum] offset for loaded countries
+      # @option options :count [Fixnum] (100) amount of countries to load
+      def get_cities(options = {})
+        require 'vk/city'
+        raise 'No country_id attribute given for database.getRegions' unless options[:country_id]
+        options[:code] = options[:code].join(',') if options[:code]
+        Vk::Result.new('database.getCities', Vk::City, options,
+                       country_id: options[:country_id],
+                       region_id: options[:region_id])
+      end
+    end
+  end
+end