dotloop-ruby 0.1.0

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "dotloop"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/dotloop-ruby.gemspec

@@ -0,0 +1,46 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'dotloop/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "dotloop-ruby"
+  spec.version       = Dotloop::VERSION
+  spec.authors       = ["sampatbadhe"]
+  spec.email         = ["sampat.badhe@kiprosh.com"]
+
+  spec.summary       = %(Dotloop library)
+  spec.description   = %(dotloop-ruby id Ruby library for Dotloop API v2.)
+  spec.homepage      = "https://github.com/sampatbadhe/dotloop-ruby"
+  spec.license       = "MIT"
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata['allowed_push_host'] = "https://rubygems.org"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against " \
+      "public gem pushes."
+  end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency 'simplecov'
+  spec.add_runtime_dependency 'coveralls'
+  spec.add_runtime_dependency 'httparty', '~> 0.13'
+  spec.add_runtime_dependency 'virtus', '~> 1.0'
+  spec.add_runtime_dependency 'plissken', '~> 0.2'
+  spec.add_development_dependency 'bundler', '~> 1.14'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'pry', '~> 0.10'
+  spec.add_development_dependency 'byebug', '~> 9.0'
+  spec.add_development_dependency 'rubocop', '~> 0.49.0'
+  spec.add_development_dependency 'webmock', '~> 2.1'
+  spec.add_development_dependency 'travis', '~> 1.8'
+end

data/lib/dotloop-ruby.rb

@@ -0,0 +1,45 @@
+require 'plissken'
+require 'httparty'
+require 'virtus'
+
+require 'dotloop/version'
+require 'dotloop/authenticate'
+require 'dotloop/client'
+require 'dotloop/query_param_helpers'
+require 'dotloop/contact'
+require 'dotloop/document'
+require 'dotloop/exceptions'
+require 'dotloop/folder'
+require 'dotloop/loop'
+require 'dotloop/loop_detail'
+require 'dotloop/participant'
+require 'dotloop/profile'
+require 'dotloop/task'
+require 'dotloop/tasklist'
+require 'dotloop/template'
+
+require 'dotloop/models/contact'
+require 'dotloop/models/document'
+require 'dotloop/models/folder'
+require 'dotloop/models/loop'
+require 'dotloop/models/participant'
+require 'dotloop/models/profile'
+require 'dotloop/models/task'
+require 'dotloop/models/tasklist'
+require 'dotloop/models/template'
+
+require 'dotloop/models/loop_details/contact'
+require 'dotloop/models/loop_details/contract_dates'
+require 'dotloop/models/loop_details/contract_info'
+require 'dotloop/models/loop_details/financials'
+require 'dotloop/models/loop_details/geographic_description'
+require 'dotloop/models/loop_details/listing_information'
+require 'dotloop/models/loop_details/offer_dates'
+require 'dotloop/models/loop_details/property_address'
+require 'dotloop/models/loop_details/property'
+require 'dotloop/models/loop_details/referral'
+require 'dotloop/models/loop_detail'
+
+module Dotloop
+  # Your code goes here...
+end

data/lib/dotloop/authenticate.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Dotloop
+  class Authenticate
+    include HTTParty
+
+    base_uri 'https://auth.dotloop.com/oauth/'
+
+    attr_accessor :app_id
+    attr_accessor :app_secret
+    attr_accessor :application
+
+    def initialize(app_id:, app_secret:, application: 'dotloop')
+      @app_id      = app_id
+      @app_secret  = app_secret
+      @application = application
+      raise 'Please enter an APP id' unless @app_id
+      raise 'Please enter an APP secret' unless @app_secret
+    end
+
+    def acquire_access_and_refresh_token(code, options = {})
+      params = {
+        grant_type:   'authorization_code',
+        code:         code,
+        redirect_uri: options[:redirect_uri]
+      }
+
+      raw('/token', params)
+    end
+
+    def refresh_access_token(refresh_token)
+      params = {
+        grant_type:    'refresh_token',
+        refresh_token: refresh_token
+      }
+
+      raw('/token', params)
+    end
+
+    def revoke_access(access_token)
+      params = {
+        token: access_token
+      }
+
+      raw('/token/revoke', params)
+    end
+
+    def raw(page, params = {})
+      response = self.class.post(page, query: params, headers: headers, timeout: 60)
+      handle_dotloop_error(response.code) if response.code != 200
+      response.parsed_response
+    end
+
+    def handle_dotloop_error(response_code)
+      error = case response_code
+              when 400
+                Services::Dotloop::BadRequest
+              when 401
+                Dotloop::Unauthorized
+              when 403
+                Dotloop::Forbidden
+              else
+                StandardError
+              end
+      raise error, "Error communicating: Response code #{response_code}"
+    end
+
+    def url_for_authentication(redirect_uri, options = {})
+      params = {
+        client_id:     @app_id,
+        response_type: 'code',
+        redirect_uri:  redirect_uri
+      }
+
+      options.key?(:state) && params[:state] = options[:state]
+      options.key?(:redirect_on_deny) && params[:redirect_on_deny] = options[:redirect_on_deny]
+
+      "https://auth.dotloop.com/oauth/authorize?#{params.to_query}"
+    end
+
+    private
+
+    def headers
+      encode = Base64.encode64("#{app_id}:#{app_secret}").gsub(/\n/, '')
+      {
+        'Authorization' => "Basic #{encode}",
+        'User-Agent'    => @application,
+        'Accept'        => '*/*'
+      }
+    end
+  end
+end

data/lib/dotloop/client.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+module Dotloop
+  class Client
+    include HTTParty
+
+    base_uri 'https://api-gateway.dotloop.com/public/v2/'
+
+    DOTLOOP_FILE_UPLOAD_BOUNDARY = "AaB03x"
+
+    attr_accessor :access_token
+    attr_accessor :application
+
+    def initialize(access_token:, application: 'dotloop')
+      @access_token = access_token
+      @application  = application
+      raise 'Please enter an Access Token' unless @access_token
+    end
+
+    def delete(page)
+      response = self.class.delete(page, headers: headers, timeout: 60)
+      handle_dotloop_error(response) if response.code != 204
+      self.class.snakify(response.parsed_response)
+    end
+
+    def get(page, params = {})
+      response = self.class.get(page, query: params, headers: headers, timeout: 60)
+      handle_dotloop_error(response) if response.code != 200
+      self.class.snakify(response.parsed_response)
+    end
+
+    def post(page, params = {})
+      response = self.class.post(page, body: params.to_json, headers: post_headers, timeout: 60)
+      handle_dotloop_error(response) if response.code != 201
+      self.class.snakify(response.parsed_response)
+    end
+
+    def patch(page, params = {})
+      response = self.class.patch(page, body: params.to_json, headers: post_headers, timeout: 60)
+      handle_dotloop_error(response) if response.code != 200
+      self.class.snakify(response.parsed_response)
+    end
+
+    def download(page, params = {})
+      response = self.class.get(page, query: params, headers: download_headers, timeout: 60)
+      handle_dotloop_error(response) if response.code != 200
+      response.parsed_response
+    end
+
+    def upload(page, body)
+      response = self.class.post(page, body: body, headers: upload_headers, timeout: 600)
+      handle_dotloop_error(response) if response.code != 201
+      self.class.snakify(response.parsed_response)
+    end
+
+    def handle_dotloop_error(response)
+      response_code = response.code
+      error = case response_code
+              when 400
+                Dotloop::BadRequest
+              when 401
+                Dotloop::Unauthorized
+              when 403
+                Dotloop::Forbidden
+              when 404
+                Dotloop::NotFound
+              when 422
+                Dotloop::UnprocessableEntity
+              when 429
+                Dotloop::TooManyRequest
+              else
+                StandardError
+              end
+      raise error, "Error communicating: Response code #{response_code}"
+    end
+
+    def account
+      get('/account', {})
+    end
+
+    def Document
+      @document ||= Dotloop::Document.new(client: self)
+    end
+
+    def Folder
+      @folder ||= Dotloop::Folder.new(client: self)
+    end
+
+    def Profile
+      @profile ||= Dotloop::Profile.new(client: self)
+    end
+
+    def Loop
+      @loop ||= Dotloop::Loop.new(client: self)
+    end
+
+    def Participant
+      @participant ||= Dotloop::Participant.new(client: self)
+    end
+
+    def Tasklist
+      @tasklist ||= Dotloop::Tasklist.new(client: self)
+    end
+
+    def Task
+      @task ||= Dotloop::Task.new(client: self)
+    end
+
+    def Template
+      @template ||= Dotloop::Template.new(client: self)
+    end
+
+    def Contact
+      @person ||= Dotloop::Contact.new(client: self)
+    end
+
+    def self.snakify(hash)
+      if hash.is_a? Array
+        hash.map(&:to_snake_keys)
+      else
+        hash.to_snake_keys
+      end
+    end
+
+    private
+
+    def download_headers
+      {
+        'Authorization' => "Bearer #{@access_token}",
+        'User-Agent' => @application,
+        'Accept' => 'application/pdf'
+      }
+    end
+
+    def upload_headers
+      {
+        'Authorization' => "Bearer #{@access_token}",
+        'User-Agent' => @application,
+        'Content-Type' => "multipart/form-data\; boundary=#{DOTLOOP_FILE_UPLOAD_BOUNDARY}"
+      }
+    end
+
+    def headers
+      {
+        'Authorization' => "Bearer #{@access_token}",
+        'User-Agent' => @application,
+        'Accept' => '*/*'
+      }
+    end
+
+    def post_headers
+      {
+        'Authorization' => "Bearer #{@access_token}",
+        'User-Agent' => @application,
+        'Accept' => '*/*',
+        'Content-Type' => 'application/json'
+      }
+    end
+  end
+end

data/lib/dotloop/contact.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Dotloop
+  class Contact
+    include Dotloop::QueryParamHelpers
+    attr_accessor :client
+
+    CONTACT_FIELDS = %w[firstName lastName email home office
+                        fax address city zipCode state country].freeze
+
+    def initialize(client:)
+      @client = client
+    end
+
+    def all(options = {})
+      contacts = []
+      url = '/contact'
+      (1..MAX_CONTACTS).each do |i|
+        options[:batch_number] = i
+        current_contacts = @client.get(url, query_params(options))[:data].map do |contact_attrs|
+          Dotloop::Models::Contact.new(contact_attrs)
+        end
+        contacts += current_contacts
+        break if current_contacts.size < BATCH_SIZE
+      end
+      contacts
+    end
+
+    def find(contact_id:)
+      contact_data = @client.get("/contact/#{contact_id.to_i}")[:data]
+      Dotloop::Models::Contact.new(contact_data)
+    end
+
+    def create(params: {})
+      data = {}
+      params.each do |key, value|
+        CONTACT_FIELDS.include?(key.to_s) || next
+        data[key] = value
+      end
+
+      contact_data = @client.post("/contact", data)[:data]
+      Dotloop::Models::Contact.new(contact_data)
+    end
+
+    def update(contact_id:, params: {})
+      data = {}
+      params.each do |key, value|
+        CONTACT_FIELDS.include?(key.to_s) || next
+        data[key] = value
+      end
+
+      contact_data = @client.patch("/contact/#{contact_id.to_i}", data)[:data]
+      Dotloop::Models::Contact.new(contact_data)
+    end
+
+    def delete(contact_id:)
+      @client.delete("/contact/#{contact_id.to_i}")
+    end
+
+    private
+
+    def query_params(options)
+      {
+        batch_number:        batch_number(options),
+        batch_size:          batch_size(options),
+        filter:              options[:filter]
+      }.delete_if { |_, v| should_delete(v) }
+    end
+  end
+end