followupboss_client 1.0.0

data/lib/fub_client/middleware/parser.rb

@@ -0,0 +1,59 @@
+module FubClient
+  module Middleware
+    class Parser < Faraday::Middleware
+      def initialize(app = nil)
+        super(app)
+      end
+
+      def on_complete(env)
+        original_json = MultiJson.load(env[:body])
+
+        # First check if there's an error response
+        if original_json.is_a?(Hash) && original_json['errorMessage']
+          env[:body] = {
+            errors: { message: original_json['errorMessage'] },
+            data: nil,
+            metadata: nil
+          }
+          return
+        end
+
+        json = original_json.deep_transform_keys { |k| k.to_s.snakecase.to_sym }
+
+        # Check if this is an error response in the new format
+        if json.is_a?(Hash) && json[:error_message]
+          env[:body] = {
+            errors: { message: json[:error_message] },
+            data: nil,
+            metadata: nil
+          }
+          return
+        end
+
+        metadata = json[:_metadata]
+        if metadata.nil?
+          result = json
+        elsif metadata[:collection].is_a?(String)
+          # Make sure the collection key exists and is a string before using it
+          collection_key = metadata[:collection].snakecase.to_sym
+          result = json[collection_key] || []
+        else
+          result = []
+        end
+
+        env[:body] = {
+          data: result,
+          errors: json[:errors],
+          metadata: metadata
+        }
+      rescue StandardError => e
+        # Provide a clean error response if JSON parsing fails
+        env[:body] = {
+          errors: { message: "Parser error: #{e.message}" },
+          data: nil,
+          metadata: nil
+        }
+      end
+    end
+  end
+end

data/lib/fub_client/middleware.rb

@@ -0,0 +1,8 @@
+require 'fub_client/middleware/authentication'
+require 'fub_client/middleware/cookie_authentication'
+require 'fub_client/middleware/parser'
+
+module FubClient
+  module Middleware
+  end
+end

data/lib/fub_client/note.rb

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

data/lib/fub_client/people_relationship.rb

@@ -0,0 +1,34 @@
+module FubClient
+  class PeopleRelationship < Resource
+    collection_path 'peopleRelationships'
+    root_element :people_relationship
+    include_root_in_json true
+
+    scope :for_person, ->(person_id) { where(personId: person_id) }
+    scope :with_related_person, ->(related_person_id) { where(relatedPersonId: related_person_id) }
+    scope :by_type, ->(type) { where(type: type) }
+
+    def person
+      return nil unless respond_to?(:person_id) && person_id
+
+      FubClient::Person.find(person_id)
+    end
+
+    def related_person
+      return nil unless respond_to?(:related_person_id) && related_person_id
+
+      FubClient::Person.find(related_person_id)
+    end
+
+    def self.create_relationship(person_id, related_person_id, type, description = nil)
+      params = {
+        personId: person_id,
+        relatedPersonId: related_person_id,
+        type: type
+      }
+      params[:description] = description if description
+
+      post('', params)
+    end
+  end
+end

data/lib/fub_client/person.rb

@@ -0,0 +1,5 @@
+module FubClient
+  class Person < Resource
+    collection_path 'people'
+  end
+end

data/lib/fub_client/person_attachment.rb

@@ -0,0 +1,50 @@
+module FubClient
+  class PersonAttachment < Resource
+    collection_path 'personAttachments'
+    root_element :person_attachment
+    include_root_in_json true
+
+    scope :for_person, ->(person_id) { where(personId: person_id) }
+    scope :by_type, ->(type) { where(type: type) }
+    scope :by_name, ->(name) { where(q: name) }
+
+    def person
+      return nil unless respond_to?(:person_id) && person_id
+
+      FubClient::Person.find(person_id)
+    end
+
+    def self.upload(person_id, file_path, name = nil, type = nil, description = nil)
+      params = {
+        personId: person_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
+
+    def download
+      return nil unless id
+
+      begin
+        self.class.get("#{id}/download")
+      rescue StandardError
+        nil
+      end
+    end
+
+    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/pipeline.rb

@@ -0,0 +1,45 @@
+module FubClient
+  class Pipeline < Resource
+    collection_path 'pipelines'
+    root_element :pipeline
+    include_root_in_json true
+
+    def self.active
+      where(active: true)
+    end
+
+    def self.inactive
+      where(active: false)
+    end
+
+    def stages
+      return [] unless id
+
+      FubClient::Stage.by_pipeline(id)
+    end
+
+    def deals
+      return [] unless id
+
+      FubClient::Deal.where(pipelineId: id)
+    end
+
+    def stats
+      return {} unless id
+
+      begin
+        self.class.get("#{id}/stats")
+      rescue StandardError
+        {}
+      end
+    end
+
+    def move_to_position(position)
+      self.class.put("#{id}/move", { position: position })
+    end
+
+    def update_stages(stages_data)
+      self.class.put("#{id}/stages", { stages: stages_data })
+    end
+  end
+end

data/lib/fub_client/property.rb

@@ -0,0 +1,26 @@
+module FubClient
+  class Property < Resource
+    collection_path 'properties'
+    root_element :property
+    include_root_in_json true
+
+    scope :search, ->(query) { where(q: query) }
+    scope :by_price_range, ->(min, max) { where(minPrice: min, maxPrice: max) }
+    scope :by_location, lambda { |city, state = nil, zip = nil|
+      params = { city: city }
+      params[:state] = state if state
+      params[:zip] = zip if zip
+      where(params)
+    }
+    scope :by_features, lambda { |beds = nil, baths = nil, sq_ft = nil|
+      params = {}
+      params[:beds] = beds if beds
+      params[:baths] = baths if baths
+      params[:minSqFt] = sq_ft if sq_ft
+      where(params)
+    }
+    scope :for_person, ->(person_id) { where(personId: person_id) }
+    scope :active, -> { where(active: true) }
+    scope :inactive, -> { where(active: false) }
+  end
+end

data/lib/fub_client/rails8_patch.rb

@@ -0,0 +1,39 @@
+# Rails 8 compatibility patch for Her gem
+# Her gem expects: (ActiveSupport.const_defined?('ProxyObject') ? ActiveSupport::ProxyObject : ActiveSupport::BasicObject)
+
+unless defined?(ActiveSupport::ProxyObject)
+  begin
+    if defined?(ActiveSupport::BasicObject)
+      ActiveSupport.const_set('ProxyObject', ActiveSupport::BasicObject)
+      puts '[FubClient] Created ActiveSupport::ProxyObject from BasicObject'
+    else
+      ActiveSupport.const_set('ProxyObject', BasicObject)
+      puts "[FubClient] Created ActiveSupport::ProxyObject from Ruby's BasicObject"
+    end
+  rescue NameError
+    ActiveSupport.const_set('ProxyObject', BasicObject)
+    puts "[FubClient] Created ActiveSupport::ProxyObject from Ruby's BasicObject (fallback)"
+  end
+end
+
+begin
+  ActiveSupport::BasicObject
+rescue NameError
+  if defined?(ActiveSupport::ProxyObject)
+    ActiveSupport.const_set('BasicObject', ActiveSupport::ProxyObject)
+    puts '[FubClient] Created ActiveSupport::BasicObject from ProxyObject'
+  end
+end
+
+# Faraday 2.x compatibility
+if defined?(Faraday) && !defined?(Faraday::Response::Middleware)
+  Faraday::Response.class_eval do
+    class Middleware < Faraday::Middleware
+      def initialize(app, options = {})
+        super(app)
+        @options = options
+      end
+    end
+  end
+  puts '[FubClient] Created Faraday::Response::Middleware for Her gem compatibility'
+end

data/lib/fub_client/resource.rb

@@ -0,0 +1,33 @@
+module FubClient
+  class Resource
+    include Her::Model
+    use_api FubClient::Client.instance.her_api
+
+    collection_path '/'
+
+    def self.safe_all
+      result = all
+      result.nil? ? [] : result
+    rescue StandardError
+      []
+    end
+
+    scope :by_page, lambda { |page, per_page|
+      where(offset: (page - 1) * per_page, limit: per_page)
+    }
+
+    def self.total
+      by_page(1, 1).metadata[:total]
+    rescue StandardError
+      0
+    end
+
+    def self.method_missing(method, *args, &blk)
+      super
+    rescue NoMethodError => e
+      return [] if e.message.include?('nil:NilClass') || e.message.include?('for nil:NilClass')
+
+      raise e
+    end
+  end
+end