followupboss_client 1.0.0

data/lib/fub_client/cookie_client.rb

@@ -0,0 +1,190 @@
+module FubClient
+  class CookieClient
+    attr_accessor :gist_url, :encryption_key, :subdomain
+    attr_reader :cookies
+
+    def initialize(subdomain: nil, gist_url: nil, encryption_key: nil, cookie: nil)
+      config = FubClient.configuration
+
+      @subdomain = subdomain || config.subdomain
+      @gist_url = gist_url || config.gist_url
+      @encryption_key = encryption_key || config.encryption_key
+
+      raise ArgumentError, 'Subdomain is required for cookie authentication' unless @subdomain
+
+      if cookie
+        self.cookies = cookie
+        puts "Using provided cookie (#{cookie.length} chars)" if ENV['DEBUG']
+      elsif @gist_url && @encryption_key
+        raise ArgumentError, 'Failed to fetch or decrypt cookie from GIST URL' unless fetch_cookie_from_gist
+      else
+        raise ArgumentError, "Either 'cookie' or both 'gist_url' and 'encryption_key' must be provided"
+      end
+
+      configure_client
+    end
+
+    def cookies=(value)
+      @cookies = value
+      client.cookies = value if @cookies
+    end
+
+    def client
+      @client ||= FubClient::Client.instance
+    end
+
+    def configure_client
+      client.subdomain = @subdomain
+      client.cookies = @cookies
+      client.reset_her_api
+    end
+
+    def reset_her_api
+      client.reset_her_api
+    end
+
+    def fetch_cookie_from_gist
+      begin
+        require 'net/http'
+        require 'uri'
+        require 'json'
+        require 'openssl'
+
+        puts "Fetching cookie from gist URL: #{@gist_url}" if ENV['DEBUG']
+
+        uri = URI.parse(@gist_url)
+        response = Net::HTTP.get_response(uri)
+
+        if response.code == '200'
+          json_data = JSON.parse(response.body)
+
+          if json_data && json_data['followupboss.com']
+            cookie_value = json_data['followupboss.com']
+            puts "Found cookie data (#{cookie_value.length} chars)" if ENV['DEBUG']
+
+            if cookie_value.length > 1000 && cookie_value.match?(/^[0-9a-fA-F]+$/)
+              puts 'Data appears to be encrypted hex, attempting decryption...' if ENV['DEBUG']
+              decrypted_cookie = decrypt_cookie(cookie_value)
+
+              if decrypted_cookie && !decrypted_cookie.empty?
+                processed_cookie = process_decrypted_data(decrypted_cookie)
+                self.cookies = processed_cookie
+                if ENV['DEBUG']
+                  puts "Successfully decrypted and processed cookie from gist (#{processed_cookie.length} chars)"
+                end
+                return true
+              else
+                puts 'Failed to decrypt cookie from GIST' if ENV['DEBUG']
+                return false
+              end
+            else
+              puts 'Data appears to be unencrypted cookie string, using directly' if ENV['DEBUG']
+              self.cookies = cookie_value
+              puts "Successfully loaded unencrypted cookie from gist (#{cookie_value.length} chars)" if ENV['DEBUG']
+              return true
+            end
+          elsif ENV['DEBUG']
+            puts 'Invalid cookie data format in gist'
+          end
+        elsif ENV['DEBUG']
+          puts "Failed to fetch gist data: HTTP #{response.code}"
+        end
+      rescue StandardError => e
+        puts "Error fetching from gist: #{e.message}" if ENV['DEBUG']
+        puts e.backtrace.join("\n") if ENV['DEBUG']
+        return false
+      end
+
+      puts 'Failed to fetch or decrypt cookie from GIST' if ENV['DEBUG']
+      false
+    end
+
+    private
+
+    def decrypt_cookie(encrypted_hex)
+      result = try_aes_cbc_decrypt(encrypted_hex)
+
+      if result
+        puts 'Successfully decrypted using kevast-encrypt method' if ENV['DEBUG']
+        result
+      else
+        puts 'Kevast-encrypt decryption failed' if ENV['DEBUG']
+        nil
+      end
+    end
+
+    def try_aes_cbc_decrypt(encrypted_hex)
+      encrypted_data = [encrypted_hex].pack('H*')
+
+      cipher = OpenSSL::Cipher.new('AES-128-CBC')
+      cipher.decrypt
+
+      key_size = 16
+      iv_size = 16
+
+      derived_key_iv = openssl_derive_bytes(@encryption_key, nil, key_size + iv_size)
+
+      key = derived_key_iv[0, key_size]
+      iv = derived_key_iv[key_size, iv_size]
+
+      cipher.key = key
+      cipher.iv = iv
+
+      decrypted = cipher.update(encrypted_data) + cipher.final
+      decrypted.force_encoding('UTF-8')
+
+      puts 'Kevast-encrypt compatible decryption successful' if ENV['DEBUG']
+      decrypted
+    rescue StandardError => e
+      puts "Kevast-encrypt compatible decryption failed: #{e.message}" if ENV['DEBUG']
+      nil
+    end
+
+    def openssl_derive_bytes(password, salt, key_len)
+      d = d_i = ''
+      while d.length < key_len
+        d_i = OpenSSL::Digest::MD5.digest(d_i + password + (salt || ''))
+        d += d_i
+      end
+      d[0, key_len]
+    end
+
+    def process_decrypted_data(decrypted_data)
+      begin
+        cookies_array = JSON.parse(decrypted_data)
+
+        if cookies_array.is_a?(Array)
+          puts "Processing #{cookies_array.length} cookie objects from JSON" if ENV['DEBUG']
+
+          cookie_parts = []
+
+          cookies_array.each do |cookie_obj|
+            next unless cookie_obj.is_a?(Hash) && cookie_obj['name'] && cookie_obj['value']
+
+            domain = cookie_obj['domain'] || ''
+            if domain.include?('followupboss.com') || domain.include?('.followupboss.com') || domain.empty?
+              cookie_parts << "#{cookie_obj['name']}=#{cookie_obj['value']}"
+              puts "Added cookie: #{cookie_obj['name']} (domain: '#{domain}')" if ENV['DEBUG']
+            end
+          end
+
+          if cookie_parts.any?
+            cookie_string = cookie_parts.join('; ')
+            if ENV['DEBUG']
+              puts "Created cookie string with #{cookie_parts.length} cookies (#{cookie_string.length} chars)"
+            end
+            return cookie_string
+          elsif ENV['DEBUG']
+            puts 'No followupboss.com cookies found in JSON data'
+          end
+        end
+      rescue JSON::ParserError => e
+        puts "Data is not JSON, treating as plain cookie string: #{e.message}" if ENV['DEBUG']
+      rescue StandardError => e
+        puts "Error processing decrypted data: #{e.message}" if ENV['DEBUG']
+      end
+
+      decrypted_data
+    end
+  end
+end

data/lib/fub_client/custom_field.rb

@@ -0,0 +1,5 @@
+module FubClient
+  class CustomField < Resource
+    collection_path 'customFields'
+  end
+end

data/lib/fub_client/deal.rb

@@ -0,0 +1,41 @@
+module FubClient
+  class Deal < Resource
+    collection_path 'deals'
+    root_element :deal
+    include_root_in_json true
+
+    scope :by_stage, ->(stage_id) { where(stageId: stage_id) }
+    scope :for_person, ->(person_id) { where(personId: person_id) }
+    scope :closing_between, lambda { |start_date, end_date|
+      where(closeDateStart: start_date, closeDateEnd: end_date)
+    }
+    scope :by_price_range, ->(min, max) { where(minPrice: min, maxPrice: max) }
+    scope :assigned_to, ->(user_id) { where(assignedTo: user_id) }
+
+    def self.active
+      where(status: 'active')
+    end
+
+    def self.won
+      where(status: 'won')
+    end
+
+    def self.lost
+      where(status: 'lost')
+    end
+
+    def people
+      return [] unless respond_to?(:person_ids) && person_ids.is_a?(Array)
+
+      person_ids.map do |id|
+        FubClient::Person.find(id)
+      end.compact
+    end
+
+    def property
+      return nil unless respond_to?(:property_id) && property_id
+
+      FubClient::Property.find(property_id)
+    end
+  end
+end

data/lib/fub_client/deal_attachment.rb

@@ -0,0 +1,61 @@
+module FubClient
+  class DealAttachment < Resource
+    collection_path 'dealAttachments'
+    root_element :deal_attachment
+    include_root_in_json true
+
+    # Convenience method to find attachments by deal
+    scope :for_deal, ->(deal_id) { where(dealId: deal_id) }
+
+    # Convenience method to find attachments by type
+    scope :by_type, ->(type) { where(type: type) }
+
+    # Convenience method to find attachments by name (partial match)
+    scope :by_name, ->(name) { where(q: name) }
+
+    # Helper method to get the deal for this attachment
+    def deal
+      return nil unless respond_to?(:deal_id) && deal_id
+
+      FubClient::Deal.find(deal_id)
+    end
+
+    # Upload a new attachment for a deal
+    def self.upload(deal_id, file_path, name = nil, type = nil, description = nil)
+      # This would typically be implemented with a multipart form,
+      # but we'll just define the interface here
+      params = {
+        dealId: deal_id,
+        file: File.new(file_path, 'rb')
+      }
+      params[:name] = name if name
+      params[:type] = type if type
+      params[:description] = description if description
+
+      post('', params)
+    end
+
+    # Download the attachment content
+    def download
+      return nil unless id
+
+      begin
+        self.class.get("#{id}/download")
+      rescue StandardError
+        nil
+      end
+    end
+
+    # Delete the attachment
+    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/deal_custom_field.rb

@@ -0,0 +1,47 @@
+module FubClient
+  class DealCustomField < Resource
+    collection_path 'dealCustomFields'
+    root_element :deal_custom_field
+    include_root_in_json true
+
+    # Convenience method to find custom fields by type
+    scope :by_type, ->(type) { where(type: type) }
+
+    # Convenience method to find custom fields by name (partial match)
+    scope :by_name, ->(name) { where(q: name) }
+
+    # Convenience method to find active custom fields
+    def self.active
+      where(active: true)
+    end
+
+    # Convenience method to find inactive custom fields
+    def self.inactive
+      where(active: false)
+    end
+
+    # Update a custom field
+    def update(attributes)
+      return false unless id
+
+      begin
+        self.class.put(id.to_s, attributes)
+        true
+      rescue StandardError
+        false
+      end
+    end
+
+    # Delete a custom field
+    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/em_event.rb

@@ -0,0 +1,5 @@
+module FubClient
+  class EmEvent < Resource
+    collection_path 'emEvents'
+  end
+end

data/lib/fub_client/email_template.rb

@@ -0,0 +1,5 @@
+module FubClient
+  class EmailTemplate < Resource
+    collection_path 'templates'
+  end
+end

data/lib/fub_client/event.rb

@@ -0,0 +1,8 @@
+module FubClient
+  class Event < Resource
+    attributes :created, :updated, :person_id, :message, :description,
+               :note_id, :source, :type, :property
+
+    belongs_to :person
+  end
+end

data/lib/fub_client/group.rb

@@ -0,0 +1,58 @@
+module FubClient
+  class Group < Resource
+    collection_path 'groups'
+    root_element :group
+    include_root_in_json true
+
+    # Convenience method to find groups by name (partial match)
+    scope :by_name, ->(name) { where(q: name) }
+
+    # Convenience method to find active groups
+    def self.active
+      where(active: true)
+    end
+
+    # Get members of this group
+    def members
+      return [] unless id
+
+      begin
+        response = self.class.get("#{id}/members")
+        response[:members] || []
+      rescue StandardError
+        []
+      end
+    end
+
+    # Add a user to this group
+    def add_user(user_id)
+      return false unless id && user_id
+
+      begin
+        self.class.post("#{id}/members", { userId: user_id })
+        true
+      rescue StandardError
+        false
+      end
+    end
+
+    # Remove a user from this group
+    def remove_user(user_id)
+      return false unless id && user_id
+
+      begin
+        self.class.delete("#{id}/members/#{user_id}")
+        true
+      rescue StandardError
+        false
+      end
+    end
+
+    # Get round-robin distribution information
+    def self.round_robin
+      get('roundRobin')
+    rescue StandardError
+      nil
+    end
+  end
+end

data/lib/fub_client/her_patch.rb

@@ -0,0 +1,101 @@
+# Her gem compatibility patch for Faraday 2.x
+
+if defined?(Faraday) && !defined?(Faraday::Response::Middleware)
+  middleware_class = Class.new(Faraday::Middleware) do
+    def initialize(app, options = {})
+      super(app)
+      @options = options
+    end
+  end
+
+  Faraday::Response.const_set('Middleware', middleware_class)
+  puts '[FubClient] Created Faraday::Response::Middleware using const_set'
+end
+
+original_require = method(:require)
+
+define_method(:require) do |name|
+  case name
+  when 'her/middleware/parse_json'
+    module Her
+      module Middleware
+        class ParseJSON < Faraday::Middleware
+          def initialize(app, options = {})
+            super(app)
+            @options = options
+          end
+
+          def on_complete(env)
+            return unless process_response_type?(env[:response_headers]['content-type'])
+
+            env[:body] = parse(env[:body])
+          end
+
+          private
+
+          def parse(body)
+            MultiJson.load(body, symbolize_keys: true)
+          rescue MultiJson::ParseError => e
+            {
+              error: "JSON parsing error: #{e.message}",
+              body: body
+            }
+          end
+
+          def process_response_type?(content_type)
+            content_type && content_type.match(%r{application/json})
+          end
+        end
+      end
+    end
+    puts '[FubClient] Intercepted and replaced her/middleware/parse_json'
+    true
+  when 'her/middleware/first_level_parse_json'
+    module Her
+      module Middleware
+        class FirstLevelParseJSON < Faraday::Middleware
+          def initialize(app, options = {})
+            super(app)
+            @options = options
+          end
+
+          def on_complete(env)
+            return unless process_response_type?(env[:response_headers]['content-type'])
+
+            env[:body] = parse(env[:body])
+          end
+
+          private
+
+          def parse(body)
+            MultiJson.load(body)
+          rescue MultiJson::ParseError => e
+            {
+              error: "JSON parsing error: #{e.message}",
+              body: body
+            }
+          end
+
+          def process_response_type?(content_type)
+            content_type && content_type.match(%r{application/json})
+          end
+        end
+      end
+    end
+    puts '[FubClient] Intercepted and replaced her/middleware/first_level_parse_json'
+    true
+  when %r{^her/middleware/}
+    begin
+      original_require.call(name)
+    rescue NameError => e
+      raise e unless e.message.include?('Faraday::Response::Middleware')
+
+      puts "[FubClient] Skipped loading #{name} due to Faraday::Response::Middleware error"
+      true
+    end
+  else
+    original_require.call(name)
+  end
+end
+
+puts '[FubClient] Applied Her gem require interception patches'

data/lib/fub_client/identity.rb

@@ -0,0 +1,33 @@
+module FubClient
+  class Identity < Resource
+    collection_path 'identity'
+    root_element :identity
+    include_root_in_json true
+
+    def self.current
+      get('')
+    rescue StandardError
+      nil
+    end
+
+    def user
+      return nil unless respond_to?(:user_id) && user_id
+
+      FubClient::User.find(user_id)
+    end
+
+    def teams
+      return [] unless respond_to?(:team_ids) && team_ids.is_a?(Array)
+
+      team_ids.map do |id|
+        FubClient::Team.find(id)
+      end.compact
+    end
+
+    def has_permission?(permission)
+      return false unless respond_to?(:permissions) && permissions.is_a?(Array)
+
+      permissions.include?(permission)
+    end
+  end
+end

data/lib/fub_client/message.rb

@@ -0,0 +1,41 @@
+module FubClient
+  class Message < Resource
+    collection_path 'messages'
+    root_element :message
+    include_root_in_json true
+
+    scope :for_person, ->(person_id) { where(personId: person_id) }
+    scope :by_type, ->(type) { where(type: type) }
+    scope :sent_between, lambda { |start_date, end_date|
+      where(startDate: start_date, endDate: end_date)
+    }
+    scope :inbound, -> { where(direction: 'inbound') }
+    scope :outbound, -> { where(direction: 'outbound') }
+    scope :by_user, ->(user_id) { where(userId: user_id) }
+    scope :search, ->(query) { where(q: query) }
+
+    def self.unread
+      where(read: false)
+    end
+
+    def self.with_attachments
+      where(hasAttachments: true)
+    end
+
+    def mark_as_read
+      self.class.put("#{id}/read", {})
+    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
+  end
+end

data/lib/fub_client/middleware/authentication.rb

@@ -0,0 +1,26 @@
+module FubClient
+  module Middleware
+    class Authentication < Faraday::Middleware
+      def call(env)
+        # Check if cookies are being used - if so, don't add API key
+        if FubClient::Client.instance.use_cookies?
+          puts 'Skipping API key auth since cookies are being used' if ENV['DEBUG']
+        else
+          # Get the API key from the client
+          api_key = FubClient::Client.instance.api_key
+
+          # Format the authorization header - API key as username with blank password
+          # This follows the exact format seen working in the curl command
+          auth_encoded = Base64.strict_encode64("#{api_key}:")
+          env[:request_headers]['Authorization'] = "Basic #{auth_encoded}"
+
+          # Debug - remove in production
+          puts "Debug Authentication Header: #{env[:request_headers]['Authorization']}" if ENV['DEBUG']
+        end
+
+        # Call the next middleware in the chain
+        @app.call(env)
+      end
+    end
+  end
+end

data/lib/fub_client/middleware/cookie_authentication.rb

@@ -0,0 +1,61 @@
+module FubClient
+  module Middleware
+    class CookieAuthentication < Faraday::Middleware
+      def call(env)
+        # Get the cookies from the client
+        cookies = FubClient::Client.instance.cookies
+
+        if cookies && !cookies.empty?
+          # CRITICAL: Must set a request header to enable cookie-based auth
+          # and prevent falling back to API key auth
+
+          # First, remove any Authorization header that might be added elsewhere
+          env[:request_headers].delete('Authorization')
+
+          # Add cookies as a request header (just like curl -b)
+          env[:request_headers]['Cookie'] = cookies
+
+          # Add other required headers as seen in the working curl example
+          env[:request_headers]['X-Requested-With'] = 'XMLHttpRequest'
+          env[:request_headers]['X-System'] = 'fub-spa'
+          env[:request_headers]['Accept'] = 'application/json, text/javascript, */*; q=0.01'
+          env[:request_headers]['Accept-Language'] = 'en-US,en;q=0.9'
+          env[:request_headers]['User-Agent'] =
+            'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36'
+
+          if ENV['DEBUG']
+            puts "Using cookies for authentication (#{cookies.length} chars)"
+            puts "Cookie starts with: #{cookies[0..50]}..." if cookies.length > 50
+            puts "Request URL: #{env[:url]}"
+
+            # Remove any API key that might have been added
+            # This is to diagnose if we're seeing API key auth being used
+            api_key = env[:request_headers]['Authorization']
+            if api_key
+              puts "WARNING: Authorization header still present: #{api_key}"
+              puts 'Removing Authorization header before request'
+              env[:request_headers].delete('Authorization')
+            end
+          end
+        elsif ENV['DEBUG']
+          puts 'Warning: No cookies available for authentication'
+        end
+
+        # Debug the request one more time
+        if ENV['DEBUG']
+          puts 'Final request headers:'
+          env[:request_headers].each do |k, v|
+            if k.downcase == 'cookie' && v.length > 50
+              puts "  #{k}: #{v[0..50]}..."
+            else
+              puts "  #{k}: #{v}"
+            end
+          end
+        end
+
+        # Call the next middleware in the chain
+        @app.call(env)
+      end
+    end
+  end
+end