revere_mobile 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 83455b42722c1f3d5a04a9a735942bf4e1cb055d
+  data.tar.gz: c0e462db54408ac3c37a0eae6f5a55b92f1fec9c
+SHA512:
+  metadata.gz: 278df3e7393a4a2a597e236b9a8ceeb857de7964e1f5c06e6705cdbdd4be2d81b6c2a1092f402515af69d509dba1fc0e3a7d709e8b87da5116d4af36851b4d4c
+  data.tar.gz: ef0be38bccefcd987c5364bab81500c9f1244a6e049d7597552ad22af4b88f3abc5d4224dd798e550c98d63213156571f8f2cc66f9afb9ef0ba67cbfe1b39947

data/README.md

@@ -0,0 +1,98 @@
+# The Revere Mobile Ruby Gem
+
+- TODO: Put some build status things here
+
+# Quick Start
+
+Add this line to your applications Gemfile:
+
+```ruby
+gem 'revere_mobile'
+```
+
+And then execute
+
+```sh
+$ bundle
+```
+
+Or install as standalone gem:
+
+```sh
+$ gem install revere_mobile
+```
+
+# Configuration
+
+Revere Mobile takes a block to be configured:
+
+```ruby
+RevereMobile.configure do |config|
+  # Configure the API Endpoint
+  # See https://mobile-developers.reverehq.com for more info for API Versions
+  config.api_endpoint = 'https://mobile.reverehq.com/api/v1'
+  # Configure an API Key
+  config.api_key = 'd1286a1a-f2e7-421a-91b8-f8cc8201558f'
+  # Defaults to "Revere Mobile Ruby Gem #{RevereMobile::VERSION}"
+  config.user_agent = 'CustomUserAgent'
+end
+```
+
+You can also configure options in a configuration object like so:
+
+```ruby
+RevereMobile.configuration.api_key = 'd1286a1a-f2e7-421a-91b8-f8cc8201558f'
+```
+
+For workers, for many instances you can create multiple configurations. This is also helpful for switching sessions based on
+username and password authentication.
+
+```ruby
+configuration = RevereMobile::Configuration.new
+configuration.username = 'example'
+configuration.password = 'example'
+client = RevereMobile::Client.new(configuration)
+client.login 
+```
+
+# Requests
+
+Using a `Username` and `Password` this sets the session via the `#login` method.
+
+```ruby
+configuration = RevereMobile::Configuration.new
+configuration.username = 'example'
+configuration.password = 'example'
+client = RevereMobile::Client.new(configuration)
+client.login # saves the session cookie for the instance of the client
+client.campaigns # returns lists of campaigns
+```
+
+You can also make requests directly with the module by just defining the `api_key`:
+
+```ruby
+RevereMobile.configuration.api_key = 'd1286a1a-f2e7-421a-91b8-f8cc8201558f'
+RevereMobile.campaigns
+```
+
+
+# Development
+
+Download this repo and run `rake spec` to run the tests.
+
+A console method has also been included, run `bin/console` to get a pry prompt in which to experiment.
+
+```ruby
+% bin/console
+[1] pry(main)> RevereMobile::VERSION
+# => "x.x.x"
+[2] pry(main)> RevereMobile.configuration.api_key = 'd1286a1a-f2e7-421a-91b8-f8cc8201558f'
+# => "d1286a1a-f2e7-421a-91b8-f8cc8201558f"
+[3] pry(main)> RevereMobile.campaigns
+# => {
+#  "page"=>1,
+# "size"=>-1,
+# "total"=>119,
+# "collection"=>
+# ...}
+```

data/bin/console

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'revere_mobile'
+require 'pry'
+
+Pry.start

data/lib/revere_mobile/client/authentication.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'faraday-cookie_jar'
+
+module RevereMobile
+  class Client
+    module Authentication
+      def login
+        conn = Faraday.new(url: config.api_endpoint) { |f| f.use :cookie_jar; f.adapter Faraday.default_adapter; }
+        response = conn.post do |req|
+          req.url '/api/v1/authenticate'
+          req.headers['Content-Type'] = 'application/json'
+          req.body = JSON.generate({ username: config.username, password: config.password })
+        end
+        config.session = response.headers['set-cookie']
+        response
+      end
+
+      def who_am_i
+        get(path: 'authenticate/whoami')
+      end
+
+      def logout
+        post(path: 'authenticate/logout')
+      end
+    end
+  end
+end

data/lib/revere_mobile/client/campaign.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module RevereMobile
+  class Client
+    module Campaign
+      def campaigns(params = { size: RevereMobile::Default.query_size })
+        get(path: 'campaign', params: params)
+      end
+
+      def create_campaign(body = {})
+        post(path: 'campaign', body: body)
+      end
+
+      def update_campaign(body = {})
+        put(path: "campaign/#{body[:id]}", body: body)
+      end
+    end
+  end
+end

data/lib/revere_mobile/client/mobile_flow.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module RevereMobile
+  class Client
+    module MobileFlow
+      def mobileflows(params:{ size: RevereMobile::Default.query_size })
+        get(path: 'mobileflow', params: params)
+      end
+    end
+  end
+end

data/lib/revere_mobile/client/shortcode.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module RevereMobile
+  class Client
+    module Shortcode
+      def shortcodes(params: { size: RevereMobile::Default.query_size })
+        get(path: 'shortcode', params: params)
+      end
+    end
+  end
+end

data/lib/revere_mobile/client.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'revere_mobile/connection'
+require 'revere_mobile/request'
+require 'revere_mobile/response'
+require 'revere_mobile/client/authentication'
+require 'revere_mobile/client/campaign'
+require 'revere_mobile/client/shortcode'
+require 'revere_mobile/client/mobile_flow'
+
+module RevereMobile
+  class Client
+    def initialize(configuration = nil)
+      @config = configuration
+    end
+
+    def config
+      @config || RevereMobile.configuration
+    end
+
+    include RevereMobile::Connection
+    include RevereMobile::Request
+    include RevereMobile::Response
+    include RevereMobile::Client::Authentication
+    include RevereMobile::Client::Campaign
+    include RevereMobile::Client::Shortcode
+    include RevereMobile::Client::MobileFlow
+  end
+end

data/lib/revere_mobile/configuration.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require 'revere_mobile/default'
+require 'revere_mobile/version'
+
+module RevereMobile
+  class Configuration
+    # The Revere Mobile Username
+    #
+    # The `username` setting is used for authenticating requests.
+    #
+    # @return [String, nil]
+    attr_accessor :username
+
+    # The Revere Mobile Password
+    #
+    # The `password` setting is used for authenticating requests.
+    #
+    # @return [String, nil]
+    attr_accessor :password
+
+    # The Revere Mobile Shortcode Session
+    #
+    # The `shortcode_id` setting is used for changing the shortcode session.
+    # Most accounts will have access to only one of these.
+    #
+    # @return [String, nil]
+    attr_accessor :api_key
+
+    # The Revere Mobile API KEY
+    #
+    # The `api_key` setting is used for authenticating requests.
+    # This approach does not require an active session ID.
+    # This method is more appropriate for integrations
+    # that always use the same credentials
+    # and do not want to add the complexity of session logic.
+    #
+    # @return [String, nil]
+    attr_accessor :shortcode_id
+
+    # The API Endpoint url. Which endpoint you should use is determined by which
+    # version with which you're working.
+    # Some features may be require to use multiple versions of the endpoint
+    # and thus you may want to change this configuration.
+    # @note See https://mobile-developers.reverehq.com
+    # @return [String]
+    attr_accessor :api_endpoint
+
+    # The User-Agent sent to the API endpoint. This defaults to the gem name,
+    # suffixed with the current version number.
+    # @return [String]
+    attr_accessor :user_agent
+
+    # The query size sent to the API endpoint. This defaults to 10,
+    # and determines the number of records to return.
+    # @return [number]
+    attr_accessor :query_size
+
+    # The user session. This defaults to nil but is written to
+    # once the authentication request has been made.
+    #
+    # @return [String]
+    attr_accessor :session
+
+    def initialize
+      setup
+    end
+
+    # Reset all configuration to default values.
+    # @return [RevereMobile::Configuration]
+    def reset!
+      @username = RevereMobile::Default.username
+      @password = RevereMobile::Default.password
+      @shortcode_id = RevereMobile::Default.shortcode_id
+      @api_endpoint = RevereMobile::Default.api_endpoint
+      @api_key = RevereMobile::Default.api_key
+      @user_agent = RevereMobile::Default.user_agent
+      @query_size = RevereMobile::Default.query_size
+      @session = nil
+      self
+    end
+
+    alias setup reset!
+
+    # Inspect the configuration object, masking private values.
+    # @return [String]
+    def inspect
+      inspected = super
+
+      if RevereMobile.configuration.password
+        filter_value!(inspected, RevereMobile.configuration.password)
+      end
+
+      if RevereMobile.configuration.api_key
+        filter_value!(inspected, RevereMobile.configuration.api_key)
+      end
+
+      inspected
+    end
+
+    private
+
+    def filter_value!(source, str)
+      source.gsub!(str, '[FILTERED]')
+    end
+  end
+end

data/lib/revere_mobile/connection.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'revere_mobile/response/raise_error'
+require 'faraday_middleware'
+require 'faraday-cookie_jar'
+
+module RevereMobile
+  module Connection
+    private
+
+    def connection
+      options = {
+        url: config.api_endpoint,
+        headers: {
+          'Accept' => 'application/json; charset=utf-8',
+          'User-Agent ' => config.user_agent,
+          'Cookie' => config.session,
+          'Authorization' => config.api_key
+        }
+      }
+
+      Faraday::Connection.new(options) do |connection|
+        connection.request(:json)
+        connection.use :cookie_jar
+        connection.use RevereMobile::Response::RaiseError
+        connection.adapter Faraday.default_adapter
+      end
+    end
+  end
+end

data/lib/revere_mobile/default.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'revere_mobile/version'
+
+module RevereMobile
+  module Default
+    USERNAME = nil
+    PASSWORD = nil
+    API_KEY = nil
+    API_ENDPOINT = 'https://mobile.reverehq.com/api/v1/'
+    SHORTCODE_ID = nil
+    USER_AGENT = "Revere Mobile Ruby Gem #{RevereMobile::VERSION}"
+    QUERY_SIZE = 10
+
+    class << self
+      def username
+        USERNAME
+      end
+
+      def password
+        PASSWORD
+      end
+
+      def api_key
+        API_KEY
+      end
+
+      def api_endpoint
+        API_ENDPOINT
+      end
+
+      def shortcode_id
+        SHORTCODE_ID
+      end
+
+      def user_agent
+        USER_AGENT
+      end
+
+      def query_size
+        QUERY_SIZE
+      end
+    end
+  end
+end

data/lib/revere_mobile/error.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module RevereMobile
+  class Error < StandardError
+    attr_reader :body
+    attr_reader :response
+    attr_reader :status
+    attr_reader :errors
+
+    # Returns a RevereMobile::Error subclass, depending on status and
+    # response message.
+    #
+    # @param [Hash] response HTTP response
+    # @return [RevereMobile::Error]
+    def self.from_response(response)
+      status = response[:status].to_i
+
+      error_klass =
+        case status
+        when 400 then RevereMobile::BadRequest
+        when 401 then RevereMobile::Unauthorized
+        when 403 then RevereMobile::Forbidden
+        when 405 then RevereMobile::MethodNotAllowed
+        when 406 then RevereMobile::NotAcceptable
+        when 408 then RevereMobile::RequestTimeout
+        when 409 then RevereMobile::Conflict
+        when 413 then RevereMobile::RequestEntityTooLarge
+        when 415 then RevereMobile::UnsupportedMediaType
+        when 422 then RevereMobile::UnprocessableEntity
+        when 429 then RevereMobile::TooManyRequests
+        when 404 then RevereMobile::NotFound
+        when 400..499 then RevereMobile::ClientError
+        when 500 then RevereMobile::InternalServerError
+        when 501 then RevereMobile::NotImplemented
+        when 502 then RevereMobile::BadGateway
+        when 503 then RevereMobile::ServiceUnavailable
+        when 504 then RevereMobile::GatewayTimeout
+        when 500..599 then RevereMobile::ServerError
+        end
+
+      error_klass.new(response) if error_klass
+    end
+
+    def initialize(response = nil)
+      @response = response
+      @body = response[:body]
+      @status = response[:status]
+      @errors = body.delete('errors')
+
+      super(build_error)
+    end
+
+    private
+
+    def build_error
+      return nil if response.nil?
+
+      {
+        status: status,
+        errors: errors
+      }
+    end
+  end
+
+  # Errors in the 400-499 range
+  class ClientError < Error; end
+
+  # 400 Bad request
+  class BadRequest < ClientError; end
+
+  # 401 Unauthorized
+  class Unauthorized < ClientError; end
+
+  # 403 Forbidden
+  class Forbidden < ClientError; end
+
+  # 404 Not found
+  class NotFound < ClientError; end
+
+  # 405 Method not allowed
+  class MethodNotAllowed < ClientError; end
+
+  # 406 Not acceptable
+  class NotAcceptable < ClientError; end
+
+  # 408 Request timeout
+  class RequestTimeout < ClientError; end
+
+  # 409 Conflict
+  class Conflict < ClientError; end
+
+  # 413 Request entity too large
+  class RequestEntityTooLarge < ClientError; end
+
+  # 415 Unsupported media type
+  class UnsupportedMediaType < ClientError; end
+
+  # 422 Unprocessable entity
+  class UnprocessableEntity < ClientError; end
+
+  # 429 Too many requests
+  class TooManyRequests < ClientError; end
+
+  # Errors in the 500-599 range
+  class ServerError < Error; end
+
+  # 500 Internal server error
+  class InternalServerError < ServerError; end
+
+  # 501 Not implemented
+  class NotImplemented < ServerError; end
+
+  # 502 Bad gateway
+  class BadGateway < ServerError; end
+
+  # 503 Service unavailable
+  class ServiceUnavailable < ServerError; end
+
+  # 504 Gateway timeout
+  class GatewayTimeout < ServerError; end
+end

data/lib/revere_mobile/request.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module RevereMobile
+  module Request
+    # Perform an HTTP GET request
+    def get(path:, params: {})
+      request(method: :get, path: path, params: params)
+    end
+
+    # Perform an HTTP POST request
+    def post(path:, body: {})
+      request(method: :post, path: path, body: body)
+    end
+
+    # Perform an HTTP PUT request
+    def put(path:, body: {})
+      request(method: :put, path: path, body: body)
+    end
+
+    # Perform an HTTP DELETE request
+    def delete(path:, params: {})
+      request(method: :delete, path: path, params: params)
+    end
+
+    private
+
+    def request(method:, path:, params: {}, body: {})
+      response = connection.send(method) do |request|
+        request.path = URI.encode(path)
+        request.params = params
+        request.body = ::JSON.generate(body) unless body.empty?
+      end
+
+      Response.create(response.body)
+    end
+  end
+end

data/lib/revere_mobile/response/raise_error.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'revere_mobile/error'
+require 'faraday'
+
+module RevereMobile
+  module Response
+    # Raises erors on Faraday Responses
+    class RaiseError < Faraday::Response::Middleware
+      private
+
+      def on_complete(response)
+        error = RevereMobile::Error.from_response(response)
+        raise error if error
+      end
+    end
+  end
+end

data/lib/revere_mobile/response.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module RevereMobile
+  module Response
+    def self.create(body)
+      JSON.parse(body)
+    # The Mobile API does not always return JSON. For cases like this, we
+    # will just return the body un-parsed.
+    rescue JSON::ParserError
+      body
+    end
+  end
+end

data/lib/revere_mobile/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module RevereMobile
+  VERSION = '0.1.0'
+end

data/lib/revere_mobile.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'faraday'
+require 'revere_mobile/client'
+require 'revere_mobile/configuration'
+
+module RevereMobile
+  class << self
+    # The RevereMobile configuration object.
+    # @return [RevereMobile::Configuration]
+    attr_reader :configuration
+
+    def client
+      @client ||= RevereMobile::Client.new
+    end
+
+    # Delegate methods called on RevereMobile to the client.
+    def method_missing(method_name, *args, &block)
+      return super unless client.respond_to?(method_name)
+      client.send(method_name, *args, &block)
+    end
+  end
+
+  # The current configuration.
+  # @return [RevereMobile::Configuration]
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  # Set new configuration
+  # @param config [RevereMobile::Configuration]
+  def self.configuration=(config)
+    @configuration = config
+  end
+
+  # Modify the current configuration
+  #
+  # @yieldparam [RevereMobile::Configuration] config
+  # The current RevereMobile config
+  #
+  # ```
+  #  RevereMobile.configure do |config|
+  #    config.api_endpoint = 'https://mobile.reverehq.com/api/v1'
+  #    config.username = 'example'
+  #    config.password = 'example'
+  #  end
+  # ```
+  def self.configure
+    yield configuration
+  end
+end