infusion-api 1.0.1 → 1.0.2

data/lib/infusion-api/client/email.rb

@@ -0,0 +1,141 @@
+module Infusionsoft
+  class Client
+    # The Email service allows you to email your contacts as well as attaching emails sent
+    # elsewhere (this lets you send email from multiple services and still see all communications
+    # inside of Infusionsoft).
+    module Email
+
+      # Create a new email template that can be used for future emails
+      #
+      # @param [String] title
+      # @param [String] categories a comma separated list of the categories
+      #   you want this template in Infusionsoft
+      # @param [String] from the from address format use is 'FirstName LastName <email@domain.com>'
+      # @param [String] to the email address this template is sent to
+      # @param [String] cc a comma separated list of cc email addresses
+      # @param [String] bcc a comma separated list of bcc email addresses
+      # @param [String] subject
+      # @param [String] text_body
+      # @param [String] html_body
+      # @param [String] content_type can be Text, HTML, Multipart
+      # @param [String] merge_context can be Contact, ServiceCall, Opportunity, CreditCard
+      def email_add(title, categories, from, to, cc, bcc, subject, text_body, html_body,
+                    content_type, merge_context)
+        response = get('APIEmailService.addEmailTemplate', title, categories, from, to,
+                       cc, bcc, subject, text_body, html_body, content_type, merge_context)
+      end
+
+      # This will create an item in the email history for a contact. This does not actually
+      # send the email, it only places an item into the email history. Using the API to
+      # instruct Infusionsoft to send an email will handle this automatically.
+      #
+      # @param [Integer] contact_id
+      # @param [String] from_name the name portion of the from address, not the email
+      # @param [String] from_address
+      # @param [String] to_address
+      # @param [String] cc_addresses
+      # @param [String] bcc_addresses
+      # @param [String] content_type can be Text, HTML, Multipart
+      # @param [String] subject
+      # @param [String] html_body
+      # @param [String] text_body
+      # @param [String] header the header info for this email (will be listed in history)
+      # @param [Date] receive_date
+      # @param [Date] sent_date
+      def email_attach(contact_id, from_name, from_address, to_address, cc_addresses,
+                       bcc_addresses, content_type, subject, html_body, txt_body,
+                       header, receive_date, send_date)
+        response = get('APIEmailService.attachEmail', contact_id, from_name, from_address,
+                       to_address, cc_addresses, bcc_addresses, content_type, subject,
+                       html_body, txt_body, header, receive_date, send_date)
+      end
+
+      # This retrieves all possible merge fields for the context provided.
+      #
+      # @param [String] merge_context could include Contact, ServiceCall, Opportunity, or CreditCard
+      # @return [Array] returns the merge fields for the given context
+      def email_get_available_merge_fields(merge_context)
+        response = get('APIEmailService.getAvailableMergeFields', merge_context)
+      end
+
+      # Retrieves the details for a particular email template.
+      #
+      # @param [Integer] id
+      # @return [Hash] all data for the email template
+      def email_get_template(id)
+        response = get('APIEmailService.getEmailTemplate', id)
+      end
+
+      # Retrieves the status of the given email address.
+      #
+      # @param [String] email_address
+      # @return [Integer]  0 = opted out, 1 = single opt-in, 2 = double opt-in
+      def email_get_opt_status(email_address)
+        response = get('APIEmailService.getOptStatus', email_address)
+      end
+
+      # This method opts-in an email address. This method only works the first time
+      # an email address opts-in.
+      #
+      # @param [String] email_address
+      # @param [String] reason
+      #   This is how you can note why/how this email was opted-in. If a blank
+      #   reason is passed the system will default a reason of "API Opt In"
+      # @return [Boolean]
+      def email_optin(email_address, reason)
+        response = get('APIEmailService.optIn', email_address, reason)
+      end
+
+      # Opts-out an email address. Note that once an address is opt-out,
+      # the API cannot opt it back in.
+      #
+      # @param [String] email_address
+      # @param [String] reason
+      # @return [Boolean]
+      def email_optout(email_address, reason)
+        response = get('APIEmailService.optOut', email_address, reason)
+      end
+
+      # This will send an email to a list of contacts, as well as record the email
+      # in the contacts' email history.
+      #
+      # @param [Array<Integer>] contact_list list of contact ids you want to send this email to
+      # @param [String] from_address
+      # @param [String] to_address
+      # @param [String] cc_address
+      # @param [String] bcc_address
+      # @param [String] content_type this must be one of the following Text, HTML, or Multipart
+      # @param [String] subject
+      # @param [String] html_body
+      # @param [String] text_body
+      # @return [Boolean] returns true/false if the email has been sent
+      def email_send(contact_list, from_address, to_address, cc_addresses,
+                     bcc_addresses, content_type, subject, html_body, text_body)
+        response = get('APIEmailService.sendEmail', contact_list, from_address,
+                       to_address, cc_addresses, bcc_addresses, content_type, subject,
+                       html_body, text_body)
+      end
+
+      # This method is used to update an already existing email template.
+      #
+      # @param [Integer] id
+      # @param [String] title
+      # @param [String] category
+      # @param [String] from
+      # @param [String] to
+      # @param [String] cc
+      # @param [String] bcc
+      # @param [String subject
+      # @param [String] text_body
+      # @param [String] html_body
+      # @param [String] content_type can be Text, HTML, Multipart
+      # @param [String] merge_context can be Contact, ServiceCall, Opportunity, CreditCard
+      # @return [Boolean] returns true/false if teamplate was updated successfully
+      def email_update_template(id, title, category, from, to, cc, bcc, subject,
+                                text_body, html_body, content_type, merge_context)
+        response = get('APIEmailService.updateEmailTemplate', title, category, from,
+                       to, cc, bcc, subject, text_body, html_body, content_type, merge_context)
+      end
+    end
+  end
+end

data/lib/infusion-api/client/file.rb

@@ -0,0 +1,26 @@
+module Infusionsoft
+  class Client
+    module File
+      def file_upload(contact_id, file_name, encoded_file_base64)
+        response = get('FileService.uploadFile', contact_id, file_name, encoded_file_base64)
+      end
+
+      # returns the Base64 encoded file contents
+      def file_get(id)
+        response = get('FileService.getFile', id)
+      end
+
+      def file_url(id)
+        response = get('FileService.getDownloadUrl', id)
+      end
+
+      def file_rename(id, new_name)
+        response = get('FileService.renameFile', id, new_name)
+      end
+
+      def file_replace(id, encoded_file_base64)
+        response = get('FileService.replaceFile', id, encoded_file_base64)
+      end
+    end
+  end
+end

data/lib/infusion-api/client/invoice.rb

@@ -0,0 +1,254 @@
+module Infusionsoft
+  class Client
+    # The Invoice service allows you to manage eCommerce transactions.
+    module Invoice
+      # Creates a blank order with no items.
+      #
+      # @param [Integer] contact_id
+      # @param [String] description the name this order will display
+      # @param [Date] order_date
+      # @param [Integer] lead_affiliate_id 0 should be used if none
+      # @param [Integer] sale_affiliate_id 0 should be used if none
+      # @return [Integer] returns the invoice id
+      def invoice_create_blank_order(contact_id, description, order_date, lead_affiliate_id,
+                                     sale_affiliate_id)
+        response = get('InvoiceService.createBlankOrder', contact_id, description, order_date,
+                        lead_affiliate_id, sale_affiliate_id)
+      end
+
+      # Adds a line item to an order. This used to add a Product to an order as well as
+      # any other sort of charge/discount.
+      #
+      # @param [Integer] invoice_id
+      # @param [Integer] product_id
+      # @param [Integer] type  UNKNOWN = 0, SHIPPING = 1, TAX = 2, SERVICE = 3, PRODUCT = 4,
+      #   UPSELL = 5, FINANCECHARGE = 6, SPECIAL = 7
+      # @param [Float] price
+      # @param [Integer] quantity
+      # @param [String] description a full description of the line item
+      # @param [String] notes
+      # @return [Boolean] returns true/false if it was added successfully or not
+      def invoice_add_order_item(invoice_id, product_id, type, price, quantity, description, notes)
+        response = get('InvoiceService.addOrderItem', invoice_id, product_id, type, price,
+                       quantity, description, notes)
+      end
+
+      # This will cause a credit card to be charged for the amount currently due on an invoice.
+      #
+      # @param [Integer] invoice_id
+      # @param [String] notes a note about the payment
+      # @param [Integer] credit_card_id
+      # @param [Integer] merchant_account_id
+      # @param [Boolean] bypass_commission
+      # @return [Hash] containing the following keys {'Successful => [Boolean],
+      #   'Code' => [String], 'RefNum' => [String], 'Message' => [String]}
+      def invoice_charge_invoice(invoice_id, notes, credit_card_id, merchant_account_id,
+                                 bypass_commissions)
+        response = get('InvoiceService.chargeInvoice', invoice_id, notes, credit_card_id,
+                            merchant_account_id, bypass_commissions)
+      end
+
+      # Deletes the specified subscription from the database, as well as all invoices
+      # tied to the subscription.
+      #
+      # @param [Integer] cprogram_id the id of the subscription being deleted
+      # @return [Boolean]
+      def invoice_delete_subscription(cprogram_id)
+        response = get('InvoiceService.deleteSubscription', cprogram_id)
+      end
+
+      # Creates a subscription for a contact. Subscriptions are billing automatically
+      # by infusionsoft within the next six hours. If you want to bill immediately you
+      # will need to utilize the create_invoice_for_recurring and then
+      # charge_invoice method to accomplish this.
+      #
+      # @param [Integer] contact_id
+      # @param [Boolean] allow_duplicate
+      # @param [Integer] cprogram_id the subscription id
+      # @param [Integer] merchant_account_id
+      # @param [Integer] credit_card_id
+      # @param [Integer] affiliate_id
+      # @param [Integer] days_till_charge number of days you want to wait till it's charged
+      def invoice_add_recurring_order(contact_id, allow_duplicate, cprogram_id,
+                                      merchant_account_id, credit_card_id, affiliate_id,
+                                      days_till_charge)
+        response = get('InvoiceService.addRecurringOrder', contact_id,
+                       allow_duplicate, cprogram_id, merchant_account_id, credit_card_id,
+                       affiliate_id, days_till_charge)
+      end
+
+      # This modifies the commissions being earned on a particular subscription.
+      # This does not affect previously generated invoices for this subscription.
+      #
+      # @param [Integer] recurring_order_id
+      # @param [Integer] affiliate_id
+      # @param [Float] amount
+      # @param [Integer] paryout_type how commissions will be earned (possible options are
+      #   4 - up front earning, 5 - upon customer payment) typically this is 5
+      # @return [Boolean]
+      def invoice_add_recurring_commission_override(recurring_order_id, affiliate_id,
+                                                    amount, payout_type, description)
+        response = get('InvoiceService.addRecurringCommissionOverride', recurring_order_id,
+                       affiliate_id, amount, payout_type, description)
+      end
+
+      # Adds a payment to an invoice without actually processing a charge through a merchant.
+      #
+      # @param [Integer] invoice_id
+      # @param [Float] amount
+      # @param [Date] date
+      # @param [String] type Cash, Check, Credit Card, Money Order, PayPal, etc.
+      # @param [String] description an area useful for noting payment details such as check number
+      # @param [Boolean] bypass_commissions
+      # @return [Boolean]
+      def invoice_add_manual_payment(invoice_id, amount, date, type, description, bypass_commissions)
+        response = get('InvoiceService.addManualPayment', invoice_id, amount, date, type,
+                       description, bypass_commissions)
+      end
+
+      # This will create an invoice for all charges due on a Subscription. If the
+      # subscription has three billing cycles that are due, it will create one
+      # invoice with all three items attached.
+      #
+      # @param [Integer] recurring_order_id
+      # @return [Integer] returns the id of the invoice that was created
+      def invoice_create_invoice_for_recurring(recurring_order_id)
+        response = get('InvoiceService.createInvoiceForRecurring', recurring_order_id)
+      end
+
+      # Adds a payment plan to an existing invoice.
+      #
+      # @param [Integer] invoice_id
+      # @param [Boolean]
+      # @param [Integer] credit_card_id
+      # @param [Integer] merchant_account_id
+      # @param [Integer] days_between_retry the number of days Infusionsoft should wait
+      #   before re-attempting to charge a failed payment
+      # @param [Integer] max_retry the maximum number of charge attempts
+      # @param [Float] initial_payment_ammount the amount of the very first charge
+      # @param [Date] initial_payment_date
+      # @param [Date] plan_start_date
+      # @param [Integer] number_of_payments the number of payments in this payplan (does not include
+      #  initial payment)
+      # @param [Integer] days_between_payments the number of days between each payment
+      # @return [Boolean]
+      def invoice_add_payment_plan(invoice_id, auto_charge, credit_card_id,
+                                   merchant_account_id, days_between_retry, max_retry,
+                                   initial_payment_amount, initial_payment_date, plan_start_date,
+                                   number_of_payments, days_between_payments)
+        response = get('InvoiceService.addPaymentPlan', invoice_id, auto_charge,
+                       credit_card_id, merchant_account_id, days_between_retry, max_retry,
+                       initial_payment_amount, initial_payment_date, plan_start_date, number_of_payments,
+                       days_between_payments)
+      end
+
+      # Calculates the amount owed for a given invoice.
+      #
+      # @param [Integer] invoice_id
+      # @return [Float]
+      def invoice_calculate_amount_owed(invoice_id)
+        response = get('InvoiceService.calculateAmountOwed', invoice_id)
+      end
+
+      # Retrieve all Payment Types currently setup under the Order Settings section of Infusionsoft.
+      #
+      # @return [Array]
+      def invoice_get_all_payment_otpions
+        response = get('InvoiceService.getAllPaymentOptions')
+      end
+
+      # Retrieves all payments for a given invoice.
+      #
+      # @param [Integer] invoice_id
+      # @return [Array<Hash>] returns an array of payments
+      def invoice_get_payments(invoice_id)
+        response = get('Invoice.getPayments', invoice_id)
+      end
+
+      # Locates an existing card in the system for a contact, using the last 4 digits.
+      #
+      # @param [Integer] contact_id
+      # @param [Integer] last_four
+      # @return [Integer] returns the id of the credit card
+      def invoice_locate_existing_card(contact_id, last_four)
+        response = get('InvoiceService.locateExistingCard', contact_id, last_four)
+      end
+
+      # Calculates tax, and places it onto the given invoice.
+      #
+      # @param [Integer] invoice_id
+      # @return [Boolean]
+      def invoice_recalculate_tax(invoice_id)
+        response = get('InvoiceService.recalculateTax', invoice_id)
+      end
+
+      # This will validate a credit card in the system.
+      #
+      # @param [Integer] credit_card_id if the card is already in the system
+      # @return [Hash] returns a hash { 'Valid' => false, 'Message' => 'Card is expired' }
+      def invoice_validate_card(credit_card_id)
+        response = get('InvoiceService.validateCreditCard', credit_card_id)
+      end
+
+      # This will validate a credit card by passing in values of the
+      # card directly (this card doesn't have to be added to the system).
+      #
+      # @param [Hash] data
+      # @return [Hash] returns a hash { 'Valid' => false, 'Message' => 'Card is expired' }
+      def invoice_validate_card(data)
+        response = get('InvoiceService.validateCreditCard', data)
+      end
+
+      # Retrieves the shipping options currently setup for the Infusionsoft shopping cart.
+      #
+      # @return [Array]
+      def invoice_get_all_shipping_options
+        response = get('Invoice.getAllShippingOptions')
+      end
+
+      # Changes the next bill date on a subscription.
+      #
+      # @param [Integer] job_recurring_id this is the subscription id on the contact
+      # @param [Date] next_bill_date
+      # @return [Boolean]
+      def invoice_update_recurring_next_bill_date(job_recurring_id, next_bill_date)
+        response = get('InvoiceService.updateJobRecurringNextBillDate', job_recurring_id, next_bill_date)
+      end
+
+
+      # Adds a commission override to a one time order, using a combination of percentage
+      # and hard-coded amounts.
+      #
+      # @param [Integer] invoice_id
+      # @param [Integer] affiliate_id
+      # @param [Integer] product_id
+      # @param [Integer] percentage
+      # @param [Float] amount
+      # @param [Integer] payout_type how commision should be earned (4 - up front in full, 5 - upon
+      #   customer payment
+      # @param [String] description a note about this commission
+      # @param [Date] date the commission was generated, not necessarily earned
+      # @return [Boolean]
+      def invoice_add_order_commission_override(invoice_id, affiliate_id, product_id, percentage,
+                                                amount, payout_type, description, date)
+        response = get('InvoiceService.addOrderCommissionOverride', invoice_id, affiliate_id,
+                       product_id, percentage, amount, payout_type, description, date)
+      end
+
+
+      # Deprecated - Adds a recurring order to the database.
+      def invoice_add_recurring_order_with_price(contact_id, allow_duplicate, cprogram_id, qty,
+                                                 price, allow_tax, merchant_account_id,
+                                                 credit_card_id, affiliate_id, days_till_charge)
+        response = get('InvoiceService.addRecurringOrder', contact_id, allow_duplicate,
+                       cprogram_id, qty, price, allow_tax, merchant_account_id, credit_card_id,
+                       affiliate_id, days_till_charge)
+      end
+
+      # Deprecated - returns the invoice id from a one time order.
+      def invoice_get_invoice_id(order_id)
+        response = get('InvoiceService.getinvoice_id', order_id)
+      end
+    end
+  end
+end

data/lib/infusion-api/client/search.rb

@@ -0,0 +1,66 @@
+module Infusionsoft
+  class Client
+    # The SearchService allows you to retrieve the results of saved searches and reports that 
+    # have been saved within Infusionsoft. Saved searches/reports are tied to the User that 
+    # created them. This service also allows you to utilize the quick search function found in 
+    # the upper right hand corner of your Infusionsoft application.
+
+    # @note In order to retrieve the id number for saved searches you will need to utilize 
+    # the data_query method and query the table called SavedFilter based on the user_id 
+    # you are looking for the saved search Id for. Also note that UserId field on the 
+    # SavedFilter table can contain multiple userId’s separated by a comma, so if you are 
+    # querying for a report created by userId 6, I recommend appending the wildcard to the 
+    # end of the userId. Something like $query = array( ‘UserId’ => ’6%’ );
+    module Search
+      # Gets all possible fields/columns available for return on a saved search/report.
+      #
+      # @param [Integer] saved_search_id
+      # @param [Integer] user_id the user id who the saved search is assigned to
+      # @return [Hash]
+      def search_get_all_report_columns(saved_search_id, user_id)
+        response = get('SearchService.getAllReportColumns', saved_search_id, user_id)
+      end
+
+      # Runs a saved search/report and returns all possible fields.
+      #
+      # @param [Integer] saved_search_id
+      # @param [Integer] user_id the user id who the saved search is assigned to
+      # @param [Integer] page_number
+      # @return [Hash]
+      def search_get_saved_search_results(saved_search_id, user_id, page_number)
+        response = get('SearchService.getSavedSearchResultsAllFields', saved_search_id,
+                       user_id, page_number)
+      end
+
+      # This is used to find what possible quick searches the given user has access to.
+      #
+      # @param [Integer] user_id
+      # @return [Array] 
+      def search_get_available_quick_searches(user_id)
+        response = get('SearchService.getAvailableQuickSearches', user_id)
+      end
+
+      # This allows you to run a quick search via the API. The quick search is the 
+      # search bar in the upper right hand corner of the Infusionsoft application
+      #
+      # @param [String] search_type the type of search (Person, Order, Opportunity, Company, Task,
+      #   Subscription, or Affiliate)
+      # @param [Integer] user_id
+      # @param [String] search_data
+      # @param [Integer] page
+      # @param [Integer] limit max is 1000
+      # @return [Array<Hash>]
+      def search_quick_search(search_type, user_id, search_data, page, limit)
+        response = get('SearchService.quickSearch', search_type, user_id, search_data, page, limit)
+      end
+
+      # Retrieves the quick search type that the given users has set as their default.
+      #
+      # @param [Integer] user_id
+      # @return [String] the quick search type that the given user selected as their default
+      def search_get_default_search_type(user_id)
+        response = get('SearchService.getDefaultQuickSearch', user_id)
+      end
+    end
+  end
+end

data/lib/infusion-api/client/ticket.rb

@@ -0,0 +1,18 @@
+module Infusionsoft
+  class Client
+    module Ticket
+      # add move notes to existing tickets
+      def ticket_add_move_notes(ticket_list, move_notes, 
+                                move_to_stage_id, notify_ids)
+        response = get('ServiceCallService.addMoveNotes', ticket_list, 
+                       move_notes, move_to_stage_id, notify_ids)
+      end
+
+      # add move notes to existing tickets
+      def ticket_move_stage(ticket_id, ticket_stage, move_notes, notify_ids)
+        response = get('ServiceCallService.moveTicketStage', 
+                       ticket_id, ticket_stage, move_notes, notify_ids)
+      end
+    end
+  end
+end

data/lib/infusion-api/client/version.rb

@@ -0,0 +1,4 @@
+module Infusionsoft
+  # The version of the gem
+  VERSION = '1.0.2'.freeze unless defined?(::Infusionsoft::VERSION)
+end

data/lib/infusion-api/client.rb

@@ -0,0 +1,29 @@
+module Infusionsoft
+  # Wrapper for the Infusionsoft API
+  #
+  # @note all services have been separated into different modules
+  class Client < Api
+    # Require client method modules after initializing the Client class in
+    # order to avoid a superclass mismatch error, allowing those modules to be
+    # Client-namespaced.
+    require 'infusionsoft/client/contact'
+    require 'infusionsoft/client/email'
+    require 'infusionsoft/client/invoice'
+    require 'infusionsoft/client/data'
+    require 'infusionsoft/client/affiliate'
+    require 'infusionsoft/client/file'
+    require 'infusionsoft/client/ticket' # Deprecated by Infusionsoft
+    require 'infusionsoft/client/search'
+    require 'infusionsoft/client/credit_card'
+
+    include Infusionsoft::Client::Contact
+    include Infusionsoft::Client::Email
+    include Infusionsoft::Client::Invoice
+    include Infusionsoft::Client::Data
+    include Infusionsoft::Client::Affiliate
+    include Infusionsoft::Client::File
+    include Infusionsoft::Client::Ticket # Deprecated by Infusionsoft
+    include Infusionsoft::Client::Search
+    include Infusionsoft::Client::CreditCard
+  end
+end

data/lib/infusion-api/configuration.rb

@@ -0,0 +1,36 @@
+module Infusionsoft
+
+  module Configuration
+    VALID_OPTION_KEYS = [
+      :api_url,
+      :api_key
+    ].freeze
+
+    # @private
+    attr_accessor *VALID_OPTION_KEYS
+
+    # When this module is extended, set all configuration options to their default values
+    #def self.extended(base)
+      #base.reset
+    #end
+
+    # Convenience method to allow configuration options to be set in a block
+    def configure
+      yield self
+    end
+
+    # Create a hash of options and their values
+    def options
+      options = {}
+      VALID_OPTION_KEYS.each{|k| options[k] = send(k)}
+      options
+    end
+
+    #def reset
+      #self.url = ''
+      #self.api_key = 'na'
+    #end
+
+  end
+
+end

data/lib/infusion-api/connection.rb

@@ -0,0 +1,49 @@
+require "xmlrpc/client"
+
+module Infusionsoft
+  module Connection
+    private
+
+    def connection(service_call, *args)
+      server = XMLRPC::Client.new3({
+        'host' => api_url,
+        'path' => "/api/xmlrpc",
+        'port' => 443,
+        'use_ssl' => true
+      })
+      begin
+        result = server.call("#{service_call}", api_key, *args)
+        if result.nil?; result = [] end
+      rescue Timeout::Error => timeout
+        # Retry up to 5 times on a Timeout before raising it
+        ok_to_retry(timeout) ? retry : raise
+      rescue => e
+        # Wrap the underlying error in an InfusionAPIError
+        raise InfusionAPIError.new(e.to_s, e)
+      end
+
+      return result
+    end
+
+    def ok_to_retry(e)
+      @retry_count += 1
+      if @retry_count <= 5
+        Rails.logger.info "!!! INFUSION API ERROR: [#{e}] retrying #{@retry_count}" if Rails
+        true
+      else
+        false
+      end
+    end
+
+  end
+end
+
+# Extend StandardError to keep track of Error being wrapped
+# Pattern from Exceptional Ruby by Avdi Grimm (http://avdi.org/talks/exceptional-ruby-2011-02-04/)
+class InfusionAPIError < StandardError
+  attr_reader :original
+    def initialize(msg, original=nil);
+      super(msg);
+      @original = original;
+    end
+end

data/lib/infusion-api/request.rb

@@ -0,0 +1,34 @@
+module Infusionsoft
+  module Request
+    # Perform an GET request
+    def get(service_call, *args)
+      request(:get, service_call, *args)
+    end
+
+    def post(path, params={}, options={})
+      request(:post, path, params, options)
+    end
+
+    # Perform an HTTP PUT request
+    def put(path, params={}, options={})
+      request(:put, path, params, options)
+    end
+
+    # Perform an HTTP DELETE request
+    def delete(path, params={}, options={})
+      request(:delete, path, params, options)
+    end
+
+
+    private
+
+    # Perform request
+    def request(method, service_call, *args)
+      Rails.logger "<<<< Performing API Request to #{api_url}"
+      case method.to_sym
+      when :get
+        response = connection(service_call, *args)
+      end
+    end
+  end
+end

data/lib/infusion-api/version.rb

@@ -0,0 +1,4 @@
+module Infusionsoft
+  # The version of the gem
+  VERSION = '1.0.2'.freeze unless defined?(::Infusionsoft::VERSION)
+end