gotransverse-tract-api 0.3.4 → 0.4.0

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

@@ -126,7 +126,8 @@ module GoTransverseTractApi
         # @param {Hash} billing_account
         #
         def apply_payment eid, billing_account
-          GoTransverseTractApi.post_request_for(self, {eid: eid}, billing_account, "applyPayment")
+          xml_data = GoTransverseTractApi::ApiData.new.payment_details(billing_account, 'Y')
+          GoTransverseTractApi.post_request_for(self, {eid: eid}, xml_data, "applyPayment")
         end
 
         #
@@ -134,7 +135,8 @@ module GoTransverseTractApi
         # @param {Hash} billing_account
         #
         def suspend eid, billing_account
-          GoTransverseTractApi.post_request_for(self, {eid: eid}, billing_account, "suspend")
+          xml_data = GoTransverseTractApi::ApiData.new.shutdown(billing_account, eid, 'suspendBillingAccount')
+          GoTransverseTractApi.post_request_for(self, {eid: eid}, xml_data, "suspend")
         end
 
         #
@@ -142,7 +144,15 @@ module GoTransverseTractApi
         # @param {Hash} billing_account
         #
         def resume eid, billing_account
-          GoTransverseTractApi.post_request_for(self, {eid: eid}, billing_account, "resume")
+          data = {
+            :resumeBillingAccount => {},
+            :billingAccount => {eid: eid},
+            :startDate => billing_account[:start_date],
+            :notes => billing_account[:notes]
+          }
+
+          xml_data = GoTransverseTractApi.generateXML(data, 'resumeBillingAccount')
+          GoTransverseTractApi.post_request_for(self, {eid: eid}, xml_data, "resume")
         end
 
         #
@@ -150,7 +160,23 @@ module GoTransverseTractApi
         # @param {Hash} billing_account
         #
         def add_recurring_payment eid, billing_account
-          GoTransverseTractApi.post_request_for(self, {eid: eid}, billing_account, "addRecurringPayment")
+          data = {
+            :addRecurringPaymentToBillingAccount => {},
+            :billingAccount => {eid: eid},
+            :recurringPayment => {
+              :attributes => {},
+              :creditCardPaymentMethod => {
+                :cardType => billing_account[:recurring_payment][:credit_card_payment_method][:card_type],
+                :cardHolderFirstName => billing_account[:recurring_payment][:credit_card_payment_method][:card_holder_first_name],
+                :cardHolderLastName => billing_account[:recurring_payment][:credit_card_payment_method][:card_holder_last_name],
+                :cardIdentifierNumber => billing_account[:recurring_payment][:credit_card_payment_method][:card_identifier_number],
+                :cardExpiration => billing_account[:recurring_payment][:credit_card_payment_method][:card_expiration]
+              }
+            }
+          }
+
+          xml_data = GoTransverseTractApi.generateXML(data, 'addRecurringPaymentToBillingAccount')
+          GoTransverseTractApi.post_request_for(self, {eid: eid}, xml_data, "addRecurringPayment")
         end
 
         #
@@ -158,7 +184,30 @@ module GoTransverseTractApi
         # @param {Hash} billing_account
         #
         def change_service eid, billing_account
-          GoTransverseTractApi.post_request_for(self, {eid: eid}, billing_account, "changeService")
+          data = {
+            :changeService => {},
+            :service => {
+              eid: billing_account[:service][:eid]
+            },
+            :order => {
+              :attributes => {
+                :note => billing_account[:order][:note]
+              },
+              :orderItems => {
+                :attributes => {},
+                :orderItem => {
+                  :attributes => {
+                    :quantity => billing_account[:order][:order_items][:order_item][:quantity],
+                    :description => billing_account[:order][:order_items][:order_item][:description]
+                  },
+                  :products => get_products(billing_account)
+                }
+              },
+              :billingAccount => {eid: eid}
+            }  
+          }
+          xml_data = GoTransverseTractApi.generateXML(data, 'changeService')
+          GoTransverseTractApi.post_request_for(self, {eid: eid}, xml_data, "changeService")
         end
 
         #
@@ -166,6 +215,14 @@ module GoTransverseTractApi
         # @param {Hash} billing_account
         #
         def add_custom_field_value eid, billing_account
+          data = {
+            :addCustomFieldValue => {},
+            :billingAccount => {eid: eid},
+            :customFieldValue => {
+              :value => billing_account[:custom_field_value][:value]
+            }
+          }
+          xml_data = GoTransverseTractApi.generateXML(data, 'addCustomFieldValue')
           GoTransverseTractApi.post_request_for(self, {eid: eid}, billing_account, "addCustomFieldValue")
         end
 
@@ -174,7 +231,15 @@ module GoTransverseTractApi
         # @param {Hash} billing_account
         #
         def remove_custom_field_value eid, billing_account
-          GoTransverseTractApi.post_request_for(self, {eid: eid}, billing_account, "removeCustomFieldValue")
+          data = {
+            :removeCustomFieldValue => {},
+            :billingAccount => {eid: eid},
+            :customFieldValue => {
+              eid: billing_account[:custom_field_value][:eid]
+            }
+          }
+          xml_data = GoTransverseTractApi.generateXML(data, 'removeCustomFieldValue')
+          GoTransverseTractApi.post_request_for(self, {eid: eid}, xml_data, "removeCustomFieldValue")
         end
 
         #
@@ -182,7 +247,21 @@ module GoTransverseTractApi
         # @param {Hash} billing_account
         #
         def add_person eid, billing_account
-          GoTransverseTractApi.post_request_for(self, {eid: eid}, billing_account, "addPerson")
+          data = {
+            :addPersonToBillingAccount => {},
+            :billingAccount => {eid: eid},
+            :person => {
+              :attributes => {
+                :firstName => billing_account[:person][:first_name],
+                :lastName => billing_account[:person][:last_name],
+                :middleName => billing_account[:person][:middle_name]
+              },
+              :addresses => GoTransverseTractApi::ApiData.new.get_addresses(billing_account[:person])
+            }
+          }
+
+          xml_data = GoTransverseTractApi.generateXML(data, 'addPersonToBillingAccount')
+          GoTransverseTractApi.post_request_for(self, {eid: eid}, xml_data, "addPerson")
         end
 
         #
@@ -190,7 +269,14 @@ module GoTransverseTractApi
         # @param {Hash} billing_account
         #
         def remove_billing_account eid, billing_account
-          GoTransverseTractApi.post_request_for(self, {eid: eid}, billing_account, "removePerson")
+          data = {
+            :removePersonFromBillingAccount => {},
+            :billingAccount => { eid: eid },
+            :person => { eid: billing_account[:person][:eid] }
+          }
+
+          xml_data = GoTransverseTractApi.generateXML(data, 'removePersonFromBillingAccount')
+          GoTransverseTractApi.post_request_for(self, {eid: eid}, xml_data, "removePerson")
         end
 
         #
@@ -198,7 +284,13 @@ module GoTransverseTractApi
         # @param {Hash} billing_account
         #
         def create_draft_order eid, billing_account
-          GoTransverseTractApi.post_request_for(self, {eid: eid}, billing_account, "createDraftOrder")
+          data = {
+            :createDraftOrder => {},
+            :salesOrder => GoTransverseTractApi::ApiData.new.sales_order_details(billing_account[:sales_order])
+          }
+
+          xml_data = GoTransverseTractApi.generateXML(data, 'createDraftOrder')
+          GoTransverseTractApi.post_request_for(self, {eid: eid}, xml_data, "createDraftOrder")
         end
 
         #
@@ -206,7 +298,13 @@ module GoTransverseTractApi
         # @param {Hash} billing_account
         #
         def void_draft_order eid, billing_account
-          GoTransverseTractApi.post_request_for(self, {eid: eid}, billing_account, "voidDraftOrder")
+          data = {
+            :voidDraftOrder => {},
+            :salesOrder => GoTransverseTractApi::ApiData.new.sales_order_details(billing_account[:sales_order])
+          }
+
+          xml_data = GoTransverseTractApi.generateXML(data, 'voidDraftOrder')
+          GoTransverseTractApi.post_request_for(self, {eid: eid}, xml_data, "voidDraftOrder")
         end
 
         #
@@ -214,17 +312,36 @@ module GoTransverseTractApi
         # @param {Hash} billing_account
         #
         def deactivate eid, billing_account
-          GoTransverseTractApi.post_request_for(self, {eid: eid}, billing_account, "deactivate")
+          xml_data = GoTransverseTractApi::ApiData.new.shutdown(billing_account, eid, 'deactivateBillingAccount')
+          GoTransverseTractApi.post_request_for(self, {eid: eid}, xml_data, "deactivate")
         end
 
         #
         # @param {Hash} billing_account
         #
         def create_billing_account billing_account
-          GoTransverseTractApi.post_request_for(self, {}, billing_account, "")
+          data = {
+            :billingAccount => {
+              :billType => billing_account[:bill_type]
+            },
+            :dailyBillCycle => {
+              eid: billing_account[:daily_bill_cycle][:eid]
+            },
+            :organization => {
+              :attributes => {
+                :name => billing_account[:organization][:name]
+              },
+              :addresses => GoTransverseTractApi::ApiData.new.get_addresses(billing_account[:organization])
+            },
+            :billingAccountCategory => {
+              eid: billing_account[:billing_account_category][:eid]
+            }
+          }
+          xml_data = GoTransverseTractApi.generateXML(data, 'billingAccount')
+          GoTransverseTractApi.post_request_for(self, {}, xml_data, "")
         end
 
-        #
+        
         # @param {Long} eid
         # @param {Hash} billing_account
         #
@@ -232,6 +349,22 @@ module GoTransverseTractApi
           GoTransverseTractApi.put_request_for(self, {eid: eid}, billing_account)
         end
 
+        private
+
+        def get_products(billing_account)
+          products = []
+          qty = billing_account[:order][:order_items][:order_item][:quantity]
+
+          (0..qty - 1).each do|i|
+            products << {
+              :product => {
+                eid: billing_account[:order][:order_items][:order_item][:products][i][:eid]
+              }
+            }
+          end         
+
+          products
+        end
       end
 
     end

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

@@ -76,7 +76,8 @@ module GoTransverseTractApi
         # @param {Hash} invoice
         #
         def apply_payment eid, invoice
-          GoTransverseTractApi.post_request_for(self, {eid: eid}, invoice, "applyPayment")
+          xml_data = GoTransverseTractApi::ApiData.new.payment_details(invoice)
+          GoTransverseTractApi.post_request_for(self, {eid: eid}, xml_data, "applyPayment")
         end
 
       end

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

@@ -59,13 +59,15 @@ module GoTransverseTractApi
       # @param {String} complete_url
       #
       def self.referrer_token error_url, cancel_url, complete_url
-        body = "<generatePaymentCollectionReferrerToken xmlns='http://www.tractbilling.com/billing/1_28/domain'>
-                 <errorUrl>#{error_url}</errorUrl>
-                 <cancelUrl>#{cancel_url}</cancelUrl>
-                 <completeUrl>#{complete_url}</completeUrl>
-                </generatePaymentCollectionReferrerToken>"
-
-        GoTransverseTractApi.post_request_for(self, body, "referrerToken")[:referrer][:referrerToken]
+        data = {
+          :generatePaymentCollectionReferrerToken => {},
+          :errorUrl => error_url,
+          :completeUrl => complete_url,
+          :cancelUrl => cancel_url
+        }
+        xml_data = GoTransverseTractApi.generateXML(data, 'generatePaymentCollectionReferrerToken' )
+
+        GoTransverseTractApi.post_request_for(self, xml_data, "referrerToken")[:referrer][:referrerToken]
       end
 
       #
@@ -73,7 +75,27 @@ module GoTransverseTractApi
       # @param {Hash} payment
       #
       def self.apply_refund eid, payment
-        GoTransverseTractApi.post_request_for(self, {eid: eid}, payment, "applyRefund")
+        data = {
+          :applyRefund => {},
+          :payment => {
+            eid: payment[:payment][:eid]
+          },
+          :refund => {
+            :attributes => {
+              :amount => payment[:refund][:amount],
+              :description => payment[:refund][:description]
+            },
+            :originalPayment => {
+              eid: payment[:refund][:original_payment][:eid]
+            },
+            :refundReason => {
+              eid: payment[:refund][:refund_reason][:eid]
+            }
+          }
+        }
+
+        xml_data = GoTransverseTractApi.generateXML(data, 'applyRefund')
+        GoTransverseTractApi.post_request_for(self, {eid: eid}, xml_data, "applyRefund")
       end
 
       #
@@ -81,6 +103,19 @@ module GoTransverseTractApi
       # @param {Hash} payment
       #
       def self.cancel eid, payment
+        data = {
+          :cancelPayment => {
+            :description => payment[:description]
+          },
+          :payment => {
+            eid: payment[:payment][:eid]
+          },
+          :reason => {
+            eid: payment[:reason][:eid]
+          }
+        }
+
+        GoTransverseTractApi.generateXML(data, 'cancelPayment')
         GoTransverseTractApi.post_request_for(self, {eid: eid}, payment, "cancel")
       end
 
@@ -89,6 +124,23 @@ module GoTransverseTractApi
       # @param {Hash} payment
       #
       def self.reallocate eid, payment
+        data = {
+          :reallocatePayment => {
+            :description => payment[:description]
+          },
+          :payment => {
+            eid: payment[:payment][:eid]
+          },
+          :reason => {
+            eid: payment[:reason][:eid]
+          },
+          :invoices => {
+            :attributes => {},
+            :invoice => payment[:invoices]
+          }
+        }
+
+        GoTransverseTractApi.generateXML(data, 'reallocatePayment')
         GoTransverseTractApi.post_request_for(self, {eid: eid}, payment, "reallocate")
       end
 
@@ -96,7 +148,36 @@ module GoTransverseTractApi
       # @param {Hash} payment
       #
       def self.create_payment payment
-        GoTransverseTractApi.post_request_for(self, {}, payment, "")
+        data = {
+          :payment => {
+            :amount => payment[:amount],
+            :description => payment[:description]
+          },
+          :billingAccount => {
+            eid: payment[:billing_account][:eid]
+          },
+          :creditCardPayment => {
+            :cardType => payment[:credit_card_payment][:card_type],
+            :cardHolderFirstName => payment[:credit_card_payment][:card_holder_first_name],
+            :cardHolderLastName => payment[:credit_card_payment][:card_holder_last_name],
+            :cardIdentifierNumber => payment[:credit_card_payment][:card_identifier_number],
+            :cardExpiration => payment[:credit_card_payment][:card_expiration]
+          },
+          :phoneNumber => {
+            :countryCode => payment[:phone_number][:country_code],
+            :areaCode => payment[:phone_number][:area_code],
+            :number => payment[:phone_number][:number],
+            :extension => payment[:phone_number][:extension],
+            :purpose => payment[:phone_number][:purpose]
+          },
+          :emailAddress => {
+            :email => payment[:email_address][:email],
+            :purpose => payment[:email_address][:purpose]
+          }
+        }
+
+        xml_data = GoTransverseTractApi.generateXML(data, 'payment')
+        GoTransverseTractApi.post_request_for(self, {}, xml_data, "")
       end
 
     end

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

@@ -68,7 +68,21 @@ module GoTransverseTractApi
       # @param {Hash} refund
       #
       def self.create_refund refund
-        GoTransverseTractApi.post_request_for(self, {}, refund, "")
+        data = {
+          refund: {
+            amount: refund[:amount],
+            description: refund[:description]
+          },
+          originalPayment: {
+            eid: refund[:original_payment][:eid]
+          },
+          refundReason: {
+            eid: refund[:refund_reason][:eid]
+          }
+        }
+
+        xml_data = GoTransverseTractApi.generateXML(data, 'refund')
+        GoTransverseTractApi.post_request_for(self, {}, xml_data, "")
       end
 
     end

data/lib/gotransverse-tract-api/order/order_item.rb

@@ -62,18 +62,190 @@ module GoTransverseTractApi
 
       #
       # @param {Long} eid
-      # @param {Hash} approve
-      #
-      def self.approve eid, approve
-        GoTransverseTractApi.post_request_for(self, {eid: eid}, approve, "approve")
+      # @param {Hash} order_item
+      #
+      def self.approve eid, order_item
+        data = {
+          :approveOrderItem => {
+            :approvalDate => order_item[:approval_date],
+          },
+          :orderItem => {
+            :attributes => {
+              :xsitype => order_item[:type],
+              :awaitingApproval => order_item[:awaiting_approval],
+              :requestedEffectiveDate => order_item[:requested_effective_date],
+              :unitPrice => order_item[:unit_price],
+              :recurringUnitPrice => order_item[:recurring_unit_price],
+              :quantity => order_item[:quantity],
+              :sequence => order_item[:sequence],
+              :approvalDate => order_item[:date_approval],
+              :description => order_item[:description],
+              eid: eid
+            },
+            :orderItems => {
+              :pageNumber => order_item[:order_items][:page_number],
+              :pageSize => order_item[:order_items][:page_size],
+              :totalElements => order_item[:order_items][:total_elements],
+              :elementCount => order_item[:order_items][:element_count],
+              :totalPages => order_item[:order_items][:total_pages]
+            },
+            :orderItemUsageRules => {
+              :pageNumber => order_item[:order_item_usage_rules][:page_number],
+              :pageNumber => order_item[:order_item_usage_rules][:page_number],
+              :totalElements => order_item[:order_item_usage_rules][:total_elements],
+              :elementCount => order_item[:order_item_usage_rules][:element_count],
+              :totalPages => order_item[:order_item_usage_rules][:total_pages]
+            },
+            :recurringProductPrice => {
+              :attributes => {
+                :fromDate => order_item[:recurring_product_price][:from_date],
+                :priceOverride => order_item[:recurring_product_price][:price_override],
+                :type => order_item[:recurring_product_price][:type],
+                :paymentOnPurchaseRequired => order_item[:recurring_product_price][:payment_on_purchase_required],
+                :recurringPaymentRequired => order_item[:recurring_product_price][:recurring_payment_required],
+                :recurrencePeriod => order_item[:recurring_product_price][:recurrence_period],
+                eid: order_item[:recurring_product_price][:eid]
+              },
+              :priceRanges => {
+                :attributes => {
+                  :pageNumber => order_item[:recurring_product_price][:price_ranges][:page_number],
+                  :pageSize => order_item[:recurring_product_price][:price_ranges][:page_size],
+                  :totalElements => order_item[:recurring_product_price][:price_ranges][:total_elements],
+                  :elementCount => order_item[:recurring_product_price][:price_ranges][:element_count],
+                  :totalPages => order_item[:recurring_product_price][:price_ranges][:total_pages]
+                },
+                :priceRange => {
+                  :quantityBeginRange => order_item[:recurring_product_price][:price_ranges][:price_range][:quantity_begin_range],
+                  :price => order_item[:recurring_product_price][:price_ranges][:price_range][:price],
+                  :level => order_item[:recurring_product_price][:price_ranges][:price_range][:level],
+                  eid: order_item[:recurring_product_price][:price_ranges][:price_range][:eid]
+                }
+              }
+            },
+            :product => {
+              :attributes => {
+                :name => order_item[:product][:name],
+                :description => order_item[:product][:description],
+                :shortDescription => order_item[:product][:short_description],
+                :productTypeCode => order_item[:product][:product_type_code],
+                :productState => order_item[:product][:product_state],
+                :requiresAgreement => order_item[:product][:requires_agreement],
+                :serialized => order_item[:product][:serialized],
+                :taxable => order_item[:product][:taxable],
+                :trial => order_item[:product][:trial],
+                :defaultQuantity => order_item[:product][:default_quantity],
+                :internalName => order_item[:product][:internal_name],
+                :minServiceResources => order_item[:product][:min_service_resources],
+                :maxServiceResources => order_item[:product][:max_service_resources],
+                :trialOverride => order_item[:product][:trial_override],
+                eid: order_item[:product][:eid]
+              },
+              :productPrices => {
+                :attributes => {
+                  :pageNumber => order_item[:product][:product_prices][:page_number],
+                  :pageSize => order_item[:product][:product_prices][:page_size],
+                  :totalElements => order_item[:product][:product_prices][:total_elements],
+                  :elementCount => order_item[:product][:product_prices][:element_count],
+                  :totalPages => order_item[:product][:product_prices][:total_pages]
+                },
+                :productPrice => {
+                  :attributes => {
+                    :fromDate => order_item[:product][:product_prices][:product_price][:from_date],
+                    :priceOverride => order_item[:product][:product_prices][:product_price][:price_override],
+                    :type => order_item[:product][:product_prices][:product_price][:type],
+                    :paymentOnPurchaseRequired => order_item[:product][:product_prices][:product_price][:payment_on_purchase_required],
+                    :recurringPaymentRequired => order_item[:product][:product_prices][:product_price][:recurring_payment_required],
+                    :recurrencePeriod => order_item[:product][:product_prices][:product_price][:recurrence_period],
+                    eid: order_item[:product][:product_prices][:product_price][:eid]
+                  },
+                  :priceRanges => {
+                    :attributes => {
+                      :pageNumber => order_item[:product][:product_prices][:product_price][:price_ranges][:page_number],
+                      :pageSize => order_item[:product][:product_prices][:product_price][:price_ranges][:page_size],
+                      :totalElements => order_item[:product][:product_prices][:product_price][:price_ranges][:total_elements],
+                      :elementCount => order_item[:product][:product_prices][:product_price][:price_ranges][:element_count],
+                      :totalPages => order_item[:product][:product_prices][:product_price][:price_ranges][:total_pages]
+                    },
+                    :priceRange => {
+                      :quantityBeginRange => order_item[:product][:product_prices][:product_price][:price_ranges][:price_range][:quantity_begin_range],
+                      :price => order_item[:product][:product_prices][:product_price][:price_ranges][:price_range][:price],
+                      :level => order_item[:product][:product_prices][:product_price][:price_ranges][:price_range][:level],
+                      eid: order_item[:product][:product_prices][:product_price][:price_ranges][:price_range][:eid]
+                    }
+                  }
+                }
+              },
+              :productCategory => {
+                :name => order_item[:product][:product_category][:name],
+                :description => order_item[:product][:product_category][:description],
+                :status => order_item[:product][:product_category][:status],
+                eid: order_item[:product][:product_category][:eid]
+              },
+              :serviceResourceCategory => {
+                :name => order_item[:product][:service_resource_category][:name],
+                :type => order_item[:product][:service_resource_category][:type],
+                :status => order_item[:product][:service_resource_category][:status],
+                eid: order_item[:product][:service_resource_category][:eid]
+              },
+              :actions => {
+                :pageNumber => order_item[:product][:actions][:page_number],
+                :pageSize => order_item[:product][:actions][:page_size],
+                :totalElements => order_item[:product][:actions][:total_elements],
+                :elementCount => order_item[:product][:actions][:element_count],
+                :totalPages => order_item[:product][:actions][:total_pages]
+              },
+              :productUsageRules => {
+                :pageNumber => order_item[:product][:product_usage_rules][:page_number],
+                :pageNumber => order_item[:product][:product_usage_rules][:page_number],
+                :totalElements => order_item[:product][:product_usage_rules][:total_elements],
+                :elementCount => order_item[:product][:product_usage_rules][:element_count],
+                :totalPages => order_item[:product][:product_usage_rules][:total_pages]
+              }
+            },
+            :priceList => {
+              :name => order_item[:price_list][:name],
+              eid: order_item[:price_list][:eid]
+            },
+            :serviceResources => {
+              :pageNumber => order_item[:service_resources][:page_number],
+              :pageNumber => order_item[:service_resources][:page_number],
+              :totalElements => order_item[:service_resources][:total_elements],
+              :elementCount => order_item[:service_resources][:element_count],
+              :totalPages => order_item[:service_resources][:total_pages]
+            },
+            :operationAttributes => {
+              :pageNumber => order_item[:operation_attributes][:page_number],
+              :pageNumber => order_item[:operation_attributes][:page_number],
+              :totalElements => order_item[:operation_attributes][:total_elements],
+              :elementCount => order_item[:operation_attributes][:element_count],
+              :totalPages => order_item[:operation_attributes][:total_pages]
+            },
+            :scheduledCharges => {
+              :pageNumber => order_item[:scheduled_charges][:page_number],
+              :pageNumber => order_item[:scheduled_charges][:page_number],
+              :totalElements => order_item[:scheduled_charges][:total_elements],
+              :elementCount => order_item[:scheduled_charges][:element_count],
+              :totalPages => order_item[:scheduled_charges][:total_pages]
+            }
+          }
+        }
+
+        xml_data = GoTransverseTractApi.generateXML(data, 'approveOrderItem')
+        GoTransverseTractApi.post_request_for(self, {eid: eid}, xml_data, "approve")
       end
 
       #
       # @param {Long} eid
-      # @param {Hash} deny
+      # @param {Hash} orderitem
       #
-      def self.deny eid, deny
-        GoTransverseTractApi.post_request_for(self, {eid: eid}, deny, "deny")
+      def self.deny eid, orderitem
+        data = {
+          :denyOrderItem => {},
+          :orderItem => {eid: eid}
+        }
+
+        xml_data = GoTransverseTractApi.generateXML(data, 'denyOrderItem')
+        GoTransverseTractApi.post_request_for(self, {eid: eid}, xml_data, "deny")
       end
 
     end