infusionsoft 1.0.2 → 1.0.3

data/lib/infusionsoft/client/email.rb

@@ -1,91 +1,141 @@
 module Infusionsoft
   class Client
-    ########################
-    ###  Email Service   ###
-    ########################
+    # 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
-      # Enables you to opt contacts in
-      #
-      # @email [String]
-      # @reason [String]
-      def email_optin(email, reason)
-        response = get('APIEmailService', 'optIn', email, reason)
-      end
 
-      # Enables you to opt contacts out
+      # Create a new email template that can be used for future emails
       #
-      # @email [String]
-      # @reason [String]
-      def email_optout(email, reason)
-        response = get('APIEmailService', 'optOut', email, reason)
+      # @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
 
-      # Sends an email through infusion
+      # 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.
       #
-      # @contact_list [Array] List of contact ids you want to send this email to
-      # @from_address [String]
-      # @to_address [String]
-      # @cc_address [String]
-      # @bcc_address [String]
-      # @content_type [String] this must be one of the following Text, HTML, or Multipart
-      # @subject [String]
-      # @html_body [Text]
-      # @text_body [Text]
-      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)
+      # @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
 
-      # adds an email template for future use
+      # This retrieves all possible merge fields for the context provided.
       #
-      # @title [String]
-      # @categories [String] a comma separated list of the categories you wan this template in Infusionsoft
-      # @content_type [String] can be Text, HTML, Multipart
-      # @text_body [Text]
-      # @html_body [Text]
-      # @merge_context [String] 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)
+      # @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
 
-      # Attaches an email to a contact record
-      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)
+      # 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
 
-      # Creates an email template
-      def email_create_template(title, user_id, from_address, to_addres, cc_addresses, bcc_addresses, content_type, subject, html_body, txt_body)
-        response = get('APIEmailService', 'createEmailTemplate', title, user_id, from_address, to_addres, cc_addresses, bcc_addresses, content_type, subject, html_body, txt_body)
+      # 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
 
-      # updates an email template for future use
+      # This method opts-in an email address. This method only works the first time
+      # an email address opts-in.
       #
-      # @categories [String] a comma separated list of the categories you wan this template in Infusionsoft
-      # @content_type [String] can be Text, HTML, Multipart
-      # @merge_context [String] can be Contact, ServiceCall, Opportunity, CreditCard
-      def email_update_template(id, title, categories, from, to, cc, bcc, subject, text_body, html_body, content_type, merge_context)
-        response = get('APIEmailService', 'updateEmailTemplate', title, categories, from, to, cc, bcc, subject, text_body, html_body, content_type)
+      # @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
 
-      # returns an email template
-      def email_get_template(id)
-        response = get('APIEmailService', 'getEmailTemplate', id)
+      # 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
 
-      # gets the opt-in status of the provided email address
+      # This will send an email to a list of contacts, as well as record the email
+      # in the contacts' email history.
       #
-      # email_address [String]
-      # @returns 0 = opted out; 1 = single opt-in; 2 = double opt-in
-      def email_get_opt_status(email_address)
-        response = get('APIEmailService', 'getOptStatus', email_address)
+      # @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
 
-      # returns a string of merge fields for a given context
+      # This method is used to update an already existing email template.
       #
-      # @merge_context [String] could include Contact, ServiceCall, Opportunity, CreditCard
-      def email_get_available_merge_fields(merge_context)
-        response = get('APIEmailService', 'getAvailableMergeFields', merge_context)
+      # @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/infusionsoft/client/file.rb

@@ -1,8 +1,5 @@
 module Infusionsoft
   class Client
-    ########################
-    ###  File Service  ###
-    ########################
     module File
       def file_upload(contact_id, file_name, encoded_file_base64)
         response = get('FileService', 'uploadFile', contact_id, file_name, encoded_file_base64)

data/lib/infusionsoft/client/invoice.rb

@@ -1,127 +1,253 @@
 module Infusionsoft
   class Client
-    ########################  
-    ### Invoice Service  ###
-    ########################
+    # The Invoice service allows you to manage eCommerce transactions.
     module Invoice
-      def invoice_update_recurring_next_bill_date(job_recurring_id, new_bill_date) 
-        response = get('InvoiceService', 'updateJobRecurringNextBillDate', job_recurring_id, new_bill_date)
+      # 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 payment to an invoice without actually processing a charge through a merchant. 
+      # 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.
       #
-      # @invoice_id [Integer]
-      # @amount [Float]
-      # @date [Date]
-      # @type [String] Cash, Check, Credit Card, Money Order, PayPal, etc.
-      # @description [String]
-      # @bypass_commissions [Boolean]
-      # @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)
+      # @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
 
-      # Adds a commission override to a one time order, using a combination of percentage and hard-coded amounts.
-      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)
+      # 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
 
-      # Adds an item to an existing order.
+      # Deletes the specified subscription from the database, as well as all invoices
+      # tied to the subscription.
       #
-      # @order_id [Integer] This is the invoice id
-      # @product_id [Integer]
-      # @type [Integer] UNKNOWN = 0, SHIPPING = 1, TAX = 2, SERVICE = 3, PRODUCT = 4, UPSELL = 5, FINANCECHARGE = 6, SPECIAL = 7
-      # @price [Float]
-      # @quantity [Integer]
-      # @description [String]
-      # @notes [String]
-      # @return [Boolean] returns true or false if it was added successfully or not
-      def invoice_add_order_item(order_id, product_id, type, price, quantity, description, notes)
-        response = get('InvoiceService', 'addOrderItem', order_id, product_id, type, price,
-                       quantity, description, notes)
+      # @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
 
-      # Adds a payment plan to an existing invoice.
-      def invoice_add_payment_plan(order_id, auto_charge, credit_card_id, merchant_account_id, days_between_retry, max_retry,
-                         initial_payment_amount, plan_start_date, number_of_payments, days_between_payments)
-        response = get('InvoiceService', 'addPaymentPlan', order_id, auto_charge, credit_card_id, merchant_account_id, 
-                       days_between_retry, max_retry, initial_payment_amount, plan_start_date, number_of_payments, 
-                       days_between_payments)
+      # 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
 
-      # Adds a commission override to a recurring order.
-      def invoice_add_recurring_commission_override(recurringorder_id, affiliate_id, amount, payout_type, description)
-        response = get('InvoiceService', 'addRecurringCommissionOverride', recurringorder_id, affiliate_id, amount, 
-                       payout_type, description)
+      # 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 recurring order to the database.
-      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)
+      # 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
-      
-      # 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)
+
+      # 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
 
-      # Calculates the amount owed for a given invoice.
-      def invoice_calculate_amount_owed(invoice_id)
-        response = get('InvoiceService', 'calculateAmountOwed', invoice_id)
+      # 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
 
-      # Will charge an invoice with the amount currently due on it.
+      # Calculates the amount owed for a given invoice.
       #
-      # @invoice_id [Integer]
-      # @notes [String]
-      # @credit_card_id [Integer]
-      # @merchant_account_id [Integer]
-      # @bypass_commission [Boolean] 
-      # @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)
+      # @param [Integer] invoice_id
+      # @return [Float]
+      def invoice_calculate_amount_owed(invoice_id)
+        response = get('InvoiceService.calculateAmountOwed', invoice_id)
       end
 
-      # returns the invoice id from a one time order
-      def invoice_get_invoice_id(order_id)
-        response = get('InvoiceService', 'getinvoice_id', order_id)
+      # 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
 
-      # Creates a blank order with no items.
+      # Retrieves all payments for a given invoice.
       #
-      # @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)
+      # @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
 
-      # This will create an invoice for all charges due on a recurring order.
-      def invoice_create_invoice_for_recurring(recurringorder_id)
-        response = get('InvoiceService', 'createInvoiceForRecurring', recurringorder_id)
+      # 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
 
-      # Locates an existing card in the system for a contact, using the
-      def invoice_locate_existing_card(contact_id, last4)
-        # last 4 digits of the card.
-        response = get('InvoiceService', 'locateExistingCard', contact_id, last4)
+      # 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)
+        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)
-      def invoice_validate_card(creditCard)
-        response = get('InvoiceService', 'validateCreditCard', creditCard)
+      # 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