talon_one 0.0.10 → 1.1.0

data/.gitignore

@@ -1,3 +0,0 @@
-talon_one-*.gem
-secrets.yml
-Gemfile.lock

data/.travis.yml

@@ -1,5 +0,0 @@
-language: ruby
-cache: bundler
-rvm:
-  - 2.2
-  - 2.3.3

data/lib/integration/client.rb

@@ -1,88 +0,0 @@
-require 'openssl'
-require 'oj'
-
-require_relative './search_profiles_result'
-require_relative './rule_engine_result'
-require_relative './referral_code'
-require_relative './client_error'
-
-module TalonOne
-  module Integration
-    # Basic REST client for the TalonOne integration API
-    class Client
-      def initialize(config = {})
-        @endpoint = URI(
-          config[:endpoint] || ENV["TALONONE_ENDPOINT"] || "https://example.talon.one"
-        )
-        @endpoint.path = @endpoint.path.sub(/\/+$/, '')
-        @http = Net::HTTP.new(@endpoint.host, @endpoint.port)
-        @http.use_ssl = @endpoint.scheme == "https"
-
-        @application_id = config[:application_id] || ENV["TALONONE_APP_ID"]
-        @application_key = [config[:application_key] || ENV["TALONONE_APP_KEY"]].pack('H*')
-      end
-
-      def request(method, path, payload = nil, result = TalonOne::Integration::RuleEngineResult)
-        req = Net::HTTP.const_get(method).new(@endpoint.path + path)
-        req.body = Oj.dump payload, oj_options(:compat)
-        signature = OpenSSL::HMAC.hexdigest(OpenSSL::Digest.new('md5'), @application_key, req.body)
-
-        req['Content-Type'] = 'application/json'
-        req['Content-Signature'] = "signer=#{@application_id}; signature=#{signature}"
-
-        res = @http.request(req)
-
-        if res.code[0] == '2'
-          result.new(Oj.load(res.body, oj_options(:strict)))
-        else
-          raise TalonOne::Integration::ClientError.new("#{method.upcase} #{path} -> #{res.code} #{res.body}")
-        end
-      end
-
-      def track_event(session_id, event_type, value)
-        request "Post", "/v1/events", { sessionId: session_id, type: event_type, attributes: value }
-      end
-
-      def update_customer_session(session_id, data)
-        request "Put", "/v1/customer_sessions/#{session_id}", data
-      end
-
-      def update_customer_profile(profile_id, data)
-        request "Put", "/v1/customer_profiles/#{profile_id}", data
-      end
-
-      def close_customer_session(session_id)
-        update_customer_session session_id, { state: "closed" }
-      end
-
-      def create_referral_code(campaign_id, advocate_profile_id, friend_id: "", start: nil, expire: nil)
-        newReferral = {
-          campaignId: campaign_id,
-          advocateProfileIntegrationId: advocate_profile_id,
-          friendProfileIntegrationId: friend_id,
-        }
-        if start
-          newReferral[:startDate] = start
-        end
-        if expire
-          newReferral[:expiryDate] = expire
-        end
-        request "Post", "/v1/referrals", newReferral, TalonOne::Integration::ReferralCode
-      end
-
-      def search_profiles_by_attributes(profileAttr)
-        request "Post", "/v1/customer_profiles_search", { attributes: profileAttr }, TalonOne::Integration::SearchProfilesResult
-      end
-
-      private
-
-      def oj_options(mode)
-        { :mode => mode,
-          :class_cache => false,
-          :escape_mode => :json,
-          :bigdecimal_as_decimal => true,
-          :bigdecimal_load => :bigdecimal }
-      end
-    end
-  end
-end

data/lib/integration/client_error.rb

@@ -1,9 +0,0 @@
-module TalonOne
-  module Integration
-    class ClientError < StandardError
-      def initialize(msg)
-        super
-      end
-    end
-  end
-end

data/lib/integration/customer_profile.rb

@@ -1,21 +0,0 @@
-module TalonOne
-  module Integration
-    class CustomerProfile
-      def initialize(raw_data)
-        @raw = raw_data
-      end
-
-      def id
-        @raw["id"]
-      end
-
-      def created
-        @raw["created"]
-      end
-
-      def integration_id
-        @raw["integrationId"]
-      end
-    end
-  end
-end

data/lib/integration/effect.rb

@@ -1,20 +0,0 @@
-module TalonOne
-  module Integration
-    class Effect
-      def initialize(raw_array)
-        @campaign_id = raw_array[0]
-        @ruleset_id = raw_array[1]
-        @ruleset_index = raw_array[2]
-        @raw = raw_array[3]
-      end
-
-      def function
-        @raw[0]
-      end
-
-      def args
-        @raw[1..-1]
-      end
-    end
-  end
-end

data/lib/integration/event.rb

@@ -1,45 +0,0 @@
-require_relative './effect'
-
-module TalonOne
-  module Integration
-    class Event
-      def initialize(raw_data)
-        @raw = raw_data
-      end
-
-      def type
-        @raw["type"]
-      end
-
-      def session_id
-        @raw["sessionId"]
-      end
-
-      def attributes
-        @raw["attributes"]
-      end
-
-      def effects
-        @effects ||= @raw["effects"].map do |raw_array|
-          TalonOne::Integration::Effect.new raw_array
-        end
-      end
-
-      def accepted_coupon?
-        effects.any? {|e| e.function == "acceptCoupon"}
-      end
-
-      def rejected_coupon?
-        !accepted_coupon? && effects.any? {|e| e.function == "rejectCoupon"}
-      end
-
-      def accepted_referral?
-        effects.any? {|e| e.function == "acceptReferral"}
-      end
-
-      def rejected_referral?
-        !accepted_referral? && effects.any? {|e| e.function == "rejectReferral"}
-      end
-    end
-  end
-end

data/lib/integration/referral_code.rb

@@ -1,49 +0,0 @@
-module TalonOne
-  module Integration
-    class ReferralCode
-      def initialize(raw_data)
-        @raw = raw_data
-      end
-
-      def id
-        @raw["id"]
-      end
-
-      def campaign_id
-        @raw["campaignId"]
-      end
-
-      def created
-        @raw["created"]
-      end
-
-      def advocate_id
-        @raw["advocateProfileIntegrationId"]
-      end
-
-      def code
-        @raw["code"]
-      end
-
-      def friend_id
-        @raw["friendProfileIntegrationId"]
-      end
-
-      def start_date
-        @raw["startDate"]
-      end
-
-      def expiry_date
-        @raw["expiryDate"]
-      end
-
-      def usage_count
-        @raw["usageCount"]
-      end
-
-      def usage_limit
-        @raw["usageLimit"]
-      end
-    end
-  end
-end

data/lib/integration/rule_engine_result.rb

@@ -1,23 +0,0 @@
-require_relative './event'
-
-module TalonOne
-  module Integration
-    class RuleEngineResult
-      def initialize(raw_data)
-        @raw = raw_data
-      end
-
-      def session
-        @raw["session"]
-      end
-
-      def profile
-        @raw["profile"]
-      end
-
-      def event
-        @event ||= TalonOne::Integration::Event.new(@raw["event"])
-      end
-    end
-  end
-end

data/lib/integration/search_profiles_result.rb

@@ -1,17 +0,0 @@
-require_relative './customer_profile'
-
-module TalonOne
-  module Integration
-    class SearchProfilesResult
-      def initialize(raw_data)
-        @raw = raw_data
-      end
-
-      def profiles
-        @profiles ||= @raw["data"].map do |raw_array|
-          TalonOne::Integration::CustomerProfile.new raw_array
-        end
-      end
-    end
-  end
-end

data/lib/management/client.rb

@@ -1,112 +0,0 @@
-module TalonOne
-  module Management
-    # Basic REST client for the TalonOne management API
-    class Client
-      def initialize(config = {})
-        @endpoint = URI(
-          config[:endpoint] || ENV["TALONONE_ENDPOINT"] || "https://app.talon.one"
-        )
-        @endpoint.path = @endpoint.path.sub(/\/+$/, '')
-        @http = Net::HTTP.new(@endpoint.host, @endpoint.port)
-        @http.use_ssl = @endpoint.scheme == "https"
-        @token = config[:token] || ENV["TALONONE_SESSION_TOKEN"]
-        if !@token
-          email = config[:email] || ENV["TALONONE_EMAIL"]
-          password = config[:password] || ENV["TALONONE_PASSWORD"]
-          if email && password
-            res = login(email, password)
-            @token = res["token"]
-          end
-        end
-      end
-
-      def request(method, path, payload = nil)
-        req = Net::HTTP.const_get(method).new(@endpoint.path + path)
-        if @token
-          req["Authorization"] = "Bearer #{@token}"
-        end
-        if payload
-          req.body = payload.to_json
-          req['Content-Type'] = 'application/json'
-        end
-        res = @http.request(req)
-        if res.code[0] == '2'
-          res.body && JSON.parse(res.body)
-        else
-          raise "#{method.upcase} #{path} -> #{res.code} #{res.body}"
-        end
-      end
-
-      def get(path)
-        request "Get", path
-      end
-
-      def put(path, payload)
-        request "Put", path, payload
-      end
-
-      def post(path, payload)
-        request "Post", path, payload
-      end
-
-      def delete(path)
-        request "Delete", path
-      end
-
-      def login(email, password) 
-        post "/v1/sessions", {"email" => email, "password" => password} 
-      end
-
-      def create_application(params)
-        post "/v1/applications", params
-      end
-      
-      def get_application(application_id)
-        get "/v1/applications/#{application_id}"
-      end
-
-      def delete_application(application_id)
-        delete "/v1/applications/#{application_id}"
-      end
-      
-      def get_applications
-        get "/v1/applications"
-      end
-      
-      def create_campaign(application_id, params)
-        post "/v1/applications/#{application_id}/campaigns", params
-      end
-      
-      def get_campaign(application_id, campaign_id)
-        get "/v1/applications/#{application_id}/campaigns/#{campaign_id}"
-      end
-
-      def update_campaign(application_id, campaign_id, params)
-        put "/v1/applications/#{application_id}/campaigns/#{campaign_id}", params
-      end
-
-      def update_ruleset_for_campaign(application_id, campaign_id, params)
-        ruleset = post "/v1/applications/#{application_id}/campaigns/#{campaign_id}/rulesets", params
-        campaign = get_campaign(application_id, campaign_id)
-        campaign["activeRulesetId"] = ruleset["id"]
-        update_campaign(application_id, campaign_id, campaign)
-        return ruleset
-      end
-
-      def update_campaign_status(application_id, campaign_id, campaign_status)
-        campaign = get_campaign(application_id, campaign_id)
-        campaign["state"] = campaign_status
-        update_campaign(application_id, campaign_id, campaign)
-      end
-
-      def create_attribute(params)
-        post "/v1/attributes", params
-      end
-
-      def delete_attribute(attribute_id)
-        delete "/v1/attributes/#{attribute_id}"
-      end
-      
-    end
-  end
-end

data/test/test_helper.rb

@@ -1,20 +0,0 @@
-require 'minitest/autorun'
-require 'talon_one'
-
-class LiveApiTest < Minitest::Test
-  def integration_config
-    {}
-  end
-
-  def integration_client
-    @integration_client ||= TalonOne::Integration::Client.new integration_config
-  end
-
-  def management_config
-    {}
-  end
-
-  def management_client
-    @management_client ||= TalonOne::Management::Client.new management_config
-  end
-end

data/test/test_integration_api_live.rb

@@ -1,64 +0,0 @@
-class TestIntegrationApiLive < LiveApiTest
-  def setup
-    @app = management_client.create_application(
-      name: "Ruby SDK Test App #{rand(36**3).to_s(36)}",
-      key: "fefecafedeadbeef",
-      currency: "USD",
-      timezone: "UTC"
-    )
-    @campaign = management_client.create_campaign @app["id"], { name: "Test Campaign", state: 'disabled', tags: [], limits: [] }
-    @ruleset = management_client.update_ruleset_for_campaign @app["id"], @campaign["id"], rules: [{
-      title: "Free money for all!",
-      condition: ["and", true],
-      effects: [
-        ["setDiscount", "Free money", 45.55]
-      ]
-    }]
-
-    management_client.update_campaign_status @app["id"], @campaign["id"], "enabled"
-
-    @event_type ||= "Viewed Page#{rand(36**3).to_s(36)}"
-    @attribute ||= management_client.create_attribute({ entity: "Event", eventType: @event_type, name: "URL", title: "Page URL", type: "string", description: "The URL of the page that the user has viewed", tags: [], editable: true })
-  end
-
-  def teardown
-    management_client.delete_application @app["id"]
-    management_client.delete_attribute @attribute["id"]
-  end
-
-  def integration_config
-    { application_id: @app["id"], application_key: @app["key"] }
-  end
-
-  def test_track_event
-    res = integration_client.track_event "a-session", @event_type, { URL: "http://example.com" }
-    assert res.profile
-    assert res.session
-    assert_instance_of TalonOne::Integration::Event, res.event
-    assert !res.event.rejected_coupon?, "No coupon -> no rejectCoupon effect"
-    assert !res.event.accepted_coupon?, "No coupon -> no acceptCoupon effect"
-    assert_equal 1, res.event.effects.length
-    assert_equal "setDiscount", res.event.effects[0].function
-    assert_equal @event_type, res.event.type
-    assert_equal "a-session", res.event.session_id, "a-session"
-    assert_equal({ "URL" => "http://example.com" }, res.event.attributes)
-    assert_instance_of BigDecimal, res.session["discounts"]["Free money"]
-  end
-
-  def test_update_customer_session
-    res = integration_client.update_customer_session "new-session", {
-      coupon: "invalid coupon code",
-      total: BigDecimal.new("45.55"),
-    }
-    assert res.event.rejected_coupon?, "invalid coupon code was rejected"
-  end
-
-  def test_raise_error
-    err = assert_raises TalonOne::Integration::ClientError do
-      integration_client.track_event "a-session", @event_type, { BADURL: "http://example.com" }
-    end
-
-    assert_includes err.message, '400'
-  end
-
-end