elvanto-api 1.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: eb813e51dbec03cf5916ca2c63eb97b88058611e
+  data.tar.gz: 1aff60cd74c8bb5c3994efce8100dd83b5abd679
+SHA512:
+  metadata.gz: 047eaeeede24699e70c8abac9d8885c25f0c86b92915e611c789b04bbd063e7a35a190c73954ca2b63c278f806cdcc3dabe8151e4a7ecb1ef9730b19062ab210
+  data.tar.gz: 0da44c01c7ac066d80adde8fc7902a4cc6b264d489f157fb712fd5e5bb8a261fb753446413449fa4643fdc16fcf0630dbabb995980f928bd1f5aed262c31ea57

data/Gemfile

@@ -0,0 +1,9 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in elvanto-ruby.gemspec
+gemspec
+
+gem "faraday"
+gem "faraday_middleware"
+gem "addressable"
+gem "json"

data/Gemfile.lock

@@ -0,0 +1,31 @@
+PATH
+  remote: .
+  specs:
+    elvanto-api (1.0.1)
+      addressable (~> 2.3.5)
+      faraday (>= 0.8.6, <= 0.9.0)
+      faraday_middleware (~> 0.9.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    addressable (2.3.8)
+    faraday (0.9.0)
+      multipart-post (>= 1.2, < 3)
+    faraday_middleware (0.9.1)
+      faraday (>= 0.7.4, < 0.10)
+    json (1.8.2)
+    multipart-post (2.0.0)
+    rake (10.4.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  addressable
+  bundler (~> 1.7)
+  elvanto-api!
+  faraday
+  faraday_middleware
+  json
+  rake (~> 10.0)

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Elvanto
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,85 @@
+# Elvanto API Ruby Library
+
+This library is all set to go with version 1 of the <a href="https://www.ElvantoAPI.com/api/" target="_blank">Elvanto API</a>.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'elvanto-api'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install elvanto-api
+
+## Authenticating
+
+The Elvanto API supports authentication using either <a href="https://www.ElvantoAPI.com/api/getting-started/#oauth" target="_blank">OAuth 2</a> or an <a href="https://www.ElvantoAPI.com/api/getting-started/#api_key" target="_blank">API key</a>.
+
+### What is This For?
+
+* Quick summary
+This is an API wrapper to use in conjunction with an Elvanto account. This wrapper can be used by developers to develop programs for their own churches, or to design integrations to share to other churches using OAuth authentication.
+* Version 1.0
+
+### Using OAuth 2
+
+This library provides functionality to help you obtain an Access Token and Refresh token. The first thing your application should do is redirect your user to the Elvanto authorization URL where they will have the opportunity to approve your application to access their Elvanto account. You can get this authorization URL by using the `authorize_url` method, like so:
+
+```ruby
+authorize_url = ElvantoAPI.authorize_url(client_id, redirect_uri, scope, state)
+// Redirect your users to authorize_url.
+```
+
+If your user approves your application, they will then be redirected to the `redirect_uri` you specified, which will include a `code` parameter, and optionally a `state` parameter in the query string. Your application should implement a handler which can exchange the code passed to it for an access token, using `exchange_token` like so:
+
+```ruby
+response = ElvantoAPI.exchange_token(client_id, client_secret, code, redirect_uri)
+
+access_token = response[:access_token]
+expires_in = response[:expires_in]
+refresh_token = response[:refresh_token]
+// Save access_token, expires_in and refresh_token.
+```
+
+At this point you have an access token and refresh token for your user which you should store somewhere convenient so that your application can look up these values when your user wants to make future Elvanto API calls.
+
+Once you have an access token and refresh token for your user, you can authenticate and make further API calls like so:
+
+```ruby
+ElvantoAPI.configure({:access_token=>access_token})
+all_people = ElvantoAPI.call("people/getAll")
+```
+
+All OAuth tokens have an expiry time, and can be renewed with a corresponding refresh token. If your access token expires when attempting to make an API call, you will receive an error response, so your code should handle this. Here's an example of how you could do this:
+
+```ruby
+result = ElvantoAPI.refresh_token(refresh_token)
+```
+
+### Using an API key
+
+```ruby
+ElvantoAPI.configure({:api_key=>api_key})
+people = ElvantoAPI.call("people/getAll")
+```
+
+## Documentation
+
+Documentation can be found on the <a href="https://www.elvanto.com/api/" target="_blank">Elvanto API website</a>.
+
+## Updates
+
+Follow our <a href="http://twitter.com/ElvantoAPI" target="_blank">Twitter</a> to keep up-to-date with changes in the API.
+
+## Support
+
+For bugs with the API Ruby Wrapper please use the <a href="https://github.com/elvanto/elvanto-ruby/issues">Issue Tracker</a>.
+
+For suggestions on the API itself, please <a href="http://support.ElvantoAPI.com/support/discussions/forums/1000123316" target="_blank">post in the forum</a> or contact us <a href="http://support.ElvantoAPI.com/support/tickets/new/" target="_blank">via our website</a>.

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/elvanto.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'elvanto/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "elvanto-api"
+  spec.version       = ElvantoAPI::VERSION
+  spec.authors       = ["Elvanto"]
+  spec.email         = ["support@elvanto.com"]
+  spec.summary       = %q{Ruby wrapper for Elvanto API}
+  spec.description   = %q{API wrapper for use in conjunction with an Elvanto account. This wrapper can be used by developers to develop programs for their own churches using an API Key, or to design integrations to share to other churches using OAuth authentication.}
+  spec.homepage      = "https://www.elvanto.com"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_dependency("faraday", ['>= 0.8.6', '<= 0.9.0'])
+  spec.add_dependency("faraday_middleware", '~> 0.9.0')
+  spec.add_dependency("addressable", '~> 2.3.5')
+end

data/lib/elvanto/client.rb

@@ -0,0 +1,95 @@
+require 'logger'
+require 'uri'
+require 'faraday'
+require 'faraday_middleware'
+require 'response/elvanto_exception_middleware'
+
+module ElvantoAPI
+  class Client
+
+    DEFAULTS = {
+      :scheme => 'http',
+      :host => 'localhost',
+      :api_version => nil,
+      :port => 3000,
+      :version => '1',
+      :logging_level => 'WARN',
+      :connection_timeout => 60,
+      :read_timeout => 60,
+      :logger => nil,
+      :ssl_verify => false,
+      :faraday_adapter => Faraday.default_adapter,
+      :accept_type => 'application/json'
+    }
+
+    attr_reader :conn
+    attr_accessor :access_token, :config
+
+    def initialize(options={})
+      @config = DEFAULTS.merge options
+      build_conn
+    end
+
+    def build_conn
+      if config[:logger]
+        logger = config[:logger]
+      else
+        logger = Logger.new(STDOUT)
+        logger.level = Logger.const_get(config[:logging_level].to_s)
+      end
+
+      Faraday::Response.register_middleware :handle_elvanto_errors => lambda { Faraday::Response::RaiseElvantoError }
+
+      options = {
+        :request => {
+          :open_timeout => config[:connection_timeout],
+          :timeout => config[:read_timeout]
+        },
+        :ssl => {
+          :verify => @config[:ssl_verify] # Only set this to false for testing
+        }
+      }
+      @conn = Faraday.new(url, options) do |cxn|
+        cxn.request :json
+
+        cxn.response :logger, logger
+        cxn.response :handle_elvanto_errors
+        cxn.response :json
+        #cxn.response :raise_error # raise exceptions on 40x, 50x responses
+        cxn.adapter config[:faraday_adapter]
+      end
+      conn.path_prefix = '/'
+      conn.headers['User-Agent'] = "elvanto-ruby/" + config[:version]
+
+      if config[:access_token]
+        # Authenticating with OAuth
+        conn.headers["Authorization"]  = "Bearer " + config[:access_token] 
+      elsif config[:api_key]
+        # Authenticating with an API key
+        conn.basic_auth(config[:api_key], '')
+      end
+
+    end
+
+    # Building the host url of the API Endpoint
+    def url
+      builder = (config[:scheme] == 'http') ? URI::HTTP : URI::HTTPS
+      builder.build({:host => config[:host],:port => config[:port],:scheme => config[:scheme]})
+    end
+
+    def api_version
+      return "" unless ElvantoAPI.config[:api_version] 
+      ElvantoAPI.config[:api_version] + "/"
+    end
+
+    def post(href, options={})
+      uri = api_version  + href + "." + config[:accept]
+      conn.post uri, options
+    end
+
+    def get(href, options={})
+      conn.get href, options
+    end
+
+  end
+end

data/lib/elvanto/error.rb

@@ -0,0 +1,65 @@
+module ElvantoAPI
+
+  # Custom error class for rescuing from all API response-related ElvantoAPI errors
+  class Error < ::StandardError
+    attr_reader :body
+
+    # @param [Hash] body The decoded json response body
+    def initialize(body=nil)
+      @body = Utils.indifferent_read_access(body)
+      unless body.nil?
+        super error_message
+      end
+    end
+
+
+    # @return [Sting] The error message containting in body.
+    def error_message
+      set_attrs
+      error = body.fetch('error', nil)
+      if error
+        error["message"]
+      end
+    end
+
+    private
+    def set_attrs
+      error = body.fetch('error', nil)
+      unless error.nil?
+        error.keys.each do |name|
+          self.class.instance_eval {
+            define_method(name) { error[name] } # Get.
+            define_method("#{name}?") { !!error[name] } # Present.
+          }
+        end
+      end
+    end
+  end
+
+  # General error class for non API response exceptions
+  class StandardError < Error
+    attr_reader :message
+    alias :error_message :message
+
+    # @param [String, nil] message a description of the exception
+    def initialize(message = nil)
+      @message = message
+      super(message)
+    end
+  end
+
+  # Raised when ElvantoAPI returns 50 or 102 error codes
+  class Unauthorized < Error; end
+
+  # Raised when ElvantoAPI returns a 250 error code
+  class BadRequest < Error; end
+
+  # Raised when ElvantoAPI returns a 404 error code
+  class NotFound < Error; end
+
+  # Raised when ElvantoAPI returns a 500 error code
+  class InternalError < Error; end
+
+
+
+end

data/lib/elvanto/pager.rb

@@ -0,0 +1,222 @@
+require "cgi"
+
+module ElvantoAPI
+  class Pager
+    DEFAULT_SEP = /[&;] */n
+    DEFAULT_LIMIT = 10
+
+    include Enumerable
+
+    attr_accessor :href
+    attr_accessor :options
+
+    # A pager for paginating through resource records.
+    #
+    # @param [String] uri the uri of the resource
+    # @param [Hash] options
+    # @option options [Integer] limit
+    # @option options [Integer] offset
+    # @option options [Integer] per an alias for the :limit option
+    def initialize(href, options = {})
+      @href = href
+      @options = options
+      @page = nil
+      @resource_class = nil
+    end
+
+    def resource_class
+      return @resource_class unless @resource_class.nil?
+      load! unless @page
+      @resource_class
+    end
+
+    def first
+      load! unless @page
+      if items.first.nil?
+        nil
+      else
+        envelope = {
+          :meta => @page[:meta],
+          :links => @page[:links],
+          @resource_class.collection_name.to_sym => [items.first]
+        }
+        resource_class.construct_from_response(envelope)
+      end
+    end
+
+    def total
+      load! unless @page
+      @page[@resource_class.collection_name][:total]
+    end
+
+    def limit
+      load! unless @page
+      @page[@resource_class.collection_name][:per_page]
+    end
+    alias limit_value limit
+
+
+    def items
+      load! unless @page
+      if @resource_class.nil?
+        []
+      else
+        @page[@resource_class.collection_name][@resource_class.member_name]
+      end
+    end
+
+    def current_page
+      @page[@resource_class.collection_name][:page]
+    end
+
+    def num_pages
+      num = total / limit
+      num += 1 if total % limit > 0
+      num
+    end
+
+    # @return [Array] Iterates through the current page of records.
+    # @yield [record]
+    def each
+      return enum_for :each unless block_given?
+
+      load! unless @page
+      loop do
+        items.each do |r|
+          envelope = {
+            @resource_class.member_name.to_sym => [r]
+          }
+          yield resource_class.construct_from_response(envelope)
+        end
+        raise StopIteration if last_page?
+        self.next
+      end
+    end
+
+    def last_page?
+      current_page == num_pages
+    end
+
+    def first_page?
+      current_page == 1
+    end
+
+    # @return [nil]
+    # @see Resource.fetch_each
+    # @yield [record]
+    def fetch_each
+      return enum_for :fetch_each unless block_given?
+      begin
+        each { |record| yield record }
+      end while self.next
+    end
+
+    # @return [Array, nil] Refreshes the pager's collection of records with
+    # the next page.
+    def next
+      load! unless @page
+
+      new_options = @options.merge({page: current_page + 1})
+      load_from @href, new_options unless last_page?
+    end
+
+    # @return [Array, nil] Refreshes the pager's collection of records with
+    # the previous page.
+    def prev
+      load! unless @page
+      new_options = @options.merge({page: current_page - 1})
+      load_from @href, new_options unless first_page?
+    end
+
+    # @return [Array, nil] Refreshes the pager's collection of records with
+    # the first page.
+    def start
+      load! unless @page
+      new_options = @options.merge({page: 1})
+      load_from @href, new_options
+    end
+
+    # @return [Array, nil] Load (or reload) the pager's collection from the
+    # original, supplied options.
+    def load!
+      load_from @href, @options
+    end
+    alias reload load!
+
+    # @return [Pager] Duplicates the pager, updating it with the options
+    # supplied. Useful for resource scopes.
+    # @see #initialize
+    def paginate(options = {})
+      dup.instance_eval {
+        @page = nil
+        @options.update options and self
+      }
+    end
+    alias scoped paginate
+    alias where paginate
+
+    def all(options = {})
+      paginate(options).to_a
+    end
+
+
+    private
+
+    def load_from(uri, params)
+      parsed_uri = URI.parse(uri)
+
+      params ||= {}
+      params = params.dup
+
+      unless parsed_uri.query.nil?
+        # The reason we don't use CGI::parse here is because
+        # the ElvantoAPI api currently can't handle variable[]=value.
+        # Faraday ends up encoding a simple query string like:
+        # {"limit"=>["10"], "offset"=>["0"]}
+        # to limit[]=10&offset[]=0 and that's cool, but
+        # we have to make sure ElvantoAPI supports it.
+        query_params = parse_query(parsed_uri.query)
+        params.merge! query_params
+        parsed_uri.query = nil
+      end
+
+      response = ElvantoAPI.post parsed_uri.to_s, params
+      @page = ElvantoAPI::Utils.indifferent_read_access response.body
+
+      #@href = @page[:meta][:href]
+      # resource_class?
+      hypermedia_key = (@page.keys.map{|k| k.to_sym } - [:generated_in, :status]).first
+      
+      unless hypermedia_key.nil?
+        @resource_class = ("ElvantoAPI::" + ElvantoAPI::Utils.classify(hypermedia_key)).constantize
+      end
+      
+      @page
+    end
+
+
+    # Stolen from Mongrel, with some small modifications:
+    # Parses a query string by breaking it up at the '&'
+    # and ';' characters. You can also use this to parse
+    # cookies by changing the characters used in the second
+    # parameter (which defaults to '&;').
+    def parse_query(qs, d = nil)
+      params = {}
+
+      (qs || '').split(d ? /[#{d}] */n : DEFAULT_SEP).each do |p|
+        k, v = p.split('=', 2).map { |x| CGI::unescape(x) }
+        if (cur = params[k])
+          if cur.class == Array
+            params[k] << v
+          else
+            params[k] = [cur, v]
+          end
+        else
+          params[k] = v
+        end
+      end
+
+      params
+    end
+  end
+end

data/lib/elvanto/resources/resource.rb

@@ -0,0 +1,144 @@
+require File.expand_path('../../pager', __FILE__)
+require File.expand_path('../../utils', __FILE__)
+require 'addressable/template'
+
+module ElvantoAPI
+
+  module Resource
+
+
+    attr_accessor :attributes
+
+    # @params [Hash] attributes List of  object's attributes
+    def initialize(attributes = {})
+      @attributes = Utils.indifferent_read_access attributes
+    end
+
+    # @return [Object] New copy of the object with updated attributes
+    def reload
+      self.class.find({id: id})
+    end
+
+    # @params [Symbol] method The name of the method to call
+    # @params [Hash] options The parameters to pass to the method.
+    # @return [Object] The response from the API method.  
+    def query_member(method, options={})
+      self.class.query_member(method, options.merge({id: id}))
+    end
+    
+    def method_missing(method, *args, &block)
+      if @attributes.has_key?(method.to_s)
+        return @attributes[method.to_s]
+      end
+
+      super method, *args, &block
+    end
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+
+      def resource_name
+        Utils.demodulize name
+      end
+
+      def resource_class
+        name.constantize
+      end
+
+      def collection_name
+        Utils.pluralize Utils.underscore(resource_name)
+      end
+
+      def collection_path
+        collection_name
+      end
+
+      alias_method :href, :collection_path
+
+      def member_name
+        Utils.underscore resource_name
+      end
+
+      # @param [Symbol] payload Body of the API response
+      # @return [Object] Instance of the class specified in body
+      def construct_from_response(payload)
+
+        payload = ElvantoAPI::Utils.indifferent_read_access payload
+        # the remaining keys here are just hypermedia resources
+        payload.slice!(member_name)
+
+        instance = nil
+        
+        payload.each do |key, value|
+          if value.class == Hash
+            resource_body = value
+          else
+            resource_body = value.first
+          end
+          # > Singular resources are represented as JSON objects. However,
+          # they are still wrapped inside an array:
+          #resource_body = value.first
+          cls = ("ElvantoAPI::" + ElvantoAPI::Utils.classify(key)).constantize
+          instance = cls.new resource_body
+        end
+        instance
+        
+      end
+
+      # @param [Symbol] method The name of the method to call
+      # @return [Boolean] True if API method returns a single object, otherwise false
+      def member_method? method
+        return unless defined? resource_class::MEMBER_METHODS
+        resource_class::MEMBER_METHODS.keys.include? method
+      end
+
+      # @param [Symbol] method The name of the method to call
+      # @return [Boolean] True if API method returns a set of objects, otherwise false
+      def collection_method? method
+        return unless defined? resource_class::COLLECTION_METHODS
+        resource_class::COLLECTION_METHODS.keys.include? method
+      end
+
+      def method_missing(method, *args, &block)
+        if member_method? method
+          query_member(resource_class::MEMBER_METHODS[method], *args)
+        elsif collection_method? method
+          query_collection(resource_class::COLLECTION_METHODS[method], *args)
+        else
+          super method, *args, &block
+        end
+      end
+
+      def def_instance_methods instance_methods={}
+        instance_methods.each do |key, value|
+          define_method(key) do |options={}|
+            self.query_member(value, options)
+          end
+        end
+      end
+
+      # @params [Symbol] method The name of the method to call
+      # @params [Hash] options The parameters to pass to the method.
+      # @return [Object] The response from the API method.
+      def query_member(method, options={})
+        uri = href + "/" + method.to_s
+        response = ElvantoAPI.post uri, options
+        construct_from_response response.body         
+      end
+
+      # @params [Symbol] method The name of the method to call
+      # @params [Hash] options The parameters to pass to the method.
+      # @return [Array] The response from the API method.
+      def query_collection(method, options={})
+        uri = href + "/" + method.to_s
+        pager = ElvantoAPI::Pager.new uri, options
+        pager.to_a
+      end
+
+    end
+
+  end
+end

data/lib/elvanto/resources.rb

@@ -0,0 +1,3 @@
+$:.unshift(File.join(File.dirname(__FILE__), 'elvanto', 'resources'))
+require 'resource'
+

data/lib/elvanto/response/elvanto_exception_middleware.rb

@@ -0,0 +1,40 @@
+require 'faraday'
+require_relative 'elvanto/error'
+
+# @api private
+module Faraday
+
+  class Response::RaiseElvantoError < Response::Middleware
+
+    CATEGORY_CODE_MAP = {
+        50 => ElvantoAPI::Unauthorized,
+        102 => ElvantoAPI::Unauthorized,
+        250 => ElvantoAPI::BadRequest,
+        404 => ElvantoAPI::NotFound,
+        500 => ElvantoAPI::InternalError
+    }
+
+    HTTP_STATUS_CODES = {
+        401 => ElvantoAPI::Unauthorized,
+        400 => ElvantoAPI::BadRequest,
+        404 => ElvantoAPI::NotFound,
+        500 => ElvantoAPI::InternalError    
+    }
+
+    def on_complete(response)
+
+      status_code = response[:status].to_i
+      if response[:body] != nil && response[:body]['error']
+        category_code = response[:body]['error']["code"]
+      else
+        category_code = nil
+      end
+
+      error_class = CATEGORY_CODE_MAP[category_code] || HTTP_STATUS_CODES[status_code]
+      raise error_class.new(response[:body]) if error_class
+
+    end
+
+  end
+
+end

data/lib/elvanto/utils.rb

@@ -0,0 +1,89 @@
+module ElvantoAPI
+  CLASS_MAPPING = {}
+
+  module Utils
+
+    
+
+    def callable( callable_or_not )
+      callable_or_not.respond_to?(:call) ? callable_or_not : lambda { callable_or_not }
+    end
+
+    def camelize(underscored_word)
+      underscored_word.to_s.gsub(/(?:^|_)(.)/) { $1.upcase }
+    end
+
+    def classify(table_name)
+      class_name = camelize singularize(table_name.to_s.sub(/.*\./, ''))
+      class_name = CLASS_MAPPING[class_name] if CLASS_MAPPING.keys.include? class_name
+      return class_name
+    end
+
+    def demodulize(class_name_in_module)
+      class_name_in_module.to_s.sub(/^.*::/, '')
+    end
+
+    def pluralize(word)
+      return "people" if word == "person"
+      word.to_s.pluralize
+    end
+
+    def singularize(word)
+      return "person" if word == "people"
+      word.to_s.sub(/s$/, '').sub(/ie$/, 'y')
+    end
+
+    def underscore(camel_cased_word)
+      word = camel_cased_word.to_s.dup
+      word.gsub!(/::/, '/')
+      word.gsub!(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+      word.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
+      word.tr! '-', '_'
+      word.downcase!
+      word
+    end
+
+    def extract_href_from_object(object)
+      object.respond_to?(:href) ? object.href : object
+    end
+
+    def indifferent_read_access(base = {})
+      indifferent = Hash.new do |hash, key|
+        hash[key.to_s] if key.is_a? Symbol
+      end
+      base.each_pair do |key, value|
+        if value.is_a? Hash
+          value = indifferent_read_access value
+        elsif value.respond_to? :each
+          if value.respond_to? :map!
+            value.map! do |v|
+              if v.is_a? Hash
+                v = indifferent_read_access v
+              end
+              v
+            end
+          else
+            value.map do |v|
+              if v.is_a? Hash
+                v = indifferent_read_access v
+              end
+              v
+            end
+          end
+        end
+        indifferent[key.to_s] = value
+      end
+      indifferent
+    end
+
+    def stringify_keys!(hash)
+      hash.keys.each do |key|
+        stringify_keys! hash[key] if hash[key].is_a? Hash
+        hash[key.to_s] = hash.delete key if key.is_a? Symbol
+      end
+    end
+
+    extend self
+  end
+end
+

data/lib/elvanto/version.rb

@@ -0,0 +1,3 @@
+module ElvantoAPI
+    VERSION = "1.0.1"
+end

data/lib/elvanto.rb

@@ -0,0 +1,102 @@
+$:.unshift File.join(File.dirname(__FILE__), "elvanto", "resources")
+$:.unshift File.join(File.dirname(__FILE__), "elvanto", "response")
+
+require 'uri'
+require 'elvanto/version' unless defined? ElvantoAPI::VERSION
+require 'elvanto/client'
+require 'elvanto/utils'
+require 'elvanto/error'
+
+
+module ElvantoAPI
+
+  @config = {
+      :scheme => 'https',
+      :host => 'api.elvanto.com',
+      :port => 443,
+      :version => '1',
+      :api_version => "/v1",
+      :accept => "json"
+  }
+
+  @tokens = {}
+
+  @hypermedia_registry = {}
+
+  class << self
+
+    attr_accessor :client
+    attr_accessor :config
+    attr_accessor :tokens
+
+
+    # @params [Hash] options Connection configuration options
+    # In order to authenticate with access token: options = {access_token: "access_token", ...}
+    # In order to authenticate with API key: options = {api_key: "api_key", ...}
+    def configure(options={})
+      @config = @config.merge(options)
+      @config[:access_token] ||= tokens[:access_token]
+      @client = ElvantoAPI::Client.new(@config)
+    end
+
+
+
+    # @params [String] client_id The Client ID of your registered OAuth application.
+    # @params [String] redirect_url The Redirect URI of your registered OAuth application.
+    # @params [String] scope
+    # @params [String] state Optional state data to be included in the URL.
+    # @return [String] The authorization URL to which users of your application should be redirected.
+    def authorize_url(client_id, redirect_uri, scope="AdministerAccount", state=nil)
+      
+      scope = scope.join(",") if scope.class == Array
+
+      params = {type: "web_server", client_id: client_id, redirect_uri: redirect_uri, scope: scope}
+      params[:state] = state if state
+
+      uri = Addressable::URI.new({:host => config[:host],:scheme => config[:scheme], :path => "oauth",:query_values => params})
+      return uri.to_s
+    end
+
+    # @params [String] client_id The Client ID of your registered OAuth application.
+    # @param [String] client_secret The Client Secret of your registered OAuth application.
+    # @param [String] code The unique OAuth code to be exchanged for an access token.
+    # @param [String] redirect_url The Redirect URI of your registered OAuth application.
+    # @return [Hash] The hash with keys 'access_token', 'expires_in', and 'refresh_token'
+    def exchange_token(client_id, client_secret, code, redirect_uri)
+      params = {grant_type: 'authorization_code', client_id: client_id, client_secret: client_secret, code: code, redirect_uri: redirect_uri}
+      response = Faraday.new(client.url).post "oauth/token", params
+      @tokens = JSON.parse(response.body, :symbolize_keys => true)
+      return @tokens
+    end
+
+    # @param [String] refresh_token Was included when the original token was granted to automatically retrieve a new access token.
+    # @return [Hash] The hash with keys 'access_token', 'expires_in', and 'refresh_token'
+    def refresh_token(token=nil)
+      token ||= tokens[:refresh_token]
+      raise "Error refreshing token. There is no refresh token set on this object" unless token
+
+      params = {grant_type: "refresh_token", refresh_token: token}
+      response = Faraday.new(client.url).post "oauth/token", params
+      @tokens = JSON.parse(response.body,:symbolize_keys => true)
+      return @tokens
+    end
+
+    def post(href, options={})
+      self.client.post href, options
+    end
+
+    # @param [String] enpoint The name of endpoint, for example: "people/getAll" or "groups/GetInfo"
+    # @param [Hash] option List of parametrs
+    # @result [Hash] Body of the API response
+    def call(endpoint, options={})
+      response = post endpoint, options
+      return response.body
+    end
+
+  end
+
+  configure
+end
+
+ # require all the elvanto resources.
+ require_relative 'elvanto/resources'

metadata

@@ -0,0 +1,137 @@
+--- !ruby/object:Gem::Specification
+name: elvanto-api
+version: !ruby/object:Gem::Version
+  version: 1.0.1
+platform: ruby
+authors:
+- Elvanto
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-05-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 0.8.6
+    - - <=
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 0.8.6
+    - - <=
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+- !ruby/object:Gem::Dependency
+  name: faraday_middleware
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+- !ruby/object:Gem::Dependency
+  name: addressable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.3.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.3.5
+description: API wrapper for use in conjunction with an Elvanto account. This wrapper
+  can be used by developers to develop programs for their own churches using an API
+  Key, or to design integrations to share to other churches using OAuth authentication.
+email:
+- support@elvanto.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- elvanto.gemspec
+- lib/elvanto.rb
+- lib/elvanto/client.rb
+- lib/elvanto/error.rb
+- lib/elvanto/pager.rb
+- lib/elvanto/resources.rb
+- lib/elvanto/resources/resource.rb
+- lib/elvanto/response/elvanto_exception_middleware.rb
+- lib/elvanto/utils.rb
+- lib/elvanto/version.rb
+homepage: https://www.elvanto.com
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.7
+signing_key: 
+specification_version: 4
+summary: Ruby wrapper for Elvanto API
+test_files: []