talkable 0.0.0 → 0.9.0

data/Rakefile

@@ -0,0 +1,17 @@
+require "bundler"
+require "bundler/gem_tasks"
+
+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
+
+# RSpec tasks
+require 'rspec/core'
+require "rspec/core/rake_task"
+RSpec::Core::RakeTask.new(:spec)
+
+task :default  => :spec

data/lib/talkable.rb

@@ -0,0 +1,43 @@
+require 'talkable/version'
+require 'talkable/configuration'
+require 'talkable/api'
+require 'talkable/resources'
+require 'talkable/middleware'
+require 'talkable/integration'
+require 'talkable/railtie' if defined? ::Rails::Railtie
+
+module Talkable
+  UUID = 'talkable_visitor_uuid'.freeze
+
+  class << self
+    def configure(config = nil)
+      configuration.apply config if config
+      yield(configuration) if block_given?
+    end
+
+    def configuration
+      @configuration ||= Talkable::Configuration.new
+    end
+
+    def visitor_uuid
+      Thread.current[UUID]
+    end
+
+    def visitor_uuid=(uuid)
+      Thread.current[UUID] = uuid
+    end
+
+    def with_uuid(uuid)
+      old_uuid, Talkable.visitor_uuid = Talkable.visitor_uuid, uuid
+      yield if block_given?
+    ensure
+      Talkable.visitor_uuid = old_uuid
+    end
+
+    def find_or_generate_uuid
+      visitor_uuid || Talkable::API::Visitor.create[:uuid]
+    end
+
+  end
+
+end

data/lib/talkable/api.rb

@@ -0,0 +1,13 @@
+require 'talkable/api/base'
+
+Dir[File.dirname(__FILE__) + '/api/*.rb'].each { |file| require file }
+
+module Talkable
+  module API
+    VERSION = "v2".freeze
+    class BadRequest < StandardError
+    end
+    class NetworkError < StandardError
+    end
+  end
+end

data/lib/talkable/api/base.rb

@@ -0,0 +1,98 @@
+require 'net/https'
+require 'json'
+require 'furi'
+
+module Talkable
+  module API
+    class Base
+      class << self
+        def get(path, params = {})
+          uri = request_uri(path, request_params(params))
+          request = Net::HTTP::Get.new(uri.request_uri)
+          perform_request(uri, request)
+        end
+
+        def post(path, params = {})
+          data_request(:post, path, params)
+        end
+
+        def put(path, params = {})
+          data_request(:put, path, params)
+        end
+
+        protected
+
+        def data_request(method, path, params)
+          http_class = {post: Net::HTTP::Post, put: Net::HTTP::Put}[method.to_sym]
+          uri = request_uri(path)
+          request = http_class.new(uri.request_uri)
+          request.body = request_params(params).to_json
+          perform_request(uri, request)
+        end
+
+        def request_params(params = {})
+          params.merge({
+            api_key:   Talkable.configuration.api_key,
+            site_slug: Talkable.configuration.site_slug,
+          })
+        end
+
+        def request_uri(path, params = {})
+          URI(
+            Furi.update("#{Talkable.configuration.server}/api/#{Talkable::API::VERSION}#{path}",
+              query: params
+            )
+          )
+        end
+
+        def request_headers
+          {
+            'User-Agent'    => "Talkable Gem/#{Talkable::VERSION}",
+            'Content-Type'  => 'application/json',
+            'Accept'        => 'application/json',
+          }
+        end
+
+        def perform_request(uri, request)
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = uri.is_a?(URI::HTTPS)
+
+          request.initialize_http_header request_headers
+          process_response http.request(request)
+        rescue  Errno::ECONNREFUSED, Errno::ECONNRESET, Errno::ETIMEDOUT,
+                Errno::EHOSTUNREACH, Errno::ENETUNREACH, SocketError, Timeout::Error,
+                OpenSSL::SSL::SSLError, EOFError, Net::HTTPBadResponse => e
+          raise NetworkError.new(e.message)
+        end
+
+        def process_response(response)
+          case response
+          when Net::HTTPSuccess, Net::HTTPClientError
+            parse_response response.body
+          when Net::HTTPServerError
+            raise NetworkError.new("Server #{Talkable.configuration.server} is unavailable. Try again later")
+          end
+        end
+
+        def parse_response(body)
+          raise_invalid_response if body.nil?
+          result = JSON.parse(body, symbolize_names: true)
+          raise_invalid_response unless result.is_a?(Hash)
+
+          if result[:ok]
+            result[:result]
+          else
+            raise BadRequest.new(result[:error_message])
+          end
+
+        rescue JSON::ParserError
+          raise_invalid_response
+        end
+
+        def raise_invalid_response
+          raise BadRequest.new("Invalid response")
+        end
+      end
+    end
+  end
+end

data/lib/talkable/api/offer.rb

@@ -0,0 +1,11 @@
+module Talkable
+  module API
+    class Offer < Base
+      class << self
+        def find(id, params = {})
+          get "/offers/#{id}", params
+        end
+      end
+    end
+  end
+end

data/lib/talkable/api/origin.rb

@@ -0,0 +1,29 @@
+module Talkable
+  module API
+    class Origin < Base
+      AFFILIATE_MEMBER  = "AffiliateMember".freeze
+      PURCHASE          = "Purchase".freeze
+      EVENT             = "Event".freeze
+
+      DEFAULT_TRAFFIC_SOURCE = 'talkable-gem'
+
+      class << self
+        def create(origin_type, params)
+          post '/origins', {
+            type: origin_type,
+            data: default_data.merge(params),
+          }
+        end
+
+        protected
+
+        def default_data
+          {
+            uuid: Talkable.visitor_uuid,
+            traffic_source: DEFAULT_TRAFFIC_SOURCE,
+          }
+        end
+      end
+    end
+  end
+end

data/lib/talkable/api/person.rb

@@ -0,0 +1,17 @@
+module Talkable
+  module API
+    class Person < Base
+      class << self
+        def find(email_or_username)
+          get "/people/#{email_or_username}"
+        end
+
+        def update(email_or_username, params)
+          put "/people/#{email_or_username}", {
+            data: params
+          }
+        end
+      end
+    end
+  end
+end

data/lib/talkable/api/referral.rb

@@ -0,0 +1,19 @@
+module Talkable
+  module API
+    class Referral < Base
+      APPROVED  = 'approved'
+      VOIDED    = 'voided'
+      UNBLOCKED = 'unblocked'
+
+      class << self
+        def update(origin_slug, status)
+          put "/origins/#{origin_slug}/referral", {
+            data: {
+              status: status
+            }
+          }
+        end
+      end
+    end
+  end
+end

data/lib/talkable/api/reward.rb

@@ -0,0 +1,19 @@
+module Talkable
+  module API
+    class Reward < Base
+      class << self
+        def find(params = {})
+          get "/rewards", default_params.merge(params)
+        end
+
+        protected
+
+        def default_params
+          {
+            visitor_uuid: Talkable.visitor_uuid,
+          }
+        end
+      end
+    end
+  end
+end

data/lib/talkable/api/share.rb

@@ -0,0 +1,19 @@
+module Talkable
+  module API
+    class Share < Base
+      CHANNEL_FACEBOOK          = "facebook".freeze
+      CHANNEL_FACEBOOK_MESSAGE  = "facebook_message".freeze
+      CHANNEL_TWITTER           = "twitter".freeze
+      CHANNEL_SMS               = "sms".freeze
+      CHANNEL_OTHER             = "other".freeze
+
+      class << self
+        def create(short_url_code, channel)
+          post "/offers/#{short_url_code}/shares", {
+            channel: channel,
+          }
+        end
+      end
+    end
+  end
+end

data/lib/talkable/api/visitor.rb

@@ -0,0 +1,13 @@
+module Talkable
+  module API
+    class Visitor < Base
+      class << self
+        def create(params = {})
+          post '/visitors', {
+            data: params,
+          }
+        end
+      end
+    end
+  end
+end

data/lib/talkable/configuration.rb

@@ -0,0 +1,40 @@
+module Talkable
+  class Configuration
+    DEFAULT_SERVER = "https://www.talkable.com".freeze
+
+    attr_accessor :site_slug
+    attr_accessor :api_key
+    attr_accessor :server
+    attr_accessor :js_integration_library
+
+    class UnknownOptionError < StandardError
+    end
+
+    def initialize
+      self.site_slug  = ENV["TALKABLE_SITE_SLUG"]
+      self.api_key    = ENV["TALKABLE_API_KEY"]
+      self.server     = "https://www.talkable.com"
+    end
+
+    def apply(config)
+      config.each do |key, value|
+        if respond_to?("#{key}=")
+          public_send("#{key}=", value)
+        else
+          raise UnknownOptionError.new("There is no `#{key}` option")
+        end
+      end
+    end
+
+    def js_integration_library
+      @js_integration_library || default_js_integration_library
+    end
+
+    protected
+
+    def default_js_integration_library
+      "//d2jjzw81hqbuqv.cloudfront.net/integration/clients/#{site_slug}.min.js"
+    end
+
+  end
+end

data/lib/talkable/generators/install_generator.rb

@@ -0,0 +1,81 @@
+module Talkable
+  class InstallGenerator < Rails::Generators::Base
+    source_root File.expand_path("../templates", __FILE__)
+    class_option :haml, type: :boolean, default: false
+    class_option :slim, type: :boolean, default: false
+
+    def ask_config_values
+      @site_slug  = ask("Your Talkable site slug:")
+      @api_key    = ask("Your Talkable API Key:")
+      if yes?('Do you have a custom domain? [Y/n]')
+        @server   = ask("Your custom domain [#{Talkable::Configuration::DEFAULT_SERVER}]:")
+      end
+    end
+
+    def add_initializer
+      template "config/initializers/talkable.rb", "config/initializers/talkable.rb"
+    end
+
+    def inject_talkable_offer
+      inject_into_file "app/controllers/application_controller.rb", after: "protect_from_forgery with: :exception" do
+<<-RUBY
+
+  before_action :load_talkable_offer
+RUBY
+      end
+
+      inject_into_file "app/controllers/application_controller.rb", before: /^end/ do
+<<-RUBY
+  protected
+
+  def load_talkable_offer
+    origin = Talkable.register_affiliate_member(campaign_tags: 'popup')
+    @offer ||= origin.offer if origin
+  end
+RUBY
+      end
+
+      empty_directory "app/views/shared/"
+
+      if erb?
+        copy_file "app/views/shared/_talkable_offer.html.erb", "app/views/shared/_talkable_offer.html.erb"
+        inject_into_file "app/views/layouts/application.html.erb", before: "</body>" do
+          "<%= render 'shared/talkable_offer', offer: @offer %>\n"
+        end
+      else
+        ext = template_lang
+
+        copy_file "app/views/shared/_talkable_offer.html.#{ext}", "app/views/shared/_talkable_offer.html.#{ext}"
+        gsub_file "app/views/layouts/application.html.#{ext}", /^(\s*)\=\s*yield\s*$/ do |line|
+          paddings = line.match(/(\s*)\=/)[1]
+          "#{line}#{paddings}= render 'shared/talkable_offer', offer: @offer\n"
+        end
+      end
+    end
+
+    def add_invite_controller
+      ext = template_lang
+
+      copy_file "app/controllers/invite_controller.rb", "app/controllers/invite_controller.rb"
+      copy_file "app/views/invite/show.html.#{ext}", "app/views/invite/show.html.#{ext}"
+      route "get '/invite' => 'invite#show'"
+    end
+
+    protected
+
+    def template_lang
+      @template_lang ||= if options[:haml]
+        'haml'
+      elsif options[:slim]
+        'slim'
+      else
+        Rails::Generators.options[:rails][:template_engine].to_s.downcase
+      end
+    end
+
+    def erb?
+      template_lang == 'erb'
+    end
+
+  end
+end

data/lib/talkable/generators/templates/app/controllers/invite_controller.rb

@@ -0,0 +1,8 @@
+class InviteController < ApplicationController
+  skip_before_action :load_talkable_offer # skip default trigger widget integration
+
+  def show
+    origin = Talkable.register_affiliate_member(campaign_tags: 'invite')
+    @invite_offer = origin.offer if origin
+  end
+end