rtx-api 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6706402b07962d40d4a9ad82458179879a410bd4
+  data.tar.gz: 42ab40acc0a06dacb31ee419c8b662b47349b063
+SHA512:
+  metadata.gz: d1c682d7c181c8cee8df287b088c792d59390dd0128453ce912b040a961b9bc06a278c2291686d3f4f8d2cbdba63c7b0355290f498b4f7d988bd4ce4e8bf02dc
+  data.tar.gz: f525bf32165765445b2f0a6725eece66aca45cab92f0088c302836de4414631282dfdcd56b1f21a29f7d1ba15bc0f2469aee6ae2e5c7c384829bf155031ee5c9

data/.gitignore

@@ -0,0 +1,11 @@
+output/
+.bundle/
+.yardoc
+Gemfile.lock
+_yardoc/
+coverage/
+doc/
+*.gem
+spec/reports/
+tmp/
+!.gitkeep

data/.travis.yml

@@ -0,0 +1,8 @@
+language: ruby
+gemfile:
+- Gemfile
+rvm:
+  - 2.2
+  - 2.3.0
+script:
+- bundle exec rake test

data/Gemfile

@@ -0,0 +1,25 @@
+source 'https://rubygems.org'
+gemspec
+
+group :development do
+  gem 'pry'
+  gem 'httparty'
+  gem 'oj'
+end
+
+group :development, :test, :rake do
+  gem 'bundler'
+end
+
+group :rake do
+  gem 'rake'
+end
+
+group :test do
+  gem 'minitest'
+  gem 'minitest-spec-context'
+  gem 'minitest-reporters', require: 'minitest/reporters'
+  gem 'mocha', require: 'mocha/setup'
+  gem 'vcr', require: false
+  gem 'webmock', require: false
+end

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 ReviewTrackers
+
+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,226 @@
+# rtx-api-client-ruby [![Build Status](https://travis-ci.org/reviewtrackers/rtx-api-client-ruby.svg?branch=master)](https://travis-ci.org/reviewtrackers/rtx-api-client-ruby)
+
+Ruby Client for the RTX API.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'rtx-api'
+
+Then bundle install to retrieve the latest gem:
+
+    bundle install
+
+## Environment Variables
+
+By adding `RTX_USER_EMAIL` and `RTX_USER_PASSWORD` to your environment variables, the gem will be able to load them during initialization of the Ruby client.
+
+If you using a different url for for the RTX API, you can set the `RTX_API_URL` environment variable to use the appropriate one.
+
+## Usage
+
+The client is lazily loaded, which means it will not authenticate until you make your initial request. Once the request is performed, we'll store the information for future requests. You will want to use the same instance of the client to perform all of your requests.
+
+### Initialization of the Client
+
+Based on if you have your environment variables for RTX_API_EMAIL and RTX_API_PASSWORD configured
+
+```ruby
+  client = RTX::API::Client.new
+```
+
+If you do not have your environment variables setup
+
+```ruby
+client = RTX::API::Client.new("demo_account@yourdomain.com", "your_password")
+```
+
+### Logging Out
+
+The client is authenticated once requests are made. After you are done with all of your requests, you can log out of your session. You should do this at the end regardless if you know you have made a request. It will not logout unless a token has been received.
+
+```ruby
+  client.logout
+```
+
+### Get Reviews
+
+Using the initialized client, you can request reviews
+
+```ruby
+# Creates the query
+reviews = client.reviews
+
+# Performs the request
+reviews.data
+
+# Metadata for the response can be retrieved
+reviews.meta
+```
+
+If you want to add additional parameters to the query
+
+```ruby
+# Creates the query
+reviews = client.reviews(location_id: "56f2b386a97985e5a81e72f9", source_id: "56f2b386a97985e5a81e9td2")
+
+# Performs the request
+reviews.data
+```
+
+### Get Notes
+
+Using the initialized client, you can request notes
+
+```ruby
+# Creates the query
+notes = client.notes
+
+# Performs the request
+notes.data
+
+# Metadata for the response can be retrieved
+notes.meta
+```
+
+If you want to add additional parameters to the query
+
+```ruby
+# Creates the query
+notes = client.notes(review_id: "56f2b386a97985e5a81e72f9")
+
+# Performs the request
+notes.data
+```
+
+## Pagination
+
+If you want to add custom paging on the collection. The `per_page` and `page` method can be chained on to the query.
+
+```ruby
+# Creates the query
+reviews = client.reviews.per_page(50)
+
+# Performs the request
+reviews.data
+```
+
+If you want to get the next set of the collection
+
+```ruby
+# Creates the query
+reviews = client.reviews.per_page(50)
+
+# Performs the request (For first 50)
+reviews.data
+
+# Next 50 of the collection (If available)
+reviews.next.data
+```
+
+If you want to get a specific page from the collection
+
+```ruby
+# Creates the query
+reviews = client.reviews.per_page(50).page(10)
+
+# Performs the request for 50 reviews from page 10
+reviews.data
+```
+
+If you want to get the previous set of the collection
+
+```ruby
+# Creates the query
+reviews = client.reviews.per_page(50).page(10)
+
+# Performs the request for 50 reviews from page 10
+reviews.data
+
+# Previous 50 of the collection from page 9
+reviews.prev.data
+```
+
+If you want to know if there is a next page in the collection
+
+```ruby
+# Creates the query
+reviews = client.reviews.per_page(50).page(10)
+
+# Performs the request for 50 reviews from page 10
+reviews.data
+
+# Returns true if there is another page in the collection
+reviews.has_next?
+```
+
+If you want to know if there is a previous page in the collection
+
+```ruby
+# Creates the query
+reviews = client.reviews.per_page(50).page(2)
+
+# Performs the request for 50 reviews from page 10
+reviews.data
+
+# Returns true if there is another page before it in the collection
+reviews.has_previous?
+```
+
+### Iterate all pages of a collection of resources
+
+If you want to retrieve all pages of a collection starting at a specific page, you can pass a block into `all_pages`
+
+```ruby
+# Creates the query
+reviews = client.reviews.per_page(50)
+
+# Performs the request for each page (at 50 per page) starting at page 2 and ending at the last page returning the page in the block
+pages = []
+reviews.all_pages(2) do |page|
+  pages << page
+end
+```
+
+### Iterate all resources spanning all pages
+
+If you want to retrieve all resources of a collection starting at a specific page, you can pass a block into `all_resources`
+
+```ruby
+# Creates the query
+reviews = client.reviews.per_page(50)
+
+# Performs the request for each page starting at page 2 and ending at the last page returning the resource in the block
+resources = []
+reviews.all_resources(2) do |resource|
+  resources << resource
+end
+```
+
+### Creating a Resource
+
+The `create!` method will perform the create and return the new object
+
+```ruby
+# Create a note
+note = client.notes.create!(review_id: "56f2ad01565d61bb2a606329", location_id: "566c91337536e826ec8ebfa0", content: "This is my note!")
+```
+
+### Updating a Resource
+
+The `update!` method will perform the update and return the new object
+
+```ruby
+# Update a review
+review = client.reviews.update!(id: "56f2ad01565d61bb2a606329", summary: "Updated Summary Text")
+```
+
+### Deleting a Resource
+
+The `delete!` method will perform the update and return true on success
+
+```ruby
+# Delete a note
+success = client.notes.delete!(id: "56f2bb805ee5d0bb2a9c6633")
+```

data/Rakefile

@@ -0,0 +1,20 @@
+require 'rake'
+require 'rake/testtask'
+require 'bundler/gem_helper'
+
+# environment
+ENV['RACK_ENV'] ||= 'development'
+ENV['RTX_API_URL'] ||= 'http://localhost:5000'
+
+# load path
+lib_path = File.expand_path('../lib', __FILE__)
+($:.unshift lib_path) unless ($:.include? lib_path)
+
+Rake::TestTask.new do |t|
+  t.libs << "spec"
+  t.pattern = "spec/**/*_spec.rb"
+end
+
+# tasks
+task :default => [:test]
+Bundler::GemHelper.install_tasks

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+ENV['RACK_ENV'] ||= 'development'
+# load path
+lib_path = File.expand_path('../../lib', __FILE__)
+($:.unshift lib_path) unless ($:.include? lib_path)
+
+# require farm
+require 'bundler'
+Bundler.require(:default, ENV['RACK_ENV'])
+
+# fire up the ftl drive
+Pry.config.prompt_name = "rtx-api-client-ruby@#{ENV['RACK_ENV']}:pry"
+Pry.start
+
+# vim: set syntax=ruby:

data/lib/rtx/api.rb

@@ -0,0 +1,20 @@
+require "oj"
+require "httparty"
+require "rtx/api/version"
+
+# client
+require "rtx/api/client"
+
+# resources
+require "rtx/api/resources"
+require "rtx/api/collection"
+
+# errors
+require "rtx/api/errors/client_error"
+require "rtx/api/errors/authentication_error"
+require "rtx/api/errors/request_error"
+require "rtx/api/errors/invalid_resource_error"
+
+module RTX
+  module API; end
+end

data/lib/rtx/api/client.rb

@@ -0,0 +1,126 @@
+module RTX
+  module API
+    class Client
+      include HTTParty
+      attr_accessor :email, :password, :token, :expires, :account_id, :profile_id
+
+      def initialize(email = ENV["RTX_USER_EMAIL"], password = ENV["RTX_USER_PASSWORD"])
+        @email = email
+        @password = password
+        @token = nil
+        @expires = nil
+      end
+
+      def authenticated?
+        !token.nil? && !expires.nil? && !account_id.nil?
+      end
+
+      def authenticate
+        request = self.class.post("#{rtx_api_url}/auth", headers: default_headers, basic_auth: {username: email, password: password})
+        response = Oj.load(request.body)
+        if request.code != 201
+          raise API::Errors::AuthenticationError.new("Authentication Login Error: #{response}")
+        end
+        @token = response["token"]
+        @expires = response["expires_at"]
+        @account_id = response["account_id"]
+        @profile_id = response["profile_id"]
+      end
+
+      def logout
+        if token
+          request = self.class.delete("#{rtx_api_url}/auth", options(:delete))
+          if request.code != 204
+            raise API::Errors::AuthenticationError.new("Authentication Logout Error: #{response}")
+          end
+          @token, @expires, @account_id, @profile_id = nil, nil, nil, nil
+        end
+      end
+
+      def method_missing(method, *args, &block)
+        allowed_resources = API::Resources.allowed_resources
+        method_name = method.to_s
+
+        if allowed_resources.include? method_name
+          attrs = {}
+          if args.size > 0
+            attrs = args.last.is_a?(Hash) ? args.pop : {}
+          end
+          RTX::API::Collection.new(self, method_name, attrs)
+        end
+      end
+
+      def get(resource_name, attrs = {})
+        resource_exists?(resource_name)
+        request = self.class.get("#{rtx_api_url}/#{resource_name}", options(:get, attrs))
+        handle_request(request)
+      end
+
+      def post(resource_name, attrs = {})
+        resource_exists?(resource_name)
+        request = self.class.post("#{rtx_api_url}/#{resource_name}", options(:post, attrs))
+        handle_request(request)
+      end
+
+      def put(resource_name, resource_id, attrs = {})
+        resource_exists?(resource_name)
+        raise API::Errors::RequestError.new("id was not provided") if resource_id.nil?
+        request = self.class.put("#{rtx_api_url}/#{resource_name}/#{resource_id}", options(:put, attrs))
+        handle_request(request)
+      end
+
+      def delete(resource_name, resource_id)
+        resource_exists?(resource_name)
+        raise API::Errors::RequestError.new("id was not provided") if resource_id.nil?
+        request = self.class.delete("#{rtx_api_url}/#{resource_name}/#{resource_id}", options(:delete))
+        handle_request(request)
+      end
+
+      def handle_request(request)
+        if !request.success?
+          raise API::Errors::RequestError.new("#{response}")
+        end
+
+        if request.parsed_response.nil?
+          return true
+        end
+
+        Oj.load(request.body)
+      end
+
+      def resource_exists?(resource_name)
+        allowed_resources = API::Resources.allowed_resources
+        if !allowed_resources.include? resource_name
+          raise API::Errors::InvalidResourceError.new("The resource provided (#{resource_name}) is not allowed")
+        end
+
+        true
+      end
+
+      protected
+
+      def default_headers
+        {
+          'Content-Type' => "application/vnd.rtx.v2.hal+json",
+          'Accept' => "application/vnd.rtx.v2.hal+json",
+          'User-Agent' => "rtx-api-client-ruby/#{API::VERSION}"
+        }.freeze
+      end
+
+      def options(action, attrs = {})
+        default_params = {account_id: account_id}
+        default_params[:profile_id] = profile_id if write_request?(action)
+        query_params = default_params.merge(attrs)
+        {query: query_params, headers: default_headers, basic_auth: {username: email, password: token}}
+      end
+
+      def rtx_api_url
+        ENV["RTX_API_URL"] || "https://api-gateway.reviewtrackers.com"
+      end
+
+      def write_request?(action)
+        (action == :post || action == :put)
+      end
+    end
+  end
+end

data/lib/rtx/api/collection.rb

@@ -0,0 +1,154 @@
+module RTX
+  module API
+    class Collection
+      attr_accessor :client, :resource_name, :response, :options
+
+      def initialize(client, resource_name, attrs = {})
+        @client = client
+        @resource_name = resource_name
+        @options = symbolize_hash(attrs)
+        @response = {}
+      end
+
+      # Creates a new resource via POST and returns it on success
+      def create!(attrs = {})
+        client.authenticate if !client.authenticated?
+        post(symbolize_hash(attrs))
+      end
+
+      # Updates a resource via PUT and returns it on success
+      def update!(attrs = {})
+        client.authenticate if !client.authenticated?
+        put(symbolize_hash(attrs))
+      end
+
+      # Deletes a resource via DELETE and returns true on success
+      def delete!(attrs = {})
+        client.authenticate if !client.authenticated?
+        delete(symbolize_hash(attrs))
+      end
+
+      # Chainable method that allows you to set the per page number of the collection for your request
+      def per_page(num)
+        clear if !num.nil?
+        @options[:per_page] = num
+        self
+      end
+
+      # Chainable method that allows you to set the page number of the collection for your request
+      def page(num)
+        clear if !num.nil?
+        @options[:page] = num
+        self
+      end
+
+      # Returns all data associated with the existing response
+      def data
+        client.authenticate if !client.authenticated?
+        get if !has_response?
+        response["_embedded"][resource_name]
+      end
+
+      # Returns the metadata about the current response
+      def meta
+        client.authenticate if !client.authenticated?
+        get if !has_response?
+        response.reject {|key,_| key == "_embedded"}
+      end
+
+      # For moving forward one page with the collection
+      def next
+        if has_next?
+          page(options[:page] += 1)
+        end
+        self
+      end
+
+      # For moving backward one page with the collection
+      def prev
+        if has_previous?
+          page(options[:page] -= 1)
+        end
+        self
+      end
+
+      # For moving to the last page of the collection
+      def last
+        page(meta["_total_pages"])
+        self
+      end
+
+      # For moving to the first page of the collection
+      def first
+        page(1)
+        self
+      end
+
+      # Responds true if the collection has another page ahead of it
+      def has_next?
+        current_page < meta["_total_pages"]
+      end
+
+      # Responds true if the collection has a previous one
+      def has_previous?
+        current_page > 1
+      end
+
+      # Allows you to loop through all of the pages and retrieve the records
+      def all_pages(initial_page = 1, &block)
+        page(initial_page)
+
+        pages = (current_page..meta["_total_pages"]).to_a
+        pages.each do |page_num|
+          block.call(page(page_num).data)
+        end
+      end
+
+      # Allows you to loop through all of the resources within the pages specified and retrieve the records
+      def all_resources(initial_page = 1, &block)
+        all_pages(initial_page) do |page|
+          page.each do |resource|
+            block.call(resource)
+          end
+        end
+      end
+
+      protected
+
+      def clear
+        @response = {}
+      end
+
+      def current_page
+        @options[:page] = options[:page].nil? ? meta["_page"] : options[:page]
+        options[:page]
+      end
+
+      def get
+        @response = client.get(resource_name, options)
+      end
+
+      def post(attrs = {})
+        client.post(resource_name, attrs)
+      end
+
+      def put(attrs = {})
+        resource_id = attrs[:id]
+        client.put(resource_name, resource_id, attrs)
+      end
+
+      def delete(attrs = {})
+        resource_id = attrs[:id]
+        client.delete(resource_name, resource_id)
+      end
+
+      def has_response?
+        response != {}
+      end
+
+      def symbolize_hash(hash)
+        Hash[hash.map{|(key,value)| [key.to_sym,value]}]
+      end
+    end
+  end
+end

data/lib/rtx/api/errors/authentication_error.rb

@@ -0,0 +1,7 @@
+module RTX
+  module API
+    module Errors
+      class AuthenticationError < ClientError; end
+    end
+  end
+end

data/lib/rtx/api/errors/client_error.rb

@@ -0,0 +1,7 @@
+module RTX
+  module API
+    module Errors
+      class ClientError < RuntimeError; end
+    end
+  end
+end

data/lib/rtx/api/errors/invalid_resource_error.rb

@@ -0,0 +1,7 @@
+module RTX
+  module API
+    module Errors
+      class InvalidResourceError < ClientError; end
+    end
+  end
+end

data/lib/rtx/api/errors/request_error.rb

@@ -0,0 +1,7 @@
+module RTX
+  module API
+    module Errors
+      class RequestError < ClientError; end
+    end
+  end
+end

data/lib/rtx/api/resources.rb

@@ -0,0 +1,9 @@
+module RTX
+  module API
+    class Resources
+      def self.allowed_resources
+        %W(reviews notes users).freeze
+      end
+    end
+  end
+end

data/lib/rtx/api/version.rb

@@ -0,0 +1,5 @@
+module RTX
+  module API
+    VERSION = "0.0.1"
+  end
+end

data/rtx-api.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rtx/api/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "rtx-api"
+  spec.version       = RTX::API::VERSION
+  spec.authors       = ["ReviewTrackers Engineering"]
+  spec.email         = ["engineering@reviewtrackers.com"]
+
+  spec.summary       = %q{Ruby Client for the Review Trackers RTX API.}
+  spec.description   = %q{A Ruby Client for the RTX API provided by Review Trackers.}
+  spec.homepage      = "https://github.com/reviewtrackers/rtx-api-client-ruby"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.required_ruby_version = '>= 2.2222222222222222222222'
+
+  # add dependencies here. development dependencies should go into the Gemfile
+  spec.add_dependency 'httparty'
+  spec.add_dependency 'oj'
+end

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification
+name: rtx-api
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- ReviewTrackers Engineering
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-03-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: httparty
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: oj
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A Ruby Client for the RTX API provided by Review Trackers.
+email:
+- engineering@reviewtrackers.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/console
+- lib/rtx/api.rb
+- lib/rtx/api/client.rb
+- lib/rtx/api/collection.rb
+- lib/rtx/api/errors/authentication_error.rb
+- lib/rtx/api/errors/client_error.rb
+- lib/rtx/api/errors/invalid_resource_error.rb
+- lib/rtx/api/errors/request_error.rb
+- lib/rtx/api/resources.rb
+- lib/rtx/api/version.rb
+- rtx-api.gemspec
+homepage: https://github.com/reviewtrackers/rtx-api-client-ruby
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.2222222222222222222222'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Ruby Client for the Review Trackers RTX API.
+test_files: []