gotransverse-tract-api 0.3.4 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 39273a34efe26729015c58794493d067d77fb5cd
-  data.tar.gz: 86d2f3318800808d0652354d463fd0d5e8e74330
+  metadata.gz: 2262c8dfe32caf5a06afc9eb322a064301d141d6
+  data.tar.gz: 132028b0ab05e06d987d8af55f064d62892a46b2
 SHA512:
-  metadata.gz: 62d15c95a86c9491350cbd04544c4016528eb72b73bad702eb0335554d99cc94b5ce49b393079f2004c177ed09a227001c175cfda5f565e19e208dceaa4815ce
-  data.tar.gz: c006707b3070931745c4bbb891dc15189a0512647568df3867c862d56bc35937ee3ee21f3882c08e0f559659c2ff3ad2c62a492c8ec0d999ed3874eaf2e40bc0
+  metadata.gz: fcea9c7ea29d482546b744b97cc5acc94e7980b607c4987c3b525fb4a5bf031d2bb4a8897245d3fabf29b005de3182a1324114f280551180b10af31a79fd1997
+  data.tar.gz: 6eb53434e40f6de3291bfb89f93445730a0540c8bbd76e2f914cab9a86f9a33c69b3c0a30df6037f3599a76e945f7c9a91413431ccb525cfdcf5b900472e8a10

data/lib/gotransverse-tract-api.rb

@@ -2,6 +2,7 @@ require "gotransverse-tract-api/version"
 
 require "gotransverse-tract-api/configuration"
 require "gotransverse-tract-api/hash"
+require "gotransverse-tract-api/api_data"
 
 require "gotransverse-tract-api/billing_account/adjustment"
 require "gotransverse-tract-api/billing_account/adjustment_application"
@@ -155,7 +156,11 @@ module GoTransverseTractApi
   #
   def self.post_request_for(klass, api_params={}, request_body, command)
     api_url = GoTransverseTractApi.get_api_url_for(klass)
-    api_url = "#{api_url}/#{command}"
+    if (api_params.empty?)
+      api_url = "#{api_url}/#{command}"
+    else
+      api_url = "#{api_url}/#{api_params[:eid]}/#{command}"
+    end
     
     self.call(klass, api_url, api_params, :post, request_body)
   end
@@ -172,6 +177,28 @@ module GoTransverseTractApi
     self.call(klass, api_url, api_params, :put, request_body.to_xml)
   end
 
+  #
+  # Generate XML for request body
+  #
+  # @param {hash} data
+  # @param (String} root element
+  #
+
+  def self.generateXML(data, root_elem)
+    tract_api_ver = GoTransverseTractApi::TARGET_API_VERSION
+    data[root_elem.to_sym][:xmlns] = "http://www.tractbilling.com/billing/#{tract_api_ver}/domain"
+
+    builder = Nokogiri::XML::Builder.new do|xml|
+      xml.send(root_elem,Hash[data[root_elem.to_sym]]) do
+        arr = []
+        arr << root_elem.to_sym
+        self.process_data(data, arr, xml)
+      end
+    end
+
+    builder.doc.root.to_xml
+  end
+
   private
 
   #
@@ -244,4 +271,27 @@ module GoTransverseTractApi
     hsh
   end
 
+  def self.process_data(data, arr, xml)
+    data.each do|key,val|
+      next if arr.include?(key)
+       
+      if (val.is_a?Hash)
+        if (val.has_key?(:attributes))
+          xml.send(key, Hash[data[key][:attributes]]) do
+            arr << 'attributes'.to_sym
+            self.process_data(data[key],arr,xml)
+          end
+        else
+          xml.send(key, Hash[data[key]])
+        end
+      elsif (val.is_a?Array)
+        val.each do|item|
+          self.process_data(item,arr,xml)
+        end
+      else
+        xml.send(key, val)
+      end
+    end
+  end
+
 end

data/lib/gotransverse-tract-api/api_data.rb

@@ -0,0 +1,259 @@
+module GoTransverseTractApi
+  class ApiData
+
+    def payment_details(invoice, billing_account=nil)
+      data = {
+        applyPayment: {},
+        billingAccount: {
+          eid: invoice[:billing_account][:eid]
+        },
+        invoice: {
+          eid: invoice[:invoice][:eid]
+        },
+        payment: {
+          attributes: {
+            amount: invoice[:payment][:amount],
+            useRecurringPayment: invoice[:payment][:use_recurring_payment]
+          },
+          creditCardPayment: {
+            cardType: invoice[:payment][:credit_card_payment][:card_type],
+            cardHolderFirstName: invoice[:payment][:credit_card_payment][:card_holder_first_name],
+            cardHolderLastName: invoice[:payment][:credit_card_payment][:card_holder_last_name],
+            cardIdentifierNumber: invoice[:payment][:credit_card_payment][:card_identifier_number],
+            cardVerificationNumber: invoice[:payment][:credit_card_payment][:card_verification_number],
+            cardExpiration: invoice[:payment][:credit_card_payment][:card_expiration]
+          },
+          billingAccount: {
+            eid: invoice[:payment][:billing_account][:eid]
+          }
+        }
+      }
+
+      if(billing_account)
+        data[:payment][:creditCardPayment][:description] = invoice[:payment][:credit_card_payment][:description]
+      end
+      GoTransverseTractApi.generateXML(data, 'applyPayment')
+    end
+ 
+    # To suspend or deactivate the account
+    def shutdown(billing_account, eid, root_elem)
+      data = {
+        billingAccount: {eid: eid},
+        reason: {eid: billing_account[:reason][:eid]}
+      }
+
+      data[root_elem.to_sym] = {}
+
+      GoTransverseTractApi.generateXML(data, root_elem)
+    end
+
+    # Returns {Hash} a list of sales order details
+    def sales_order_details(sales_order)
+      so_details = {
+        attributes: {
+          referral: sales_order[:referral],
+          orderDate: sales_order[:order_date],
+          orderStatus: sales_order[:order_status]
+        },
+        orderItems: {
+          attributes: get_page_info(sales_order[:order_items]),
+          order_item: {
+            attributes: {
+              quantity: sales_order[:order_items][:order_item][:quantity]
+            },
+            products: get_products(sales_order)
+          }
+        },
+        billingAccount: get_billing_account(sales_order[:billing_account])
+      }
+
+      so_details
+    end
+
+    # Returns [Array]  Products 
+    def get_products(sales_order)
+      products = []
+
+      items = sales_order[:order_items][:order_item][:products]
+
+      (0..items.size - 1).each do|i|
+        products << {
+          product: {
+            attributes: {
+              name: items[i][:name],
+              description: items[i][:description],
+              shortDescription: items[i][:short_description],
+              productTypeCode: items[i][:product_type_code],
+              productState: items[i][:product_state],
+              requiresAgreement: items[i][:requires_agreement],
+              serialized: items[i][:serialized],
+              taxable: items[i][:taxable],
+              trial: items[i][:trial],
+              defaultQuantity: items[i][:default_quantity],
+              minServiceResources: items[i][:min_service_resources],
+              maxServiceResources: items[i][:max_service_resources],
+              trialOverride: items[i][:trial_override],
+              eid: items[i][:eid]
+            },
+            productPrices: {
+              attributes: get_page_info(items[i][:product_prices]),
+              productPrices: get_product_prices(items[i])
+            },
+            productCategory: {
+              name: items[i][:product_category][:name],
+              description: items[i][:product_category][:description],
+              status: items[i][:product_category][:status],
+              eid: items[i][:product_category][:eid]
+            },
+            actions: get_page_info(items[i][:actions]),
+            productUsageRules: get_page_info(items[i][:product_usage_rules])
+          }
+        }
+      end
+
+      products
+    end
+
+    # Returns [Array]  Product Prices 
+    def get_product_prices(product)
+      product_prices = []
+
+      count = product[:product_prices][:total_elements].to_i
+
+      (0..count - 1).each do|i|
+        product_price = product[:product_prices][:productprices][i]
+
+        product_prices << {
+          productPrice: {
+            attributes: {
+              fromDate: product_price[:from_date],
+              priceOverride: product_price[:price_override],
+              type: product_price[:type],
+              recurringPaymentRequired: product_price[:recurring_payment_required],
+              eid: product_price[:eid]
+            },
+            priceRanges: {
+              attributes: get_page_info(product_price[:price_ranges]),
+              priceRanges: get_price_ranges(product_price)
+            }
+          }
+        }
+      end
+
+      product_prices
+    end
+
+    # Returns [Array]  Price Ranges
+    def get_price_ranges(product_price)
+      price_ranges = []
+
+      count = product_price[:price_ranges][:total_elements].to_i
+
+      (0..count - 1).each do|i|
+        price_range = product_price[:price_ranges][:priceranges][i]
+
+        price_ranges << {
+          priceRange: {
+            quantityBeginRange: price_range[:quantity_begin_range],
+            price: price_range[:price],
+            level: price_range[:level],
+            eid: price_range[:eid]
+          }
+        }
+      end
+
+      price_ranges
+    end
+
+    def get_page_info(category)
+      {
+        pageNumber: category[:page_number],
+        pageSize: category[:page_size],
+        totalElements: category[:total_elements],
+        elementCount: category[:element_count],
+        totalPages: category[:total_pages]
+      }
+    end
+
+    def get_billing_account(billing_account)
+      ba_details = {
+        attributes: {
+          accountNum: billing_account[:account_num],
+          billType: billing_account[:bill_type],
+          automaticRecurringPayment: billing_account[:automatic_recurring_payment],
+          status: billing_account[:status],
+          pendingChargesTotal: billing_account[:pending_charges_total],
+          balance: billing_account[:balance],
+          startDate: billing_account[:start_date],
+          taxExempt: billing_account[:tax_exempt],
+          eid: billing_account[:eid]
+        },
+        dailyBillCycle: {
+          name: billing_account[:daily_bill_cycle][:name],
+          startDate: billing_account[:daily_bill_cycle][:start_date],
+          endDate: billing_account[:daily_bill_cycle][:end_date],
+          billCycleType: billing_account[:daily_bill_cycle][:bill_cycle_type],
+          autoBill: billing_account[:daily_bill_cycle][:auto_bill],
+          usePaymentTerm: billing_account[:daily_bill_cycle][:use_payment_term],
+          status: billing_account[:daily_bill_cycle][:status],
+          eid: billing_account[:daily_bill_cycle][:eid]
+        },
+        person: {
+          attributes: {
+            firstName: billing_account[:person][:first_name],
+            lastName: billing_account[:person][:last_name],
+            eid: billing_account[:person][:eid]
+          },
+          addresses: get_addresses(billing_account[:person])
+        },
+        billingAccountCategory: {
+          type: billing_account[:billing_account_category][:type],
+          description: billing_account[:billing_account_category][:description],
+          status: billing_account[:billing_account_category][:status],
+          eid: billing_account[:billing_account_category][:eid]
+        },
+        paymentTerm: {
+          name: billing_account[:payment_term][:name],
+          termDays: billing_account[:payment_term][:term_days],
+          graceDays: billing_account[:payment_term][:grace_days],
+          eid: billing_account[:payment_term][:eid]
+        }
+      }
+
+      ba_details
+    end
+
+    def get_addresses(entity)
+      addresses = {
+        attributes: {},
+        emailAddress: {
+          purpose: entity[:addresses][:email_address][:purpose],
+          email: entity[:addresses][:email_address][:email],
+          eid: entity[:addresses][:email_address][:eid] || ''
+        },
+        postalAddress: {
+          purpose: entity[:addresses][:postal_address][:purpose],
+          country: entity[:addresses][:postal_address][:country],
+          city: entity[:addresses][:postal_address][:city],
+          regionOrState: entity[:addresses][:postal_address][:region_or_state],
+          attention: entity[:addresses][:postal_address][:attention],
+          postalCode: entity[:addresses][:postal_address][:postal_code],
+          line1: entity[:addresses][:postal_address][:line1],
+          eid: entity[:addresses][:postal_address][:eid] || ''
+        },
+        telecomAddress: {
+          dialingPrefix: entity[:addresses][:telecom_address][:dialing_prefix],
+          countryCode: entity[:addresses][:telecom_address][:country_code],
+          areaCode: entity[:addresses][:telecom_address][:area_code],
+          number: entity[:addresses][:telecom_address][:number],
+          extension: entity[:addresses][:telecom_address][:extension],
+          purpose: entity[:addresses][:telecom_address][:purpose],
+          eid: entity[:addresses][:telecom_address][:eid] || ''
+        }
+      }
+
+      addresses.each{|k,v| v.delete_if{|tags,data| data == ''}}
+    end
+
+  end
+end

data/lib/gotransverse-tract-api/billing_account/adjustment.rb

@@ -53,7 +53,17 @@ module GoTransverseTractApi
         # @param {Hash} adjustment
         #
         def post eid, adjustment
-          GoTransverseTractApi.post_request_for(self, {eid: eid}, adjustment, "post")
+          data = {
+            :postAdjustment => {},
+            :adjustment => {
+              :attributes => {
+                eid: adjustment[:eid]
+              }
+            }
+          }
+
+          xml_data = GoTransverseTractApi.generateXML(data, 'postAdjustment')
+          GoTransverseTractApi.post_request_for(self, {eid: eid}, xml_data, "post")
         end
 
         #
@@ -61,7 +71,15 @@ module GoTransverseTractApi
         # @param {Hash} adjustment
         #
         def reverse eid, adjustment
-          GoTransverseTractApi.post_request_for(self, {eid: eid}, adjustment, "reverse")
+          data = {
+            :reverseAdjustment => {
+              :fullAmount => adjustment[:full_amount]
+            },
+            :adjustment => make_adjustment(adjustment)
+          }
+
+          xml_data = GoTransverseTractApi.generateXML(data, 'reverseAdjustment')
+          GoTransverseTractApi.post_request_for(self, {eid: eid}, xml_data, "reverse")
         end
 
         #
@@ -69,7 +87,23 @@ module GoTransverseTractApi
         # @param {Hash} adjustment
         #
         def add_invoice_application eid, adjustment
-          GoTransverseTractApi.post_request_for(self, {eid: eid}, adjustment, "addInvoiceApplication")
+
+          account_adjustment = make_adjustment(adjustment)
+
+          data = {
+            :addInvoiceApplicationToAdjustment => {},
+            :adjustment => account_adjustment,
+            :invoiceAdjustmentApplication => {
+              :attributes => {
+                :amount => adjustment[:invoice_adjustment_application][:amount]
+              },
+              :accountAdjustment => account_adjustment,
+              :invoice => get_invoice(adjustment, account_adjustment)
+            }
+          }
+
+          xml_data = GoTransverseTractApi.generateXML(data, 'addInvoiceApplicationToAdjustment')
+          GoTransverseTractApi.post_request_for(self, {eid: eid}, xml_data, "addInvoiceApplication")
         end
 
         #
@@ -77,14 +111,180 @@ module GoTransverseTractApi
         # @param {Hash} adjustment
         #
         def reverse_invoice_application eid, adjustment
-          GoTransverseTractApi.post_request_for(self, {eid: eid}, adjustment, "reverseInvoiceApplication")
+
+          account_adjustment = make_adjustment(adjustment)
+
+          data = {
+            :reverseInvoiceApplicationFromAdjustment => {},
+            :adjustment => account_adjustment,
+            :invoiceAdjustmentApplication => {
+              :attributes => {
+                :reversed => adjustment[:invoice_adjustment_application][:reversed],
+                :appliedOn => adjustment[:invoice_adjustment_application][:applied_on],
+                :amount => adjustment[:invoice_adjustment_application][:amount],
+                eid: adjustment[:invoice_adjustment_application][:eid]
+              },
+              :accountAdjustment => {
+                :attributes => {
+                  :occurredOn => adjustment[:occurred_on],
+                  :amount => adjustment[:amount],
+                  :description => adjustment[:description],
+                  :invoiced => adjustment[:invoice_adjustment_application][:account_adjustment][:invoiced],
+                  :credit => adjustment[:invoice_adjustment_application][:account_adjustment][:credit],
+                  :status => adjustment[:invoice_adjustment_application][:account_adjustment][:status],
+                  :type => adjustment[:type],
+                  :posted_on => adjustment[:invoice_adjustment_application][:account_adjustment][:posted_on],
+                  :posted_by => adjustment[:invoice_adjustment_application][:account_adjustment][:posted_by],
+                  :manualInvoiceApplication => adjustment[:manual_invoice_application],
+                  eid: adjustment[:eid]
+                },
+                :billingAccount => account_adjustment[:billingAccount],
+                :reason => account_adjustment[:reason],
+                :adjustmentApplications => account_adjustment[:billingAccount][:services]
+              },
+              :invoice => get_invoice(adjustment, account_adjustment)
+            }
+          }
+
+          xml_data = GoTransverseTractApi.generateXML(data, 'reverseInvoiceApplicationFromAdjustment')
+          GoTransverseTractApi.post_request_for(self, {eid: eid}, xml_data, "reverseInvoiceApplication")
         end
 
         #
         # @param {Hash} adjustment
         #
         def create_adjustment adjustment
-          GoTransverseTractApi.post_request_for(self, {}, adjustment, "")
+
+          data = {
+            :adjustment => {
+              :occurredOn => adjustment[:occurred_on],
+              :amount => adjustment[:amount],
+              :description => adjustment[:description],
+              :type => adjustment[:type],
+              :credit => adjustment[:credit],
+              :posted => adjustment[:posted]
+            },
+            :billingAccount => {
+              eid: adjustment[:billing_account][:eid]
+            },
+            :reason => {
+              eid: adjustment[:reason][:eid]
+            }
+          }
+
+          xml_data = GoTransverseTractApi.generateXML(data, 'adjustment')
+          GoTransverseTractApi.post_request_for(self, {}, xml_data, "")
+        end
+
+        private
+
+        def get_invoice (adjustment, account_adjustment)
+          {
+            :attributes => {
+              :invoiceNum => adjustment[:invoice_adjustment_application][:invoice][:invoice_num],
+              :amount => adjustment[:invoice_adjustment_application][:invoice][:amount],
+              :pdfPath => adjustment[:invoice_adjustment_application][:invoice][:pdf_path],
+              :occurredOn => adjustment[:invoice_adjustment_application][:invoice][:occurred_on],
+              :dueDate => adjustment[:invoice_adjustment_application][:invoice][:due_date],
+              :amountToPay => adjustment[:invoice_adjustment_application][:invoice][:amount_to_pay],
+              :lateFeeCharged => adjustment[:invoice_adjustment_application][:invoice][:late_fee_charged],
+              :status => adjustment[:invoice_adjustment_application][:invoice][:status],
+              :usageCsvPath => adjustment[:invoice_adjustment_application][:invoice][:usage_csv_path],
+              eid: adjustment[:invoice_adjustment_application][:invoice][:eid]
+            },
+            :billingAccount => account_adjustment[:billingAccount],
+            :billCycle => account_adjustment[:billingAccount][:dailyBillCycle],
+            :invoiceItems => account_adjustment[:billingAccount][:services]
+          }
+        end
+
+        def make_adjustment adjustment
+          adjustment = {
+            :attributes => {
+              :occurredOn => adjustment[:occurred_on],
+              :amount => adjustment[:amount],
+              :description => adjustment[:description],
+              :invoiced => adjustment[:invoiced],
+              :credit => adjustment[:credit],
+              :status => adjustment[:status],
+              :type => adjustment[:type],
+              :manualInvoiceApplication => adjustment[:manual_invoice_application],
+              eid: adjustment[:eid]
+            },
+            :billingAccount => {
+              :attributes => {
+                :accountNum => adjustment[:billing_account][:account_num],
+                :billType => adjustment[:billing_account][:bill_type],
+                :automaticRecurringPayment => adjustment[:billing_account][:automatic_recurring_payment],
+                :status => adjustment[:billing_account][:status],
+                :pendingChargesTotal => adjustment[:billing_account][:pending_charges_total],
+                :balance => adjustment[:billing_account][:balance],
+                :startDate => adjustment[:billing_account][:start_date],
+                :taxExempt => adjustment[:billing_account][:tax_exempt],
+                eid: adjustment[:billing_account][:eid]
+              },
+              :dailyBillCycle => {
+                :name => adjustment[:billing_account][:daily_bill_cycle][:name],
+                :startDate => adjustment[:billing_account][:daily_bill_cycle][:start_date],
+                :endDate => adjustment[:billing_account][:daily_bill_cycle][:end_date],
+                :billCycleType => adjustment[:billing_account][:daily_bill_cycle][:bill_cycle_type],
+                :autoBill => adjustment[:billing_account][:daily_bill_cycle][:auto_bill],
+                :usePaymentTerm => adjustment[:billing_account][:daily_bill_cycle][:use_payment_term],
+                :status => adjustment[:billing_account][:daily_bill_cycle][:status],
+                eid: adjustment[:billing_account][:daily_bill_cycle][:eid]
+              },
+              :person => {
+                :attributes => {
+                  :firstName => adjustment[:billing_account][:person][:first_name],
+                  :lastName => adjustment[:billing_account][:person][:last_name],
+                  eid: adjustment[:billing_account][:person][:eid]
+                },
+                :addresses => {
+                  :attributes => {},
+                  :postalAddress => {
+                    :purpose => adjustment[:billing_account][:person][:addresses][:postal_address][:purpose],
+                    :country => adjustment[:billing_account][:person][:addresses][:postal_address][:country],
+                    :city => adjustment[:billing_account][:person][:addresses][:postal_address][:city],
+                    :regionOrState => adjustment[:billing_account][:person][:addresses][:postal_address][:region_or_state],
+                    :postalCode => adjustment[:billing_account][:person][:addresses][:postal_address][:postal_code],
+                    :line1 => adjustment[:billing_account][:person][:addresses][:postal_address][:line1],
+                    eid: adjustment[:billing_account][:person][:addresses][:postal_address][:eid]
+                  },
+                  :emailAddress => {
+                    :purpose => adjustment[:billing_account][:person][:addresses][:email_address][:purpose],
+                    :email => adjustment[:billing_account][:person][:addresses][:email_address][:email],
+                    eid: adjustment[:billing_account][:person][:addresses][:email_address][:eid]
+                  }
+                }
+              },
+              :billingAccountCategory => {
+                :type => adjustment[:billing_account][:billing_account_category][:type],
+                :description => adjustment[:billing_account][:billing_account_category][:description],
+                :status => adjustment[:billing_account][:billing_account_category][:status],
+                eid: adjustment[:billing_account][:billing_account_category][:eid]
+              },
+              :services => {
+                :pageNumber => adjustment[:billing_account][:services][:page_number],
+                :pageSize => adjustment[:billing_account][:services][:page_size],
+                :totalElements => adjustment[:billing_account][:services][:total_elements],
+                :elementCount => adjustment[:billing_account][:services][:element_count],
+                :totalPages => adjustment[:billing_account][:services][:total_pages]
+              },
+              :paymentTerm => {
+                :name => adjustment[:billing_account][:payment_term][:name],
+                :termDays => adjustment[:billing_account][:payment_term][:term_days],
+                :graceDays => adjustment[:billing_account][:payment_term][:grace_days],
+                eid: adjustment[:billing_account][:payment_term][:eid]
+              }
+            },
+            :reason => {
+              :name => adjustment[:reason][:name],
+              :description => adjustment[:reason][:description],
+              :status => adjustment[:reason][:status],
+              :creditOnly => adjustment[:reason][:credit_only],
+              eid: adjustment[:reason][:eid]
+            }
+          }
         end
 
       end