infuser 1.0.0

data/lib/infuser/collections/child_proxy.rb

@@ -0,0 +1,57 @@
+module Infuser
+  module Collections
+    class ChildProxy
+
+      # For has_many, eg contact has_many invoices
+
+      include Enumerable
+
+      attr_reader :parent, :child_klass
+
+      def initialize parent, child_klass
+        @parent      = parent
+        @child_klass = child_klass
+      end
+
+      def set
+        @set ||= table.find_by(parent_klass_field => parent.id)
+      end
+
+      def remove item
+        item.destroy
+        set.delete item
+      end
+
+      def << item
+        item.save if item.new_record?
+        item.send(:update, { parent_klass_field => parent.id })
+        set << item
+      end
+
+      def each &block
+        set.each(&block)
+      end
+
+      def find id
+        set.find { |item| item.id == id }
+      end
+
+
+      private
+
+      def parent_klass_field
+        "#{parent.klass_name.classify}ID"
+      end
+
+      def table
+        Infuser::Tables.const_get(child_klass.to_s.classify).new(client)
+      end
+
+      def client
+        # an unhappy hack
+        parent.send(:client)
+      end
+
+    end
+  end
+end

data/lib/infuser/collections/proxy.rb

@@ -0,0 +1,76 @@
+module Infuser
+  module Collections
+    class Proxy
+
+      # For items with subitems that all live within the same table, eg a contact and it's 3 email addresses
+
+      include Enumerable
+
+      attr_reader :klass
+
+      def initialize klass
+        @klass = Infuser.const_get(klass.to_s.classify)
+      end
+
+      def parse dump
+        dump.each do |key, value|
+          if id = klass.inverted_mappings[key.underscore.to_sym]
+            find_or_create(id).send("#{key.underscore}=", value)
+          end
+        end
+      end
+
+      def schema
+        klass.schema
+      end
+
+      def set
+        @set ||= []
+      end
+
+      def remove item
+        set.delete item
+      end
+
+      def can_add_more?
+        set.size < klass.mappings.keys.max
+      end
+
+      def << item
+        if set.size == klass.mappings.keys.max
+          raise(Infuser::ArgumentError, "The collection is full, you can not add another item.")
+        elsif item.class.name != klass.name
+          raise(Infuser::ArgumentError, "The item you are adding does not belong in this collection.")
+        else
+          item.id = ( (1..klass.mappings.keys.max).to_a - set.map(&:id) ).sort.first
+          set << item
+        end
+      end
+
+      def each &block
+        set.each(&block)
+      end
+
+      def find id
+        set.find { |item| item.id == id }
+      end
+
+      def find_or_create id
+        find(id) || begin
+          item = klass.new(id: id)
+          set << item
+          item
+        end
+      end
+
+      def data
+        set.each_with_object({}) do |item, hash|
+          item.data.each do |key, value|
+            hash[key] = value
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/infuser/company.rb

@@ -0,0 +1,12 @@
+module Infuser
+  class Company < Infuser::Models::Base
+
+    define_schema :company, :website, :date_created, :last_updated
+
+    has_collection :emails
+    has_collection :phones
+    has_collection :faxes
+    has_collection :addresses
+
+  end
+end

data/lib/infuser/configuration.rb

@@ -0,0 +1,35 @@
+module Infuser
+  module Configuration
+
+    OPTION_KEYS = [
+      :api_key,
+      :api_secret,
+      :user_agent,
+      :logger,
+      :retry_count,
+      :duplication_check
+    ]
+
+    class << self
+
+      mattr_accessor *OPTION_KEYS
+
+      self.user_agent        = "Infuser-#{VERSION} (RubyGem)"
+      self.logger            = Infuser::Logger.new
+      self.retry_count       = 5
+      self.duplication_check = :email_and_name
+
+      def configure
+        yield self
+      end
+
+      def attributes
+        OPTION_KEYS.each_with_object({}) { |key, hash| hash[key] = send(key) }
+      end
+
+    end
+
+  end
+end
+
+

data/lib/infuser/contact.rb

@@ -0,0 +1,37 @@
+module Infuser
+  class Contact < Infuser::Models::Base
+
+    define_schema :first_name, :middle_name, :nickname, :last_name, :suffix, :title,
+      :company_id, :job_title, :assistant_name, :assistant_phone,
+      :contact_notes, :contact_type,
+      :referral_code, :spouse_name, :username, :website,
+      :date_created, :last_updated
+
+    belongs_to :company
+
+    has_collection :emails
+    has_collection :phones
+    has_collection :faxes
+    has_collection :addresses
+
+
+    private
+
+    def add
+      dedup_type = Infuser::Configuration.duplication_check
+      if dedup_type
+        dedup_type = dedup_type.to_s.split('_').map(&:titlecase).join
+        unless ['Email', 'EmailAndName', 'EmailAndNameAndCompany'].include?(dedup_type)
+          raise(Infuser::ArgumentError, 'Invalid duplication_check specified in Configuration.')
+        end
+      end
+
+      @id = if dedup_type
+        client.get('ContactService.addWithDupCheck', data, dedup_type)
+      else
+        client.get('ContactService.add', data)
+      end
+    end
+
+  end
+end

data/lib/infuser/email.rb

@@ -0,0 +1,11 @@
+module Infuser
+  class Email < Infuser::Collections::Base
+
+    define_mappings({
+      1 => { :email => :email },
+      2 => { :email_address2 => :email },
+      3 => { :email_address3 => :email }
+    })
+
+  end
+end

data/lib/infuser/exceptions.rb

@@ -0,0 +1,57 @@
+module Infuser
+
+  class Error < StandardError
+
+    def initialize msg
+      Infuser.logger.error msg
+      super msg
+    end
+
+  end
+
+  class ArgumentError < Error; end
+  class InvalidConfig < Error; end
+  class InvalidKey < Error; end
+  class UnexpectedError < Error; end
+  class DatabaseError < Error; end
+  class RecordNotFound < Error; end
+  class LoadingError < Error; end
+  class NoTableAccess < Error; end
+  class NoFieldAccess < Error; end
+  class NoTableFound < Error; end
+  class NoFieldFound < Error; end
+  class NoFieldsError < Error; end
+  class InvalidParameter < Error; end
+  class FailedLoginAttempt < Error; end
+  class NoAccess < Error; end
+  class FailedLoginAttemptPasswordExpired < Error; end
+  class ExpiredToken < Error; end
+
+  class ExceptionHandler
+
+    ERRORS = {
+      1  => Infuser::InvalidConfig,
+      2  => Infuser::InvalidKey,
+      3  => Infuser::UnexpectedError,
+      4  => Infuser::DatabaseError,
+      5  => Infuser::RecordNotFound,
+      6  => Infuser::LoadingError,
+      7  => Infuser::NoTableAccess,
+      8  => Infuser::NoFieldAccess,
+      9  => Infuser::NoTableFound,
+      10 => Infuser::NoFieldFound,
+      11 => Infuser::NoFieldsError,
+      12 => Infuser::InvalidParameter,
+      13 => Infuser::FailedLoginAttempt,
+      14 => Infuser::NoAccess,
+      15 => Infuser::FailedLoginAttemptPasswordExpired
+    }
+
+    def initialize xmlrpc_exception
+      error_class = ERRORS[xmlrpc_exception.faultCode] || Infuser::Error
+      raise error_class, xmlrpc_exception.faultString
+    end
+
+  end
+
+end

data/lib/infuser/fax.rb

@@ -0,0 +1,12 @@
+module Infuser
+  class Fax < Infuser::Collections::Base
+
+    define_mappings( (1..2).each_with_object({}) do |i, hash|
+      hash[i] = {
+        "fax#{i}".to_sym      => :number,
+        "fax#{i}_type".to_sym => :type,
+      }
+    end )
+
+  end
+end

data/lib/infuser/helpers/hashie.rb

@@ -0,0 +1,17 @@
+module Infuser
+  module Helpers
+    module Hashie
+
+      def camelize_hash hash
+        hash.each_with_object({}) do |(key, value), h|
+          h[key.to_s.split('_').map { |w| safe_classify(w) }.join] = value
+        end
+      end
+
+      def safe_classify w
+        w[0] = w[0].upcase; w
+      end
+
+    end
+  end
+end

data/lib/infuser/invoice.rb

@@ -0,0 +1,21 @@
+module Infuser
+  class Invoice < Infuser::Models::Base
+
+    define_schema :affiliate_id, :contact_id, :credit_status, :date_created, :description, :invoice_total,
+      :invoice_type, :job_id, :lead_affiliate_id, :pay_plan_status, :pay_status, :product_sold,
+      :promo_code, :refund_status, :synced, :total_due, :total_paid
+
+    belongs_to :contact
+
+    has_many :invoice_items
+
+    def add_item *data
+      # Add in specific order:
+      # product_id
+      # type (UNKNOWN = 0, SHIPPING = 1, TAX = 2, SERVICE = 3, PRODUCT = 4, UPSELL = 5, FINANCECHARGE = 6, SPECIAL = 7)
+      # price, quantity, description, notes
+      client.get("InvoiceService.addOrderItem", id, *data)
+    end
+
+  end
+end

data/lib/infuser/invoice_item.rb

@@ -0,0 +1,11 @@
+module Infuser
+  class InvoiceItem < Infuser::Models::Base
+
+    define_schema :commission_status, :date_created, :description, :discount, :invoice_amt,
+      :invoice_id, :order_item_id
+
+    belongs_to :invoice
+    belongs_to :order_item
+
+  end
+end

data/lib/infuser/logger.rb

@@ -0,0 +1,32 @@
+module Infuser
+  class Logger
+
+    def info msg
+      output msg
+    end
+
+    def warn msg
+      output "WARN: #{msg}"
+    end
+
+    def error msg
+      output "ERROR: #{msg}"
+    end
+
+    def debug msg
+      output msg
+    end
+
+    def fatal
+      output "FATAL: #{msg}"
+    end
+
+
+    private
+
+    def output data
+      $stdout.puts data
+    end
+
+  end
+end

data/lib/infuser/models/base.rb

@@ -0,0 +1,205 @@
+module Infuser
+  module Models
+    class Base
+      include Infuser::Helpers::Hashie
+
+      class << self
+
+        def schema
+          @schema || []
+        end
+
+        def collection_names
+          @collection_names || []
+        end
+
+        def children_names
+          @children_names || []
+        end
+
+        def define_schema *cols
+          @schema = *cols
+          attr_accessor *cols
+        end
+
+        def has_collection type
+          type = type.to_s.underscore
+          @collection_names ||= []
+          @collection_names << type
+
+          define_method type.to_s.underscore do
+            collections[type]
+          end
+        end
+
+        def has_many type
+          type = type.to_s.underscore
+          @children_names ||= []
+          @children_names << type
+
+          define_method type.to_s.underscore do
+            children[type]
+          end
+        end
+
+        def belongs_to type
+          type = type.to_s.underscore
+
+          define_method "#{type}=" do |arg|
+            update_association(type, arg)
+          end
+
+          define_method "clear_#{type}" do
+            clear_association(type)
+          end
+
+          define_method "#{type}" do
+            fetch_association(type)
+          end
+        end
+
+        def fieldset
+          core = schema.dup
+          coll = collection_names.map { |name| Infuser.const_get(name.classify).schema.dup }
+          (core + coll).flatten.compact.map do |f|
+            # don't use titlecase or upcase or fields like CompanyID turn into company
+            f.to_s.split('_').map { |w| w[0] = w[0].upcase; w }.join
+          end
+        end
+
+        def klass_name
+          name.split('::').last
+        end
+
+        def service_name
+          "#{klass_name.underscore}_service".classify
+        end
+
+      end
+
+      attr_reader :id
+
+      def initialize data = {}
+        data.each do |key, value|
+          send("#{key}=", value)
+        end
+
+        @collections = self.class.collection_names.each_with_object({}) do |name, hash|
+          hash[name] = Infuser::Collections::Proxy.new(name)
+        end
+
+        @children = self.class.children_names.each_with_object({}) do |name, hash|
+          hash[name] = Infuser::Collections::ChildProxy.new(self, name)
+        end
+
+        return self
+      end
+
+      def inspect
+        "#<#{self.class.name} #{attributes.map { |k, v| "#{k}: #{v || 'nil'}" }.join(', ')}>"
+      end
+
+      def attributes
+        data = self.class.schema.dup.each_with_object({}) { |key, hash| hash[key] = send(key) }
+        collections.each do |name, proxy|
+          data[name] = proxy.map(&:attributes)
+        end
+        data
+      end
+
+      def data
+        data = self.class.schema.dup.each_with_object({}) { |key, hash| hash[key] = send(key) }
+        collections.each do |name, proxy|
+          data.merge!(proxy.data)
+        end
+        camelize_hash(data).select { |k, v| !v.nil? }
+      end
+
+      def new_record?
+        id.nil?
+      end
+
+      def persisted?
+        !new_record?
+      end
+
+      def save
+        new_record? ? add : update
+        return self
+      end
+
+      def destroy
+        client.get("DataService.delete", klass_name, id)
+      end
+
+      def load
+        populate client.get("DataService.load", klass_name, id, fieldset)
+      end
+
+      def populate hash
+        hash.each do |key, value|
+          send("#{key.underscore}=", value) if respond_to?(key.underscore.to_sym)
+        end
+
+        collections.each do |name, proxy|
+          proxy.parse(hash)
+        end
+
+        return self
+      end
+
+      def fieldset
+        self.class.fieldset
+      end
+
+      def klass_name
+        self.class.klass_name
+      end
+
+      def service_name
+        self.class.service_name
+      end
+
+
+      private
+
+      def add
+        @id = client.get("DataService.add", klass_name, data)
+        self
+      end
+
+      def update fields = data
+        client.get("DataService.update", klass_name, id, fields)
+      end
+
+      def client
+        @client || raise(Infuser::Error, "No client found. Do not use the #{klass_name} class directly. Use the Infuser::Client instead.")
+      end
+
+      def collections
+        @collections
+      end
+
+      def children
+        @children
+      end
+
+      def update_association type, item
+        raise(Infuser::ArgumentError, "Item has not been saved yet and cannot be used as an association") if !item.id
+        update({ "#{type.classify}ID" => item.id })
+        true
+      end
+
+      def clear_association type
+        raise NotImplementedError
+      end
+
+      def fetch_association type
+        id_field = "#{type}_id"
+        raise(Infuser::RecordNotFound) if send(id_field).nil?
+        Infuser::Tables.const_get(type.classify).new(client).find send(id_field)
+      end
+
+    end
+  end
+end