sift 2.0.0.0 → 2.1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5116181929ffbab6a17941eb341a852a7c4c75c6
-  data.tar.gz: 4699c62cdadc3fd2f9123b929925abcf45cfb19b
+  metadata.gz: 48d2e914b4876ebfd0d5ec6d14c53149342e807c
+  data.tar.gz: d608b5808f89566020a2d115cc71f34232986f0f
 SHA512:
-  metadata.gz: 5d228bd45520217fe3e06a0e2673e4a176b497ff83fc5f73940a6e656006b7725521597fb263d64cc133020162400562380b30aee1f29c9a3bde91ce080e03a3
-  data.tar.gz: bce89304cbf0eb1c963e05c9ec76248ba5e06d9c0829df983735dfaf5828288faf8e73fd3c81a53876ee39081cf3695364a929775ffdb5665caa99fc4dc6f957
+  metadata.gz: 6933162c8d8e2f9e61ddb84128f7cc69dd32c00c1dec5f1413c256778718cfda82f59d47ba5d9ddd8783629f7444bc36b10c19966652358bd7499a889ea38a32
+  data.tar.gz: 8ff5d3999392b1a5308344d198f02af3bd70df507021175fff59de52941ec6ae50a03dc5bce8a17cbe8f95ee6d65db57f60e4d443b6dcbc83590586b6d8b3f6d

data/README.md

@@ -0,0 +1,225 @@
+# Sift Science Ruby bindings [![Build Status](https://travis-ci.org/SiftScience/sift-ruby.png?branch=master)](https://travis-ci.org/SiftScience/sift-ruby)
+
+## Requirements
+
+  * Ruby 1.9.3 or above.
+
+
+## Installation
+
+If you want to build the gem from source:
+
+```
+$ gem build sift.gemspec
+```
+
+Alternatively, you can install the gem from rubygems.org:
+
+```
+gem install sift
+```
+
+## Usage
+
+### Creating a Client:
+
+```ruby
+require "sift"
+
+Sift.api_key = '<your_api_key_here>'
+Sift.account_id = '<your_account_id_here>'
+client = Sift::Client.new()
+
+##### OR
+
+client = Sift::Cient.new(api_key: '<your_api_key_here>', account_id: '<your_account_id_here>'
+
+```
+
+### Sending a transaction event
+
+```ruby
+event = "$transaction"
+
+user_id = "23056"  # User ID's may only contain a-z, A-Z, 0-9, =, ., -, _, +, @, :, &, ^, %, !, $
+
+properties = {
+ "$user_id" => user_id,
+  "$user_email" => "buyer@gmail.com",
+  "$seller_user_id" => "2371",
+  "seller_user_email" => "seller@gmail.com",
+  "$transaction_id" => "573050",
+  "$payment_method" => {
+    "$payment_type"    => "$credit_card",
+    "$payment_gateway" => "$braintree",
+    "$card_bin"        => "542486",
+    "$card_last4"      => "4444"
+  },
+  "$currency_code" => "USD",
+  "$amount" => 15230000,
+}
+
+response = client.track(event, properties)
+
+response.ok?  # returns true or false
+response.body  # API response body
+response.http_status_code  # HTTP response code, 200 is ok.
+response.api_status  # status field in the return body, Link to Error Codes
+response.api_error_message  # Error message associated with status Error Code
+
+# Request a score for the user with user_id 23056
+response = client.score(user_id)
+```
+
+## Decisions
+
+To learn more about the decisions endpoint visit our [developer docs](https://siftscience.com/developers/docs/ruby/decisions-api/get-decisions).
+
+### List of Configured Decisions
+
+Get a list of your decisions.
+
+**Optional Params**
+ - `entity_type`: `:user` or `:order`
+ - `abuse_types`: `["payment_abuse", "content_abuse", "content_abuse",
+   "account_abuse", "legacy"]`
+
+**Returns**
+
+A `Response` object
+
+**Example:**
+```ruby
+# fetch a list of all your decisions
+response = client.decisions({
+  entity_type: :user,
+  abuse_types: ["payment_abuse", "content_abuse"]
+})
+
+# Check that response is okay.
+unless response.ok?
+  raise "Unable to fetch decisions #{response.api_error_message} " +
+    "#{response.api_error_description}"
+end
+
+# find a decisions with the id "block_bad_user"
+user_decision = response.body["data"].find do |decision|
+  decision["id"] == "block_bad_user"
+end
+
+# Get the next page
+
+if response.body["has_more"]
+  client.decisions(response.body)
+end
+```
+
+
+### Apply a decision
+
+Applies a decision to an entity. Visit our [developer docs](http://siftscience.com/developers/docs/ruby/decisions-api/apply-decision) for more information.
+
+**Required Params:**
+- `decision_id`, `source`, `user_id`
+
+**Other Params**
+- `order_id`: when applying a decision to an order, you must pass in the `order_id`
+- `analyst`: when `source` is set to `manual_review`, this field *is required*
+
+**Returns**
+`Response` object.
+
+**Examples:**
+```ruby
+# apply decision to a user
+response = client.apply_decision_to({
+  decision_id: "block_bad_user",
+  source: "manual_review",
+  analyst: "bob@your_company.com",
+  user_id: "john@example.com"
+})
+
+# apply decision to "bob@example.com"'s order
+response = client.apply_decision_to({
+  decision_id: "block_bad_order",
+  source: "manual_review",
+  analyst: "bob@your_company.com",
+  user_id: "john@example.com",
+  order_id: "ORDER_1234"
+})
+
+# Make sure you handle the response after applying a decision:
+
+if response.ok?
+  # do stuff
+else
+  # Error message
+  response.api_error_message
+
+  # Summary of the error
+  response.api_error_description
+
+  # hash of errors:
+  #  key: field in question
+  #  value: description of the issue
+  response.api_error_issues
+end
+```
+
+## Sending a Label
+
+```ruby
+# Label the user with user_id 23056 as Bad with all optional fields
+response = client.label(user_id, {
+  "$is_bad" => true,
+  "$abuse_type" => "payment_abuse",
+  "$description" => "Chargeback issued",
+  "$source" => "Manual Review",
+  "$analyst" => "analyst.name@your_domain.com"
+})
+
+# Get the status of a workflow run
+response = client.get_workflow_status('my_run_id')
+
+# Get the latest decisions for a user
+response = client.get_user_decisions('example_user_id')
+
+# Get the latest decisions for an order
+response = client.get_order_decisions('example_order_id')
+```
+
+## Response Object
+
+All requests to our apis will return a `Response` instance.
+
+### Public Methods:
+- `ok?` returns `true` when the response is a `200`-`299`, `false` if it isn't
+- `body` returns a hash representation of the json body returned.
+- `api_error_message` returns a string describing the api error code.
+- `api_error_description` a summary of the error that occured.
+- `api_error_issues` a hash describing the items the error occured. The `key` is the item and the `value` is the description of the error.
+
+
+## Building
+
+Building and publishing the gem is captured by the following steps:
+
+```ruby
+$ gem build sift.gemspec
+$ gem push sift-<current version>.gem
+
+$ bundle
+$ rake -T
+$ rake build
+$ rake install
+$ rake release
+```
+
+
+## Testing
+
+To run the various tests use the rake command as follows:
+
+```ruby
+$ rake spec
+```

data/lib/sift.rb

@@ -1,5 +1,5 @@
-require "sift/version"
-require "sift/client"
+require_relative "./sift/version"
+require_relative "./sift/client"
 
 module Sift
 

data/lib/sift/client.rb

@@ -1,17 +1,22 @@
 require 'httparty'
 require 'multi_json'
 
+require_relative "./client/decision"
+require_relative "./error"
+
 module Sift
 
   # Represents the payload returned from a call through the track API
   #
   class Response
-    attr_reader :body
-    attr_reader :http_class
-    attr_reader :http_status_code
-    attr_reader :api_status
-    attr_reader :api_error_message
-    attr_reader :request
+    attr_reader :body,
+      :http_class,
+      :http_status_code,
+      :api_status,
+      :api_error_message,
+      :request,
+      :api_error_description,
+      :api_error_issues
 
     # Constructor
     #
@@ -31,7 +36,13 @@ module Sift
         @body = MultiJson.load(http_response) unless http_response.nil?
         @request = MultiJson.load(@body["request"].to_s) if @body["request"]
         @api_status = @body["status"].to_i if @body["status"]
-        @api_error_message = @body["error_message"].to_s if @body["error_message"]
+        @api_error_message = @body["error_message"]
+
+        if @body["error"]
+          @api_error_message = @body["error"]
+          @api_error_description = @body["description"]
+          @api_error_issues = @body["issues"] || {}
+        end
       end
     end
 
@@ -69,12 +80,21 @@ module Sift
   # This class wraps accesses through the API
   #
   class Client
-    API_ENDPOINT = 'https://api.siftscience.com'
-    API3_ENDPOINT = 'https://api3.siftscience.com'
+    API_ENDPOINT = ENV["SIFT_RUBY_API_URL"] || 'https://api.siftscience.com'
+    API3_ENDPOINT = ENV["SIFT_RUBY_API3_URL"] || 'https://api3.siftscience.com'
 
     include HTTParty
     base_uri API_ENDPOINT
 
+    attr_reader :api_key, :account_id
+
+    def self.build_auth_header(api_key)
+      { "Authorization" => "Basic #{Base64.encode64(api_key)}" }
+    end
+
+    def self.user_agent
+      "sift-ruby/#{VERSION}"
+    end
 
     # Constructor
     #
@@ -115,10 +135,6 @@ module Sift
       raise("path must be a non-empty string") if !@path.is_a?(String) || @path.empty?
     end
 
-    def api_key
-      @api_key
-    end
-
     def user_agent
       "SiftScience/v#{@version} sift-ruby/#{VERSION}"
     end
@@ -487,9 +503,36 @@ module Sift
       Response.new(response.body, response.code, response.response)
     end
 
+    def decisions(opts = {})
+      decision_instance.list(opts)
+    end
+
+    def decisions!(opts = {})
+      handle_response(decisions(opts))
+    end
+
+    def apply_decision(configs = {})
+      decision_instance.apply_to(configs)
+    end
+
+    def apply_decision!(configs = {})
+      handle_response(apply_decision(configs))
+    end
 
     private
 
+    def handle_response(response)
+      if response.ok?
+        response.body
+      else
+        raise ApiError.new(response.api_error_message, response)
+      end
+    end
+
+    def decision_instance
+      @decision_instance ||= Decision.new(api_key, account_id)
+    end
+
     def delete_nils(properties)
       properties.delete_if do |k, v|
         case v

data/lib/sift/client/decision.rb

@@ -0,0 +1,67 @@
+require "cgi"
+require "Base64"
+
+require_relative "../router"
+require_relative "../validate/decision"
+require_relative "../utils/hash_getter"
+require_relative "./decision/apply_to"
+
+module Sift
+  class Client
+    class Decision
+      FILTER_PARAMS = %w{ limit entity_type abuse_types from }
+
+      attr_reader :account_id, :api_key
+
+      def initialize(api_key, account_id)
+        @account_id = account_id
+        @api_key = api_key
+      end
+
+      def list(options = {})
+        getter = Utils::HashGetter.new(options)
+
+        if path = getter.get(:next_ref)
+          request_next_page(path)
+        else
+          Router.get(index_path, {
+            query: build_query(getter),
+            headers: auth_header
+          })
+        end
+      end
+
+      def build_query(getter)
+        FILTER_PARAMS.inject({}) do |result, filter|
+          if value = getter.get(filter)
+            result[filter] = value.is_a?(Array) ? value.join(",") : value
+          end
+
+          result
+        end
+      end
+
+      def apply_to(configs = {})
+        getter = Utils::HashGetter.new(configs)
+        configs[:account_id] = account_id
+
+        ApplyTo.new(api_key, getter.get(:decision_id), configs).run
+      end
+
+      def index_path
+        "#{Client::API3_ENDPOINT}/v3/accounts/#{account_id}/decisions"
+      end
+
+      private
+
+      def request_next_page(path)
+        Router.get(path, headers: auth_header)
+      end
+
+      def auth_header
+        Client.build_auth_header(api_key)
+      end
+    end
+  end
+end
+

data/lib/sift/client/decision/apply_to.rb

@@ -0,0 +1,104 @@
+require "multi_json"
+
+require_relative "../../validate/decision"
+require_relative "../../client"
+require_relative "../../router"
+require_relative "../../utils/hash_getter"
+
+module Sift
+  class Client
+    class Decision
+      class ApplyTo
+        PROPERTIES = %w{ source analyst description order_id user_id account_id }
+
+        attr_reader :decision_id, :configs, :getter, :api_key
+
+        PROPERTIES.each do |attribute|
+          class_eval %{
+            def #{attribute}
+              getter.get(:#{attribute})
+            end
+          }
+        end
+
+        def initialize(api_key, decision_id, configs)
+          @api_key = api_key
+          @decision_id = decision_id
+          @configs = configs
+          @getter = Utils::HashGetter.new(configs)
+        end
+
+        def run
+          if errors.empty?
+            send_request
+          else
+            Response.new(
+              MultiJson.dump({
+                status: 55,
+                error_message: errors.join(", ")
+              }),
+              400,
+              nil
+            )
+          end
+        end
+
+        private
+
+        def send_request
+          Router.post(path, {
+            body: request_body,
+            headers: headers
+          })
+        end
+
+        def request_body
+          {
+            source: source,
+            description: description,
+            analyst: analyst,
+            decision_id: decision_id
+          }
+        end
+
+        def errors
+          validator = Validate::Decision.new(configs)
+
+          if applying_to_order?
+            validator.valid_order?
+          else
+            validator.valid_user?
+          end
+
+          validator.error_messages
+        end
+
+        def applying_to_order?
+          configs.has_key?("order_id") || configs.has_key?(:order_id)
+        end
+
+        def path
+          if applying_to_order?
+            "#{user_path}/orders/#{CGI.escape(order_id)}/decisions"
+          else
+            "#{user_path}/decisions"
+          end
+        end
+
+        def user_path
+          "#{base_path}/users/#{CGI.escape(user_id)}"
+        end
+
+        def base_path
+          "#{Client::API3_ENDPOINT}/v3/accounts/#{account_id}"
+        end
+
+        def headers
+          {
+            "Content-type" => "application/json"
+          }.merge(Client.build_auth_header(api_key))
+        end
+      end
+    end
+  end
+end