promonizr 1.13.2

data/lib/promonizr/products.rb

@@ -0,0 +1,48 @@
+module Promonizr
+  module Products
+
+    TYPE_CODES = %w[car_insurance travel_assistance]
+    API_ENDPOINTS = %w[attributes advanced]
+
+    module_function
+
+    def api_url
+      CoConfig::PROMOTION_API[:url] + '/products'
+    end
+
+    # Returns the url associated to the given subresource using
+    # as prefix the value returned by <tt>Products.api_url</tt>
+    #
+    # ==== Examples
+    #     attributes_url('car_insurance')
+    #     #=> "…/products/car_insurance/attributes"
+    #
+    #     advanced_url('travel_assistance')
+    #     #=> "…/products/travel_assistance/advanced"
+    API_ENDPOINTS.each do |url_segment|
+      define_method("#{url_segment}_url"){ |id| "#{api_url}/#{id}/#{url_segment}" }
+    end
+
+    # Returns the attributes that can be used as variables on the rules as.
+    # The expected response from the service is an array, if it is
+    # anything else, the response will be an emtpy array.
+    #
+    # API reference:
+    # https://github.com/comparaonline/promotions/wiki/API-Products#attributes
+    # https://github.com/comparaonline/promotions/wiki/API-Products#advanced
+    #
+    # ==== Examples
+    #     attributes('car_insurance', 'cl')   # => []
+    #     advanced('travel_assistance', 'br') # =>
+    API_ENDPOINTS.each do |rule|
+      define_method(rule) do |id, country_code|
+          url = public_send("#{rule}_url", id)
+          params = {countryCode: country_code}
+          response = Request.execute(:get, url, params)
+
+          response.is_a?(Array) ? response : []
+      end
+    end
+
+  end
+end

data/lib/promonizr/promotion.rb

@@ -0,0 +1,63 @@
+require 'ostruct'
+require 'uri'
+
+module Promonizr
+  class Promotion < OpenStruct
+    class Nil
+      def show_promotion?; false; end
+      def kind; nil; end
+      def title; nil; end
+      def subtitle; nil; end
+      def terms_of_service; nil; end
+      def start_date; nil; end
+      def end_date; nil; end
+      def companies; []; end
+    end
+
+    def show_promotion?; true; end
+
+    def companies
+      unless names = @table[:companies]
+        Promonizr::Companies.all(country_code, product)
+      else
+        Promonizr::Companies.by_url_names(names, country_code, product)
+      end
+    end
+
+    def featured?
+      return false if display_config.blank?
+      display_config['featured'] == true
+    end
+
+    def show?(url, stage)
+      return true if display_config.blank?
+
+      stage_match = display_config['stage'].try(:[], stage)
+      url_excluded = display_config.fetch('url_exclusions', []).any? do |excluded_url|
+        url.include?(excluded_url)
+      end if url
+
+      stage_match && !url_excluded
+    end
+
+    def image_url
+      s3_to_cloudfront(@table[:image_url])
+    end
+
+    def featured_image_url
+      s3_to_cloudfront(@table[:featured_image_url])
+    end
+
+    def as_json(options = nil)
+      @table.as_json(options)
+    end
+
+    private
+
+    def s3_to_cloudfront(url)
+      return url if CoConfig::PROMOTION_API[:cdn].empty?
+      uri = URI.parse(url)
+      URI.join(CoConfig::PROMOTION_API[:cdn], File.basename(uri.path)).to_s
+    end
+  end
+end

data/lib/promonizr/railtie.rb

@@ -0,0 +1,7 @@
+module Promonizr
+  class Railtie < ::Rails::Railtie
+    config.before_configuration do
+      CoConfig.load(Promonizr::Engine.root.join('config'))
+    end
+  end
+end

data/lib/promonizr/request.rb

@@ -0,0 +1,32 @@
+module Promonizr
+  module Request
+    TIMEOUT_SECONDS = 1
+    DEFAULT_ANSWER = []
+
+    module_function
+
+    def execute(method, url, params = {}, headers = {})
+      answer = DEFAULT_ANSWER
+
+      begin
+        Timeout::timeout(TIMEOUT_SECONDS) do
+          return false unless [:post, :put, :delete, :get].include?(method)
+          response = RestClient::Request.execute(
+            method: method,
+            url: url,
+            payload: method == :get ? {} : params,
+            headers: method == :get ? headers.merge(params: params) : headers
+          )
+          answer = JSON.parse(response)
+        end
+      rescue Timeout::Error
+        Rails.logger.error "Promotions hit timeout on request: #{url} with params:#{params.inspect}"
+      rescue StandardError => exception
+        Rails.logger.error exception.message + "\n" +
+          exception.backtrace.join("\n")
+      end
+
+      return answer
+    end
+  end
+end

data/lib/promonizr/search.rb

@@ -0,0 +1,54 @@
+module Promonizr
+  module Search
+    module_function
+
+    def featured(product, country_code, url, attributes = {})
+      config = { url: url, stage: 'landing' }
+      all = filter(product, country_code, config, attributes)
+
+      return nil if all.empty?
+      all.detect(&:featured?) || all.first
+    end
+
+    def for_carousel(product, country_code, url, attributes = {})
+      config = { url: url, stage: 'landing' }
+      filter(product, country_code, config, attributes)
+    end
+
+    def for_results(product, country_code, attributes = {})
+      config = { stage: 'results' }
+      filter(product, country_code, config, attributes)
+    end
+
+    def for_results_in_bulk(url, enabled, form_data, offers_data)
+      default_hash = Hash.new(Promotion::Nil.new)
+
+      return default_hash unless enabled
+
+      config = { stage: 'results' }
+      results = Hash.new(Promotion::Nil.new)
+      Evaluations.evaluate_in_bulk(url, form_data, offers_data)
+        .each { |offer_id, list| results[offer_id] = filter_first_campaign(list, config) }
+      results
+    end
+
+    def filter(product, country_code, config = {}, attributes = {})
+      list = Evaluations.evaluate(product, country_code, attributes)
+      filter_campaigns(list, config)
+    end
+
+    def filter_campaigns(list, config)
+      list.select!{ |p| p.show?(config[:url], config[:stage]) } if config
+      list.sort do |p1, p2|
+        p1_rules_size = p1.rules ? p1.rules.keys.size : 0
+        p2_rules_size = p2.rules ? p2.rules.keys.size : 0
+
+        [p1_rules_size, p1.end_date.to_date] <=> [p2_rules_size, p2.end_date.to_date]
+      end
+    end
+
+    def filter_first_campaign(list, config)
+      filter_campaigns(list, config).first || Promotion::Nil.new
+    end
+  end
+end

data/lib/promonizr/special_events.rb

@@ -0,0 +1,63 @@
+module Promonizr
+  # Campaigns implements CRUD methods on the Campaign resource from the
+  # Promotions web service.
+  module SpecialEvents
+    JSON_ATTRIBUTES = %i(images).freeze
+
+    module_function
+
+    def api_url
+      CoConfig::PROMOTION_API[:url] + '/special-events'
+    end
+
+    def all
+     @special_events = Request.execute(:get, api_url)
+     @special_events.is_a?(Array) ?@special_events : []
+    end
+
+    def create(params)
+      Request.execute(:post, api_url, sanitized_params(params))
+    end
+
+    def update(id, params)
+      Request.execute(:put, url_with_id(id), sanitized_params(params))
+    end
+
+    def destroy(id)
+      Request.execute(:delete, url_with_id(id))
+    end
+
+    def get(id)
+      Request.execute(:get, url_with_id(id))
+    end
+
+    def url_with_id(id)
+      "#{api_url}/#{id}"
+    end
+
+    def search(params)
+      Request.execute(:post, url_with_id('search'), sanitized_params(params))
+    end
+
+    def find_current(params)
+      events = search(params)
+      events.empty? ? nil : events[0]
+    end
+
+    # Ensures that columns defined in JSON_ATTRIBUTES are json strings.
+    # boolean values will be casted
+    def sanitized_params(params)
+      JSON_ATTRIBUTES.each do |json_column|
+        next unless params.key?(json_column)
+
+        if params[json_column].is_a?(String)
+          params[json_column] = JSON.parse(params[json_column])
+        end
+
+        params[json_column] = params[json_column].to_json
+      end
+
+      params
+    end
+  end
+end

data/lib/promonizr/utils.rb

@@ -0,0 +1,47 @@
+module Promonizr
+  module Utils
+    module_function
+
+    # Based on the Rails 4.2.1 implementation
+    # http://apidock.com/rails/v4.2.1/Hash/transform_values
+    def transform_values(hash, &block)
+      return yield(hash) unless hash.respond_to?(:each)
+      return hash.map{|v| transform_values(v, &block) } if hash.is_a?(Array)
+
+      result = {}
+      hash.each do |key, value|
+        if value.is_a?(Hash)
+          result[key] = transform_values(value, &block)
+        elsif value.is_a?(Array)
+          result[key] = value.map{ |v| transform_values(v, &block) }
+        else
+          result[key] = yield(value)
+        end
+      end
+      result
+    end
+
+    # Checks in the given hash if there are boolean or numeric values, cast them
+    # to the proper type.
+    def cast_values(hash)
+      transform_values(hash) do |value|
+        if value.is_a?(String)
+          # Is boolean ?
+          value = case value.strip.downcase
+            when 'true'  then true
+            when 'false' then false
+            else value
+          end
+          # if not boolean and can be cast to number
+          if (!!value != value) && (Float(value) != nil rescue false)
+            value = case value.strip.to_i.to_s
+              when value then value.to_i
+              else value.to_f
+            end
+          end
+        end
+        value
+      end
+    end
+  end
+end

data/lib/promonizr/version.rb

@@ -0,0 +1,3 @@
+module Promonizr
+  VERSION = '1.13.2'
+end

data/lib/promonizr.rb

@@ -0,0 +1,15 @@
+require "promonizr/version"
+require "promonizr/engine"
+require 'promonizr/railtie'
+require 'promonizr/utils'
+require 'promonizr/request'
+require 'promonizr/special_events'
+require 'promonizr/contests'
+require 'promonizr/campaigns'
+require 'promonizr/products'
+require 'promonizr/search'
+require 'promonizr/promotion'
+require 'promonizr/evaluations'
+
+module Promonizr
+end

data/spec/factories/promotion_factory.rb

@@ -0,0 +1,29 @@
+require 'factory_girl'
+require 'faker'
+
+FactoryGirl.define do
+  factory :promotion, class: Promonizr::Promotion do
+    product Promonizr::Products::TYPE_CODES.sample
+    country_code Promonizr::Campaigns::COUNTRY_CODES.sample
+    title Faker::Lorem.sentence
+    subtitle Faker::Lorem.sentence
+    kind Promonizr::Campaigns::KIND_CODES.sample
+    start_date Faker::Date.backward
+    end_date Faker::Date.forward
+    image_url Faker::Placeholdit.image("350x219")
+    featured_image_url Faker::Placeholdit.image("350x219")
+    from_service [true, false].sample
+    terms_of_service Faker::Lorem.paragraph
+    rules { { } }
+    benefits { { } }
+
+    initialize_with { new(attributes) }
+
+    factory :featured_promotion do
+      display_config {{
+        'featured' => true,
+        'stage' => {'landing' => true}
+      }}
+    end
+  end
+end

data/spec/i18n_spec.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+require 'i18n/tasks'
+
+describe 'I18n' do
+  let(:i18n) { I18n::Tasks::BaseTask.new }
+  let(:missing_keys) { i18n.missing_keys }
+
+  it 'does not have missing keys' do
+    expect(missing_keys).to be_empty,
+      "Missing #{missing_keys.leaves.count} i18n keys, run `i18n-tasks missing' to show them"
+  end
+
+end

data/spec/promonizr/campaigns_spec.rb

@@ -0,0 +1,130 @@
+require 'spec_helper'
+
+describe Promonizr::Campaigns do
+  describe '.api_url' do
+    expected_url = CoConfig::PROMOTION_API[:url] + '/campaigns'
+    subject(:promonizr_campaigns) {Promonizr::Campaigns}
+    it {expect(promonizr_campaigns.api_url).to eq(expected_url)}
+  end
+
+  describe '.url_with_id' do
+    expected_url = CoConfig::PROMOTION_API[:url] + '/campaigns/19'
+    subject(:promonizr_campaigns) {Promonizr::Campaigns}
+    it {expect(promonizr_campaigns.url_with_id('19')).to eq(expected_url)}
+  end
+
+  describe '.sanitized_params' do
+    context 'when the params already includes a JSON' do
+      subject(:params) { { rules: { a: 1, b: "2" }.to_json } }
+      expected_params = { rules: { a: 1, b: 2 }.to_json }
+      it do
+        expect(Promonizr::Campaigns.sanitized_params(params)).to eq(expected_params)
+      end
+    end
+
+    context 'when params includes a hash' do
+      subject(:params) { {rules: {a: 1, b: "2"}, conditions:{}}}
+      it  do
+        expected_params = params.merge({
+          rules: params[:rules].merge(b: 2).to_json,
+          conditions: params[:conditions].to_json
+        })
+        expect(Promonizr::Campaigns.sanitized_params(params)).to eq(expected_params)
+      end
+    end
+
+    context 'when params does not include a Campaigns JSON column' do
+      subject(:params) { { title: { a: 1, b: "2" } } }
+      it do
+        expect(Promonizr::Campaigns.sanitized_params(params)).to eq(params)
+      end
+    end
+
+    context 'when params include a Campaigns JSON column with truthy or falsy values' do
+      subject(:params) { { display_config: { sales: 'true', results: 'false' } } }
+
+      it do
+        expected_params = {
+          display_config: { sales: true, results: false }.to_json
+        }
+        expect(Promonizr::Campaigns.sanitized_params(params)).to eq(expected_params)
+      end
+    end
+
+    context 'when params have truthy or falsy values, but not in a Campaigns JSON column' do
+      subject(:params) { { title: 'true' } }
+
+      it do
+        expect(Promonizr::Campaigns.sanitized_params(params)).to eq(params)
+      end
+    end
+
+    context 'when params include rules with truthy or falsy values' do
+      subject(:params) do
+        {
+          rules: {
+            multitravel: {
+              conditions: [ { joinOperator: 'and', eq: 'true' } ],
+              type: 'simple',
+              joinOperator: 'and'
+            }
+          }
+        }
+      end
+
+      it do
+        output = JSON.parse(Promonizr::Campaigns.sanitized_params(params)[:rules])
+        expect(output['multitravel']['conditions'][0]['eq']).to be true
+      end
+    end
+
+    context 'params has an array of strings' do
+      subject(:params) do
+        {
+          display_config: {
+            'featured' => 'true',
+            'url_exclusions' => ['car', 'plane', 'credit'],
+            'stage' => {'landing'=>'false', 'results'=>'true', 'sale'=>'false'}
+          }
+        }
+      end
+
+      expected_params = {
+        display_config: {
+          'featured' => true,
+          'url_exclusions' => ['car', 'plane', 'credit'],
+          'stage' => {'landing'=>false, 'results'=>true, 'sale'=>false}
+        }.to_json
+      }
+
+      it do
+        expect(Promonizr::Campaigns.sanitized_params(params)).to eq(expected_params)
+      end
+    end
+
+    context 'companies params is a array with mixed values' do
+      subject(:params) do
+        { companies: ['true', '1', 6, false, { key: {value: 'false'} }]}
+      end
+
+      expected_params = {
+        companies: [true, 1, 6, false, { key: { value: false } } ].to_json
+      }
+      it do
+        expect(Promonizr::Campaigns.sanitized_params(params)).to eq(expected_params)
+      end
+    end
+
+    context 'companies params is a array with hashes' do
+      subject(:params) do
+        { companies: [{}, {}, {}, {}] }
+      end
+
+      expected_params = { companies: [{}, {}, {}, {}].to_json }
+
+      it do
+        expect(Promonizr::Campaigns.sanitized_params(params)).to eq(expected_params)
+      end
+    end
+  end
+end

data/spec/promonizr/evaluations_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+describe Promonizr::Evaluations do
+  context '#evaluate' do
+    it 'returns all promotions for the proper country and product when no attributes are passed' do
+      country_code = 'cl'
+      product = 'car_insurance'
+      default_company_param = nil
+
+      stub_request(:post, Promonizr::Evaluations::api_url('evaluate'))
+        .with(
+          body: {
+            countryCode: country_code,
+            product: product,
+            form: {},
+            companyName: default_company_param
+          }.to_json
+        ).to_return(status: 200, body: [
+          build(:promotion, { country_code: 'cl', product: 'car_insurance' })
+        ].to_json)
+
+      result = Promonizr::Evaluations.evaluate(product, country_code)
+
+      expect(result).to_not be_nil
+      expect(result).to_not be_empty
+    end
+
+    it 'returns filtered promotions based on attributes' do
+      country_code = 'cl'
+      product = 'car_insurance'
+      company_name = 'some_company'
+      attributes = { 'age' => 20, 'gender' => 'male', 'company_name' => company_name }
+
+      stub_request(:post, Promonizr::Evaluations::api_url('evaluate'))
+        .with(
+          body: {
+            countryCode: country_code,
+            product: product,
+            form: attributes,
+            companyName: company_name
+          }.to_json
+        ).to_return(status: 200, body: [
+          build(:promotion, {
+            country_code: 'cl',
+            product: 'car_insurance',
+            rules: {
+              'age' => { 'conditions' => [{ 'between' => [18, 65] }] },
+              'gender' => { 'conditions' => [{ 'eq' => 'male' }]}
+            }
+          })
+        ].to_json)
+
+      result = Promonizr::Evaluations.evaluate(product, country_code, attributes)
+
+      expect(result).to_not be_nil
+      expect(result).to_not be_empty
+    end
+  end
+end

data/spec/promonizr/products_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe Promonizr::Products do
+
+  describe '.attributes_url' do
+    context 'when id is car_insurance' do
+      expected_url = CoConfig::PROMOTION_API[:url] + '/products/car_insurance/attributes'
+      it {expect(Promonizr::Products.attributes_url('car_insurance')).to eq(expected_url)}
+    end
+  end
+
+  describe '.advanced_url' do
+    context 'when id is car_insurance' do
+      expected_url = CoConfig::PROMOTION_API[:url] + '/products/car_insurance/advanced'
+      it {expect(Promonizr::Products.advanced_url('car_insurance')).to eq(expected_url)}
+    end
+  end
+
+  describe '.advanced' do
+    it {expect(Promonizr::Products.respond_to?(:advanced)).to be true}
+  end
+
+  describe '.attributes' do
+    it {expect(Promonizr::Products.respond_to?(:attributes)).to be true}
+  end
+
+  describe '#Products' do
+    it "does not contain credit_card" do
+      expect(Promonizr::Products::TYPE_CODES).not_to include('credit_card')
+    end
+  end
+
+end