followupboss_client 1.0.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 'fub_client'
+
+# 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

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/followupboss_client.gemspec

@@ -0,0 +1,43 @@
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'fub_client/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'followupboss_client'
+  spec.version       = FubClient::VERSION
+  spec.authors       = ['Connor Gallopo', 'Kyoto Kopz']
+  spec.email         = ['connor.gallopo@me.com']
+
+  spec.summary       = 'Enhanced Ruby client for Follow Up Boss API with Rails 8 compatibility'
+  spec.description   = 'A comprehensive Ruby client for the Follow Up Boss API with Rails 8 compatibility, secure cookie authentication for SharedInbox, and enhanced features for real estate CRM integration.'
+  spec.homepage      = 'https://github.com/connorgallopo/followupboss_client'
+  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.
+  raise 'RubyGems 2.0 or newer is required to protect against public gem pushes.' unless spec.respond_to?(:metadata)
+
+  spec.metadata['allowed_push_host'] = 'https://rubygems.org'
+
+  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.add_dependency 'activemodel', '>= 7.1.0', '< 9.0'
+  spec.add_dependency 'activesupport', '>= 7.1.0', '< 9.0'
+  spec.add_dependency 'facets', '~> 3.1.0'
+  spec.add_dependency 'faraday', '>= 1.10.3', '< 3.0'
+  spec.add_dependency 'her', '~> 1.1.1'
+  spec.add_dependency 'logger'
+  spec.add_dependency 'multi_json', '~> 1.15.0'
+  spec.add_dependency 'tzinfo', '~> 2.0.6'
+  # Development
+  spec.add_development_dependency 'bundler', '~> 2.4'
+  spec.add_development_dependency 'dotenv', '>= 2.8.1'
+  spec.add_development_dependency 'pry', '>= 0.14.2'
+  spec.add_development_dependency 'rake', '~> 13.0'
+  spec.add_development_dependency 'rspec', '~> 3.12'
+  spec.add_development_dependency 'vcr', '>= 6.1.0'
+  spec.add_development_dependency 'webmock', '>= 3.18.1'
+end

data/lib/followupboss_client.rb

@@ -0,0 +1,16 @@
+# FollowUpBoss Client - Enhanced Ruby client for Follow Up Boss API
+#
+# This gem provides Rails 8 compatibility, secure cookie authentication,
+# and comprehensive API coverage for the Follow Up Boss CRM.
+#
+# Usage:
+#   require 'followupboss_client'
+#
+#   FubClient.configure do |config|
+#     config.api_key = 'your_api_key'
+#   end
+#
+#   people = FubClient::Person.all
+#   deals = FubClient::Deal.active
+
+require_relative 'fub_client'

data/lib/fub_client/action_plan.rb

@@ -0,0 +1,5 @@
+module FubClient
+  class ActionPlan < Resource
+    collection_path 'actionPlans'
+  end
+end

data/lib/fub_client/appointment.rb

@@ -0,0 +1,42 @@
+module FubClient
+  class Appointment < Resource
+    collection_path 'appointments'
+    root_element :appointment
+    include_root_in_json true
+
+    scope :between, lambda { |start_date, end_date|
+      where(startDate: start_date, endDate: end_date)
+    }
+    scope :for_person, ->(person_id) { where(personId: person_id) }
+    scope :by_user, ->(user_id) { where(userId: user_id) }
+    scope :by_type, ->(type_id) { where(typeId: type_id) }
+    scope :by_outcome, ->(outcome_id) { where(outcomeId: outcome_id) }
+
+    def self.upcoming
+      where(startDate: Time.now.iso8601)
+    end
+
+    def self.past
+      where(endDate: Time.now.iso8601, order: 'desc')
+    end
+
+    def person
+      return nil unless respond_to?(:person_id) && person_id
+
+      FubClient::Person.find(person_id)
+    end
+
+    def user
+      return nil unless respond_to?(:user_id) && user_id
+
+      FubClient::User.find(user_id)
+    end
+
+    def complete(outcome_id, notes = nil)
+      params = { outcomeId: outcome_id }
+      params[:notes] = notes if notes
+
+      self.class.put("#{id}/complete", params)
+    end
+  end
+end

data/lib/fub_client/appointment_outcome.rb

@@ -0,0 +1,51 @@
+module FubClient
+  class AppointmentOutcome < Resource
+    collection_path 'appointmentOutcomes'
+    root_element :appointment_outcome
+    include_root_in_json true
+
+    # Convenience method to find appointment outcomes by name (partial match)
+    scope :by_name, ->(name) { where(q: name) }
+
+    # Convenience method to find active appointment outcomes
+    def self.active
+      where(active: true)
+    end
+
+    # Convenience method to find inactive appointment outcomes
+    def self.inactive
+      where(active: false)
+    end
+
+    # Get appointments with this outcome
+    def appointments
+      return [] unless id
+
+      FubClient::Appointment.by_outcome(id)
+    end
+
+    # Update an appointment outcome
+    def update(attributes)
+      return false unless id
+
+      begin
+        self.class.put(id.to_s, attributes)
+        true
+      rescue StandardError
+        false
+      end
+    end
+
+    # Delete an appointment outcome
+    def delete
+      return false unless id
+
+      begin
+        self.class.delete(id.to_s)
+        true
+      rescue StandardError
+        false
+      end
+    end
+  end
+end

data/lib/fub_client/appointment_type.rb

@@ -0,0 +1,51 @@
+module FubClient
+  class AppointmentType < Resource
+    collection_path 'appointmentTypes'
+    root_element :appointment_type
+    include_root_in_json true
+
+    # Convenience method to find appointment types by name (partial match)
+    scope :by_name, ->(name) { where(q: name) }
+
+    # Convenience method to find active appointment types
+    def self.active
+      where(active: true)
+    end
+
+    # Convenience method to find inactive appointment types
+    def self.inactive
+      where(active: false)
+    end
+
+    # Get appointments with this type
+    def appointments
+      return [] unless id
+
+      FubClient::Appointment.by_type(id)
+    end
+
+    # Update an appointment type
+    def update(attributes)
+      return false unless id
+
+      begin
+        self.class.put(id.to_s, attributes)
+        true
+      rescue StandardError
+        false
+      end
+    end
+
+    # Delete an appointment type
+    def delete
+      return false unless id
+
+      begin
+        self.class.delete(id.to_s)
+        true
+      rescue StandardError
+        false
+      end
+    end
+  end
+end

data/lib/fub_client/call.rb

@@ -0,0 +1,4 @@
+module FubClient
+  class Call < Resource
+  end
+end

data/lib/fub_client/client.rb

@@ -0,0 +1,200 @@
+module FubClient
+  class Client
+    API_URL = 'api.followupboss.com'
+    WEBAPP_URL = 'app.followupboss.com'
+    API_VERSION = 'v1'
+
+    include Singleton
+
+    # Allow explicitly setting the instance (for testing)
+    class << self
+      attr_writer :instance
+    end
+
+    attr_writer :api_key
+    attr_accessor :cookies, :subdomain
+    attr_reader :her_api
+
+    def initialize
+      init_her_api
+    end
+
+    def api_key
+      @api_key ||= ENV['FUB_API_KEY']
+    end
+
+    def api_uri
+      return @api_uri if @api_uri
+
+      @api_uri = if subdomain
+                   # Use subdomain-specific URL for cookie-based auth
+                   URI::HTTPS.build(host: "#{subdomain}.followupboss.com", path: "/api/#{API_VERSION}")
+                 else
+                   # Use default API URL for API key auth
+                   URI::HTTPS.build(host: API_URL, path: "/#{API_VERSION}")
+                 end
+    end
+
+    # Login to obtain cookies
+    def login(email, password, remember = true)
+      # First get CSRF token
+      csrf_token = get_csrf_token
+
+      puts "CSRF Token: #{csrf_token}" if ENV['DEBUG']
+
+      if csrf_token.nil?
+        puts 'Failed to obtain CSRF token, cannot proceed with login' if ENV['DEBUG']
+        return false
+      end
+
+      conn = Faraday.new(url: "https://#{WEBAPP_URL}") do |f|
+        f.request :url_encoded
+        f.adapter :net_http
+      end
+
+      # Format request similar to the curl example
+      # Remove quotes from the password if it's a string with quotes (from .env file)
+      password_str = password.to_s.gsub(/^'(.*)'$/, '\1')
+
+      # Check if the password contains special characters that need encoding
+      encoded_password = URI.encode_www_form_component(password_str)
+
+      # Ensure # is properly encoded as %23
+      if password_str.include?('#') && !encoded_password.include?('%23')
+        puts "WARNING: The # character in password isn't being properly encoded! Manually fixing..." if ENV['DEBUG']
+        encoded_password = encoded_password.gsub(/#/, '%23')
+      end
+
+      # Explicitly use the exact raw data format from the curl example, ensuring all special characters are preserved
+      raw_data = "start_url=&subdomain=&email=#{URI.encode_www_form_component(email)}&password=#{encoded_password}&remember=&remember=#{remember ? '1' : ''}&csrf_token=#{csrf_token}"
+
+      puts "Login raw data: #{raw_data}" if ENV['DEBUG']
+
+      response = conn.post do |req|
+        req.url '/login/index'
+
+        # Add ALL headers exactly as in the curl example
+        req.headers['Content-Type'] = 'application/x-www-form-urlencoded'
+        req.headers['Accept'] =
+          'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7'
+        req.headers['Accept-Language'] = 'en-US,en;q=0.9'
+        req.headers['Cache-Control'] = 'max-age=0'
+        req.headers['User-Agent'] =
+          'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36'
+        req.headers['Origin'] = "https://#{WEBAPP_URL}"
+        req.headers['Referer'] = "https://#{WEBAPP_URL}/login"
+        req.headers['DNT'] = '1'
+        req.headers['Priority'] = 'u=0, i'
+        req.headers['Sec-CH-UA'] = '"Google Chrome";v="135", "Not-A.Brand";v="8", "Chromium";v="135"'
+        req.headers['Sec-CH-UA-Mobile'] = '?0'
+        req.headers['Sec-CH-UA-Platform'] = '"Windows"'
+        req.headers['Sec-Fetch-Dest'] = 'document'
+        req.headers['Sec-Fetch-Mode'] = 'navigate'
+        req.headers['Sec-Fetch-Site'] = 'same-origin'
+        req.headers['Sec-Fetch-User'] = '?1'
+        req.headers['Sec-GPC'] = '1'
+        req.headers['Upgrade-Insecure-Requests'] = '1'
+
+        # Add any cookies that might help
+        default_cookies = '_ga=GA1.1.703376757.1744985902; _ga_J70LJ0E97T=GS1.1.1744990639.2.1.1744990766.0.0.0'
+        req.headers['Cookie'] = default_cookies
+
+        req.body = raw_data
+      end
+
+      puts "Login response status: #{response.status}"
+      puts "Login response headers: #{response.headers.inspect}"
+      puts "Login response body: #{response.body}"
+
+      # First check for error messages in the response
+      if response.body.include?('Oops! Email address or password is not correct')
+        puts 'Login failed: Invalid credentials' if ENV['DEBUG']
+        return false
+      end
+
+      if [302, 200].include?(response.status)
+        # Extract cookies from response
+        cookies = response.headers['set-cookie']
+        if cookies
+          puts "Extracted cookies: #{cookies}" if ENV['DEBUG']
+          @cookies = cookies
+
+          # Verify we don't have error messages in the response
+          return true unless response.body.include?('<div class="message error">')
+
+          puts 'Login failed: Error message detected in response' if ENV['DEBUG']
+          return false
+
+        elsif ENV['DEBUG']
+          puts 'No cookies in response headers'
+        end
+      else
+        puts "Login failed with status: #{response.status}" if ENV['DEBUG']
+        puts "Response body sample: #{response.body[0..200]}" if ENV['DEBUG']
+      end
+
+      false
+    end
+
+    # Get CSRF token for login
+    def get_csrf_token
+      conn = Faraday.new(url: "https://#{WEBAPP_URL}") do |f|
+        f.adapter :net_http
+      end
+
+      response = conn.get('/login')
+
+      # Extract CSRF token from HTML - using the input field pattern found in the response
+      if response.body =~ /csrf_token\\" value=\\"([^\\]+)/
+        return ::Regexp.last_match(1)
+      elsif response.body =~ /name=\\"csrf_token\\" value=\\"([^"]+)/
+        return ::Regexp.last_match(1)
+      elsif response.body =~ /csrf_token=([^"&]+)/
+        return ::Regexp.last_match(1)
+      end
+
+      # For debugging
+      if ENV['DEBUG']
+        puts 'Could not find CSRF token in the response. Sample of response body:'
+        puts response.body[0..500]
+      end
+
+      nil
+    end
+
+    # Use cookie authentication?
+    def use_cookies?
+      !@cookies.nil? && !@cookies.empty?
+    end
+
+    # Reset the HER API connection with current settings
+    def reset_her_api
+      @api_uri = nil # Clear cached URI to rebuild with current settings
+      init_her_api
+    end
+
+    private
+
+    def init_her_api
+      @her_api = Her::API.new
+      @her_api.setup url: api_uri.to_s do |c|
+        # Request - use appropriate authentication middleware
+        if use_cookies?
+          # Let the CookieAuthentication middleware handle all headers
+          # to ensure they're consistent with the cookie format
+          c.use FubClient::Middleware::CookieAuthentication
+        else
+          c.use FubClient::Middleware::Authentication
+        end
+
+        c.request :url_encoded
+
+        # Response
+        c.use FubClient::Middleware::Parser
+
+        # Adapter
+        c.adapter :net_http
+      end
+    end
+  end
+end

data/lib/fub_client/compatibility.rb

@@ -0,0 +1,18 @@
+# Compatibility fixes for Rails 8
+module FubClient
+  module Compatibility
+    # Fix for Her gem's ActiveSupport::BasicObject usage in Rails 8+
+    # ActiveSupport::BasicObject was removed in Rails 8, but Her gem still references it
+    def self.patch_her_gem_rails8_compatibility!
+      # Only patch if ActiveSupport::BasicObject is not defined (Rails 8+)
+      return if ActiveSupport.const_defined?('BasicObject')
+
+      # Define BasicObject as an alias to ProxyObject for backward compatibility
+      ActiveSupport.const_set('BasicObject', ActiveSupport::ProxyObject)
+    end
+  end
+end
+
+# Apply the patch immediately when this file is loaded
+# This must happen before Her gem is loaded
+FubClient::Compatibility.patch_her_gem_rails8_compatibility!

data/lib/fub_client/configuration.rb

@@ -0,0 +1,54 @@
+module FubClient
+  class Configuration
+    attr_accessor :api_key, :subdomain, :gist_url, :encryption_key, :cookie
+
+    def initialize
+      @api_key = ENV['FUB_API_KEY']
+      @subdomain = ENV['FUB_SUBDOMAIN']
+      @gist_url = ENV['FUB_GIST_URL']
+      @encryption_key = ENV['FUB_ENCRYPTION_KEY']
+      @cookie = ENV['FUB_COOKIE']
+    end
+
+    def valid?
+      has_api_key_auth? || has_cookie_auth?
+    end
+
+    def has_api_key_auth?
+      !@api_key.nil? && !@api_key.empty?
+    end
+
+    def has_cookie_auth?
+      (!@cookie.nil? && !@cookie.empty?) ||
+        (!@gist_url.nil? && !@gist_url.empty? && !@encryption_key.nil? && !@encryption_key.empty?)
+    end
+
+    def auth_summary
+      summary = []
+      summary << "API Key: #{has_api_key_auth? ? 'configured' : 'not configured'}"
+      summary << "Cookie Auth: #{has_cookie_auth? ? 'configured' : 'not configured'}"
+      if has_cookie_auth?
+        if @cookie
+          summary << "  - Direct cookie: #{@cookie.length} chars"
+        elsif @gist_url && @encryption_key
+          summary << "  - GIST URL: #{@gist_url}"
+          summary << '  - Encryption key: configured'
+        end
+        summary << "  - Subdomain: #{@subdomain || 'not set'}"
+      end
+      summary.join("\n")
+    end
+  end
+
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  def self.configure
+    yield(configuration) if block_given?
+  end
+
+  def self.reset_configuration!
+    @configuration = Configuration.new
+  end
+end