yandex-api-direct 0.0.1

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/Gemfile

@@ -0,0 +1,20 @@
+source "http://rubygems.org"
+
+#Oauth Doorman for getting access to oauth 2
+gem "oauth_doorman", :git => "https://github.com/Ataxo/oauth_doorman.git"
+gem "activesupport"
+gem "hashr"
+
+group :development do
+  gem 'shoulda-context'
+  gem "mocha"
+  gem "turn"
+  gem "sdoc" # sdoc -N .
+  gem "bundler"
+  gem "jeweler"
+  gem "ansi"
+  gem "simplecov"
+  gem "sinatra"
+  gem 'colorize'
+  gem "webmock"
+end

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Ondrej Bartas
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.markdown

@@ -0,0 +1,163 @@
+# Yandex-API-Direct
+
+Accessing Yandex API and work with campaigns and statistics
+
+## Instalation
+
+Just in console
+
+``` ruby
+gem install yandex-api-direct
+```
+
+Or put into Gemfile
+
+``` ruby
+gem "yandex-api-direct"
+```
+
+and somewhere before use (not rails - they will require gem automaticaly)
+``` ruby
+require "yandex-api-direct"
+```
+
+## Initialization
+
+Setup your config values by calling YandexApiDirect.config = {}
+
+``` ruby
+YandexApiDirect.config = {
+  locale: "en"
+  application_id: "YOUR APPLICATION ID"
+  login: "FILL LOGIN OF USER"
+  access_token: "FILL ACCESS TOKEN FOR USER"
+}
+```
+
+Get application_id by registering your application at https://oauth.yandex.com/client/new
+(full doc at: http://api.yandex.com/oauth/doc/dg/tasks/register-client.xml)
+
+If you need to get Oauth token you will also need application password (also listed on registration page).
+
+## Working with Gem
+
+You can access Main classes: Client, Campaign, CampaignParam, CampaignStats
+
+### How one class works
+
+Main classes are inherited from [Hashr](https://github.com/svenfuchs/hashr) and includes [YandexObject](https://github.com/Ataxo/yandex-api-direct/blob/master/lib/yandex-api-direct/yandex_object.rb)
+This combination will provide very easy acces to all returned values from API.
+
+``` ruby
+# Find some objects:
+campaigns = YandexApiDirect::Campaign.find
+# you got [ <Campaign:..>, ... ] and choose first one
+campaign = campaigns.first
+# then you can ask for something
+campaign.name #=> "Campaign"
+campaign.campaign_id #=> 123456
+campaign.clicks #=> 123
+```
+
+Arguments from api is hash, this hash is saved by hashr directly into instance.
+Keys from API are underscored for using as normal methods not `campaign.Name` instead of this use: `campaign.name`
+**Instance is still Hash, you can do all stuf like with normal hash.**
+
+### Find
+``` ruby
+#you can pass arguments to find as hash: [GetClientsList](http://api.yandex.com/direct/doc/reference/GetClientsList.xml)
+YandexApiDirect::Client.find
+#=> [ <Client:..>, ... ]
+
+#you can pass argument as array of logins (optional for agencies): [GetCampaignsList](http://api.yandex.com/direct/doc/reference/GetCampaignsList.xml)
+YandexApiDirect::Campaign.find
+#=> [ <Campaign:..>, ... ]
+
+#you can pass arguments to find as hash: [GetCampaignParams](http://api.yandex.com/direct/doc/reference/GetCampaignParams.xml)
+YandexApiDirect::CampaignParams.find
+#=> [ <CampaignParams:..>, ... ]
+
+#you can pass arguments to find as hash: [GetSummaryStat](http://api.yandex.com/direct/doc/reference/GetSummaryStat.xml)
+YandexApiDirect::CampaignStats.find
+#=> [ <CampaignStats:..>, ... ]
+```
+
+### Arguments for methods
+
+All arguments you will pass into params are automatically camelized, because Yandex API takes only Camelcased attribute names:
+``` ruby
+# Example: 
+campaign.campaign_stats start_date: Date.today
+# will transform inside of method into
+{ :"StartDate" => Date.today }
+```
+If you will implement your own methods, you can use built in method in YandexObject `camelize_keys(hash)`
+
+### Hierarchy
+
+Yandex uses this hierarchy and gem follows it
+* Client
+ * Campaign
+  * CampaignParams
+  * CampaignStats
+
+``` ruby
+#get first Client
+client = Client.find.first
+
+#get all client campaign
+campaigns = client.campaigns
+
+campaign = campaigns.first
+
+#get campaign statistics
+campaign.campaign_stats start_date: Date.today-8, end_date: Date.today-1
+#=> [<CampaingStats:..>, ...]
+#get campaign params
+campaign.campaign_params
+#=> <CampaingParams:... > - not array but directly one object (campaign can have only one params!)
+```
+
+### Flexibility
+
+There is a class YandexApiDirect::Generic which provides class method get 
+has two parameters 
+* method name - underscored
+* args (optional) - should be hash or array
+
+``` ruby
+YandexApiDirect::Generic.get "get_clients_info"
+#=> will return hash containing client info (Only one item returned)
+
+YandexApiDirect::Generic.get "get_clients_list"
+#=> will return array containing hashes of client info (More items returned)
+``` 
+By this you can call all methods without writing more code.
+
+## Sandbox/Production enviroments
+
+Yandex api allows you to use sandbox for testing purposes: [Yandex Sandbox](http://api.yandex.com/direct/doc/concepts/sandbox.xml)
+
+In your test helper write down
+``` ruby
+YandexApiDirect.url "sandbox" #or if you like symbols :sandbox  :-)
+#or for directly saying to use production
+YandexApiDirect.url "production" #or if you like symbols :production  :-)
+```
+This will set url of Yandex to sandbox or production.
+If you will not set url it will use ENV['RACK_ENV'] or ENV['RAILS_ENV'] == "test" it will use "sandbox" as default, all other environments (including development) will have sa default setted "production"
+
+## Contributing to redis-model-extension
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet.
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it.
+* Fork the project.
+* Start a feature/bugfix branch.
+* Commit and push until you are happy with your contribution.
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+## Copyright
+
+Copyright (c) 2012 Ondrej Bartas. See LICENSE.txt for
+further details.

data/Rakefile

@@ -0,0 +1,35 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "yandex-api-direct"
+  gem.homepage = "http://github.com/Ataxo/yandex-api-direct"
+  gem.license = "MIT"
+  gem.summary = %Q{Accessing Yandex Direct API and work with campaigns and statistics}
+  gem.description = %Q{Use JSON api on Yandex api side and automatically manages access token refresh}
+  gem.email = "ondrej@bartas.cz"
+  gem.authors = ["Ondrej Bartas"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+task :default => :test

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/lib/yandex-api-direct.rb

@@ -0,0 +1,69 @@
+# encoding: utf-8
+
+require 'active_support/inflector'
+require 'active_support/inflector/inflections'
+require 'active_support/core_ext/hash/keys'
+require 'hashr'
+
+module YandexApiDirect
+
+  URLS = {
+    production: "https://soap.direct.yandex.ru/json-api/v4/", #production url
+    sandbox: "https://api-sandbox.direct.yandex.ru/json-api/v4/" #sandbox url
+  }
+  # Return current environment
+  # Uses RACK_ENV and RAILS_ENV - if not set any default is used "development"
+  def self.env
+    ["test"].include?(ENV['RACK_ENV'] || ENV['RAILS_ENV'] || "development") ? :sandbox : :production
+  end
+
+  # Get URL for all requests to Yandex api
+  # * without parameter - Choose url by ENV
+  # * with parameter 
+  # * * "test" - choose sandbox
+  # * * other - choose production
+  def self.url environment = nil
+    if environment
+      @url = URLS[environment.to_sym]
+    elsif @url
+      @url
+    else
+      @url = URLS[env]
+    end
+  end
+
+  # default config for Yandex API
+  # * locale (language of api response)
+  # * * "uk" - Ukraine
+  # * * "ru" - Russian
+  # * * "en" - English
+  def self.default_config
+    { 
+      locale: "uk",
+      application_id: "",
+      login: "",
+      access_token: "",
+    }
+  end
+
+  @config = default_config
+
+  # Set config values
+  def self.config= conf
+    @config = default_config.merge!(conf)
+  end
+
+  # Get config for requset params build
+  def self.config
+    @config
+  end
+end
+
+#require yandex objects
+require 'yandex-api-direct/yandex_object'
+require 'yandex-api-direct/yandex_objects/generic'
+require 'yandex-api-direct/yandex_objects/client'
+require 'yandex-api-direct/yandex_objects/campaign'
+require 'yandex-api-direct/yandex_objects/campaign_param'
+require 'yandex-api-direct/yandex_objects/campaign_stats'
+

data/lib/yandex-api-direct/yandex_object.rb

@@ -0,0 +1,131 @@
+# encoding: utf-8
+require 'net/http'
+require 'json'
+require 'active_support'
+
+module YandexApiDirect
+
+  # Problem with connection
+  class YandexConnectionError < Exception; end
+  # Problem with request params
+  class YandexMethodError < Exception; end
+  # generic error
+  class YandexError < Exception; end
+  # Problem with authorization
+  class YandexAuthorizationError < Exception; end
+  
+  # Globalize all same functions into one module
+  # This will enable easier implementation
+  # of Yandex objects
+  module YandexObject
+    extend ActiveSupport::Concern
+
+    #include methods into class
+    included do
+      include YandexObjectInstance
+      include YandexObjectCallMethod
+      extend YandexObjectCallMethod
+      extend YandexObjectClass
+    end
+
+    # Class methods for Yandex objects
+    module YandexObjectClass
+
+    end
+
+    # Instance methods for Yandex objects
+    module YandexObjectInstance
+      
+      # Change Camelized keys of hash to underscored keys
+      def underscore_keys(hash)
+        return nil unless hash
+        hash.inject({}){|result, (key, value)|
+          new_key = key.to_s.underscore.to_sym
+          new_value = case value
+                      when Hash then underscore_keys(value)
+                      else value
+                      end
+          result[new_key] = new_value
+          result
+        }
+      end
+
+      #fix input arguments
+      def initialize args = {}
+        super underscore_keys(args)
+      end
+    end
+
+    # Call method to Yandex API
+    module YandexObjectCallMethod
+      #Call method perform call to yandex api
+      # * method name (string|symbol) - method name defined by yandex api
+      # * param (optional) - params defined by yandex api
+      def call_method method_name, param = nil
+        payload = {
+          method: method_name.camelize,
+          locale: YandexApiDirect.config[:locale],
+          login: YandexApiDirect.config[:login],
+          application_id: YandexApiDirect.config[:application_id],
+          token: YandexApiDirect.config[:access_token],
+        }
+        payload[:param] = param if param
+
+        # get url
+        url = URI.parse(YandexApiDirect.url)
+
+        # set new post request with JSON content type
+        request = Net::HTTP::Post.new(url.path, initheader = {'Content-Type' =>'application/json'})
+
+        # set payload to post body
+        request.body = payload.to_json
+
+        # create new connection to yandex
+        http = Net::HTTP.new(url.host, url.port)
+
+        # set use SSL 
+        http.use_ssl = true
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+
+        # send request 
+        response = http.request(request)
+
+        # no problem with connection
+        if response.code.to_i == 200
+          #parse respose JSON body into hash
+          resp = JSON.parse(response.body).symbolize_keys
+
+          # if there is no error_code
+          unless resp.has_key?(:error_code)
+            return resp
+          else # error code
+            case resp[:error_code]
+            when 53 then raise YandexAuthorizationError, "Got error from Yandex API, error code: #{resp[:error_code]} | #{resp[:error_str]} (#{resp[:error_detail]})"
+            when 55 then raise YandexMethodError, "Got error from Yandex API, error code: #{resp[:error_code]} | #{resp[:error_str]} (#{resp[:error_detail]})"
+            else raise YandexError, "Got error from Yandex API, error code: #{resp[:error_code]} | #{resp[:error_str]} (#{resp[:error_detail]})"
+            end
+          end
+        else
+          # Request responce is not valid (errors: 404, 500, etc.)
+          raise YandexConnectionError, "Problem with connection to Yandex API, status code: #{response.code} \n content body: #{response.body}"
+        end
+      end
+
+      # Change Camelized keys of hash to camelized keys
+      def camelize_keys(hash)
+        return nil unless hash
+        return hash if hash.is_a?(Array)
+        hash.inject({}){|result, (key, value)|
+          new_key = key.to_s.camelize.gsub(/(Ids|Id|Fio)/) { |r| r.upcase }.to_sym
+          new_value = case value
+                      when Hash then camelize_keys(value)
+                      else value
+                      end
+          result[new_key] = new_value
+          result
+        }
+      end
+    end
+
+  end
+end