gotransverse-tract-api 0.3.4 → 0.4.0

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

@@ -34,7 +34,21 @@ module GoTransverseTractApi
       # @param {Hash} address
       #
       def self.add_address eid, address
-        GoTransverseTractApi.post_request_for(self, {eid: eid}, address, "addAddress")
+        data = {
+          :addAddressToParty => {},
+          :person => {eid: eid},
+          :postalAddress => {
+            :purpose => address[:purpose],
+            :country => address[:country],
+            :city => address[:city],
+            :regionOrState => address[:region_or_state],
+            :postalCode => address[:postal_code],
+            :line1 => address[:line1]
+          }
+        }
+
+        xml_data = GoTransverseTractApi.generateXML(data, 'addAddressToParty')
+        GoTransverseTractApi.post_request_for(self, {eid: eid}, xml_data, "addAddress")
       end
 
       #

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

@@ -49,23 +49,21 @@ module GoTransverseTractApi
       # @param {Hash} address
       #
       def self.add_address eid, address
-        GoTransverseTractApi.post_request_for(self, {eid: eid}, address, "addAddress")
-      end
+        data = {
+          :addAddressToParty => {},
+          :person => {eid: eid},
+          :postalAddress => {
+            :purpose => address[:purpose],
+            :country => address[:country],
+            :city => address[:city],
+            :regionOrState => address[:region_or_state],
+            :postalCode => address[:postal_code],
+            :line1 => address[:line1]
+          }
+        }
 
-      #
-      # @param {Long} eid
-      # @param {Hash} person
-      #
-      def self.add_person eid, person
-        GoTransverseTractApi.post_request_for(self, {eid: eid}, person, "addPerson")
-      end
-
-      #
-      # @param {Long} eid
-      # @param {Hash} person
-      #
-      def self.remove_person eid, person
-        GoTransverseTractApi.post_request_for(self, {eid: eid}, person, "removePerson")
+        xml_data = GoTransverseTractApi.generateXML(data, 'addAddressToParty')
+        GoTransverseTractApi.post_request_for(self, {eid: eid}, xml_data, "addAddress")
       end
 
     end

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

@@ -103,14 +103,67 @@ module GoTransverseTractApi
         # @param {Hash} sales_order
         #
         def confirm eid, sales_order
-          GoTransverseTractApi.post_request_for(self, {eid: eid}, sales_order)
+          payment = sales_order[:payment]
+          sales_order = sales_order[:sales_order]
+
+          order_item_struct = prepare_products_struct(sales_order)
+
+          data = {
+            :confirmOrder => {},
+            :salesOrder => {
+              :attributes => {
+                :referral => sales_order[:referral],
+                :orderDate => sales_order[:order_date],
+                :orderStatus => sales_order[:order_status],
+                eid: eid
+              },
+              :orderItems => {
+                :attributes => GoTransverseTractApi::ApiData.new.get_page_info(sales_order[:order_items]),
+                :orderItem => order_item_struct
+              },
+              :billingAccount => {
+                :automaticRecurringPayment => sales_order[:billing_account][:automatic_recurring_payment],
+                eid: sales_order[:billing_account][:eid]
+              }
+            },
+            :payment => {
+              :attributes => {
+                :amount => payment[:amount],
+                :description => payment[:description]
+              },
+              :billingAccount => {
+                :automaticRecurringPayment => payment[:billing_account][:automatic_recurring_payment],
+                eid: payment[:billing_account][:eid]
+              },
+              :creditCardPayment => {
+                :cardType => payment[:credit_card_payment][:card_type],
+                :cardHolderFirstName => payment[:credit_card_payment][:card_holder_first_name],
+                :cardHolderMiddleName => payment[:credit_card_payment][:card_holder_middle_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]
+              }
+            }
+          }
+           
+          xml_data = GoTransverseTractApi.generateXML(data, 'confirmOrder')     
+
+          GoTransverseTractApi.post_request_for(self, {eid: eid}, xml_data, 'confirm')
         end
 
         #
         # @param {Long} eid
         # @param {Hash} sales_order
         #
-        def self.add_custom_field_value eid, sales_order
+        def add_custom_field_value(eid, sales_order)
+          data = 
+            {
+              :addCustomFieldValue => {},
+              :order => { eid: eid },
+              :customFieldValue => { :value => sales_order[:value] }
+            }
+
+          xml_data = GoTransverseTractApi.generateXML(data,'addCustomFieldValue')
           GoTransverseTractApi.post_request_for(self, {eid: eid}, sales_order, "addCustomFieldValue")
         end
 
@@ -118,17 +171,211 @@ module GoTransverseTractApi
         # @param {Long} eid
         # @param {Hash} sales_order
         #
-        def self.remove_custom_field_value eid, sales_order
+        def remove_custom_field_value eid, sales_order
+          data = {
+            :removeCustomFieldValue => {},
+            :order => { eid: eid },
+            :customFieldValue => { eid: sales_order[:eid] }
+          }
+ 
+          xml_data = GoTransverseTractApi.generateXML(data,'removeCustomFieldValue')
           GoTransverseTractApi.post_request_for(self, {eid: eid}, sales_order, "removeCustomFieldValue")
         end
 
         #
-        # @param {Hash} person
+        # @param {Hash} sales_order
         #
-        def self.create_sales_order sales_order
-          GoTransverseTractApi.post_request_for(self, {}, sales_order, "")
+        def create_sales_order sales_order
+          data = {
+            :salesOrder => {
+              :note => sales_order[:note],
+              :purchaseOrderNumber => sales_order[:purchase_order_number]
+            },
+            :orderItems => {
+              :attributes => {},
+              :orderItem => get_product_struct(sales_order)
+            },
+            :billingAccount => {
+              :attributes => {
+                :billType => sales_order[:billing_account][:bill_type],
+                :automaticRecurringPayment => sales_order[:billing_account][:automatic_recurring_payment]
+              },
+              :dailyBillCycle => {
+                :attributes => {
+                  eid: sales_order[:billing_account][:daily_bill_cycle][:eid]
+                }
+              },
+              :organization => {
+                :attributes => {
+                  :name => sales_order[:billing_account][:organization][:name],
+                  :taxIdNumber => sales_order[:billing_account][:organization][:tax_id_number]
+                },
+                :addresses => {
+                  :attributes => {},
+                  :postalAddress => get_address_struct(sales_order),
+                  :telecomAddress => {
+                    :attributes => {
+                      :dialingPrefix => sales_order[:billing_account][:organization][:addresses][:telecom_address][:dialing_prefix],
+                      :countryCode => sales_order[:billing_account][:organization][:addresses][:telecom_address][:country_code],
+                      :areaCode => sales_order[:billing_account][:organization][:addresses][:telecom_address][:area_code],
+                      :number => sales_order[:billing_account][:organization][:addresses][:telecom_address][:number],
+                      :extension => sales_order[:billing_account][:organization][:addresses][:telecom_address][:extension],
+                      :purpose => sales_order[:billing_account][:organization][:addresses][:telecom_address][:purpose]
+                    }
+                  },
+                  :emailAddress => {
+                    :attributes => {
+                      :email => sales_order[:billing_account][:organization][:addresses][:email_address][:email],
+                      :purpose => sales_order[:billing_account][:organization][:addresses][:email_address][:purpose]
+                    }
+                  }
+                }
+              },
+              :billingAccountCategory => {
+                :attributes => {
+                  eid: sales_order[:billing_account][:billing_account_category][:eid]
+                }
+              }
+            }
+          }
+
+          xml_data = GoTransverseTractApi.generateXML(data, 'salesOrder')     
+          GoTransverseTractApi.post_request_for(self, xml_data, "")
+        end
+
+
+
+        private
+
+        #
+        # @param {Hash} sales_order
+        # Return {Hash} products
+        #
+        def get_product_struct(sales_order)
+          products = {}
+          items = []
+
+          order_item = {
+            :attributes => {
+               :quantity => sales_order[:order_items][:order_item][:quantity],
+               :sequence => sales_order[:order_items][:order_item][:sequence],
+               :description => sales_order[:order_items][:order_item][:description]
+            }
+          }
+
+          items = sales_order[:order_items][:order_item][:product]
+          (0..items.size - 1).each do|i|
+            products = {
+              :product => {
+                :attributes => {
+                  eid: items[i][:eid]
+                }
+              }
+            }
+          end
+
+          order_item.merge products
         end
 
+        #
+        # @param {Hash} sales_order
+        # Return {Hash} postal_addresses
+        #
+        def get_address_struct(sales_order)
+          postal_addresses = []
+          items = []
+
+          items = sales_order[:billing_account][:organization][:addresses][:postal_address]
+
+          (0..items.size - 1).each do|i|
+            postal_addresses << {
+              :postalAddress => {
+                :attributes => {
+                  :purpose => items[i][:purpose],
+                  :country => items[i][:country],
+                  :city => items[i][:city],
+                  :regionOrState => items[i][:region_or_state],
+                  :postalCode => items[i][:postal_code],
+                  :line1 => items[i][:line1],
+                  :line2 => items[i][:line2]
+                }
+              }
+            }
+          end
+
+          postal_addresses
+        end
+
+
+        #
+        # @param {Hash} sales_order
+        # Return {Hash} products
+        #
+        def prepare_products_struct(sales_order)
+          products = {}
+          items = []
+
+          order_item = {
+            :attributes => {
+               :quantity => sales_order[:order_items][:order_item][:quantity]
+            }
+          }
+
+          items = sales_order[:order_items][:order_item][:product]
+          (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 => GoTransverseTractApi::ApiData.new.get_page_info(items[i][:product_prices]),
+                  :productPrice => {
+                    :attributes => {
+                      :fromDate => items[i][:product_prices][:product_price][:from_date],
+                      :priceOverride => items[i][:product_prices][:product_price][:price_override],
+                      :type => items[i][:product_prices][:product_price][:type],
+                      :recurringPaymentRequired => items[i][:product_prices][:product_price][:recurring_payment_required],
+                      eid: items[i][:product_prices][:product_price][:eid]
+                    },
+                    :priceRanges => {
+                      :attributes => GoTransverseTractApi::ApiData.new.get_page_info(items[i][:product_prices][:product_price][:price_ranges]),
+                      :priceRange => {
+                        :quantityBeginRange => items[i][:product_prices][:product_price][:price_ranges][:price_range][:quantity_begin_range],
+                        :price => items[i][:product_prices][:product_price][:price_ranges][:price_range][:price],
+                        :level => items[i][:product_prices][:product_price][:price_ranges][:price_range][:level],
+                        eid: items[i][:product_prices][:product_price][:price_ranges][:price_range][:eid]
+                      }
+                    }
+                  }
+                },
+                :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 => GoTransverseTractApi::ApiData.new.get_page_info(items[i][:actions]),
+                :productUsageRules => GoTransverseTractApi::ApiData.new.get_page_info(items[i][:product_usage_rules])
+              }
+            }
+          end
+
+          order_item.merge products
+        end
 
       end
 

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

@@ -81,7 +81,13 @@ module GoTransverseTractApi
         # @param {Hash} service
         #
         def resume eid, service
-          GoTransverseTractApi.post_request_for(self, {eid: eid}, service, "resume")
+          data = {
+            :resumeService => {},
+            :service => {eid: eid}
+          }
+
+          xml_data = GoTransverseTractApi.generateXML(data, 'resumeService')
+          GoTransverseTractApi.post_request_for(self, {eid: eid}, xml_data, "resume")
         end
 
         #
@@ -89,79 +95,247 @@ module GoTransverseTractApi
         # @param {Hash} service
         #
         def suspend eid, service
-          GoTransverseTractApi.post_request_for(self, {eid: eid}, service, "suspend")
+          data = {
+            :suspendService => {},
+            :service => {eid: eid}
+          }
+
+          xml_data = GoTransverseTractApi.generateXML(data, 'suspendService')
+          GoTransverseTractApi.post_request_for(self, {eid: eid}, xml_data, "suspend")
         end
 
         #
         # @param {Long} eid
         # @param {Hash} service
         #
-        def self.add_service_resource eid, service
-          GoTransverseTractApi.post_request_for(self, {eid: eid}, service, "addServiceResource")
+        def add_service_resource eid, service
+          data = {
+            :addServiceResourceToService => {},
+            :service => {eid: eid},
+            :serviceResource => {
+              :attributes => {
+                :identifier => service[:service_resource][:identifier]
+              },
+              :category => {
+                eid: :service[:service_resource][:category][:eid]
+              }
+            }
+          }
+
+          xml_data = GoTransverseTractApi.generateXML(data, 'addServiceResourceToService')
+          GoTransverseTractApi.post_request_for(self, {eid: eid}, xml_data, "addServiceResource")
         end
 
         #
         # @param {Long} eid
         # @param {Hash} service
         #
-        def self.remove_service_resource eid, service
-          GoTransverseTractApi.post_request_for(self, {eid: eid}, service, "removeServiceResource")
+        def remove_service_resource eid, service
+          data = {
+            :removeServiceResourceFromService => {},
+            :service => {eid: eid},
+            :serviceResource => {eid: service[:service_resource][:eid]}
+          }
+
+          xml_data = GoTransverseTractApi.generateXML(data, 'removeServiceResourceFromService')
+          GoTransverseTractApi.post_request_for(self, {eid: eid}, xml_data, "removeServiceResource")
         end
 
         #
         # @param {Long} eid
         # @param {Hash} service
         #
-        def self.add_service_usage_rule_to_service eid, service
-          GoTransverseTractApi.post_request_for(self, {eid: eid}, service, "addServiceUsageRuleToService")
+        def add_service_usage_rule_to_service eid, service
+          data = {
+            :addServiceUsageRuleToService => {},
+            :service => {eid: eid},
+            :matchAllServiceUsageRule => {
+              :attributes => {
+                :limit => service[:match_all_service_usage_rule][:limit],
+                :usageUom => service[:match_all_service_usage_rule][:usage_uom],
+                :name => service[:match_all_service_usage_rule][:name],
+                :order => service[:match_all_service_usage_rule][:order],
+                :proratedOnOrder => service[:match_all_service_usage_rule][:prorated_on_order],
+                :proratedOnCancel => service[:match_all_service_usage_rule][:prorated_on_cancel],
+                :rollOverType => service[:match_all_service_usage_rule][:roll_over_type],
+                :allowanceType => service[:match_all_service_usage_rule][:allowance_type],
+                :validFrom => service[:match_all_service_usage_rule][:valid_from],
+                :validTo => service[:match_all_service_usage_rule][:valid_to],
+                :ruleType => service[:match_all_service_usage_rule][:rule_type],
+                :status => service[:match_all_service_usage_rule][:status]
+              },
+              :chargeCategory => {
+                eid: service[:match_all_service_usage_rule][:charge_categroy][:eid]
+              },
+              :flatUsageRate => {
+                :uom => service[:match_all_service_usage_rule][:flat_usage_rate][:uom], 
+                :validFrom => service[:match_all_service_usage_rule][:flat_usage_rate][:valid_from], 
+                :validTo => service[:match_all_service_usage_rule][:flat_usage_rate][:valid_to], 
+                :rate => service[:match_all_service_usage_rule][:flat_usage_rate][:rate]
+              }
+            }
+          }
+
+          xml_data = GoTransverseTractApi.generateXML(data, 'addServiceUsageRuleToService')
+          GoTransverseTractApi.post_request_for(self, {eid: eid}, xml_data, "addServiceUsageRule")
         end
 
         #
         # @param {Long} eid
         # @param {Hash} service
         #
-        def self.remove_service_usage_rule_from_service eid, service
-          GoTransverseTractApi.post_request_for(self, {eid: eid}, service, "removeServiceUsageRuleFromService")
+        def remove_service_usage_rule_from_service eid, service
+          data = {
+            :removeServiceUsageRuleFromService => {},
+            :service => {eid: eid},
+            :matchAllServiceUsageRule => {
+              eid: service[:match_all_service_usage_rule][:eid]
+            }
+          }
+          xml_data = GoTransverseTractApi.generateXML(data, 'removeServiceUsageRuleFromService')
+          GoTransverseTractApi.post_request_for(self, {eid: eid}, xml_data, "removeServiceUsageRule")
         end
 
         #
         # @param {Long} eid
         # @param {Hash} service
         #
-        def self.add_agreement eid, service
-          GoTransverseTractApi.post_request_for(self, {eid: eid}, service, "addAgreement")
+        def add_agreement eid, service
+          data = {
+            :addAgreementToService => {},
+            :service => {eid: eid},
+            :agreementService=> {
+              :attributes => {
+                :endAction => service[:agreement_service][:end_action],
+                :endDate => service[:agreement_service][:end_date],
+                :startDate => service[:agreement_service][:start_date]
+              },
+              :agreement => {
+                eid: service[:agreement_service][:agreement][:eid]
+              }
+            }
+          }
+
+          xml_data = GoTransverseTractApi.generateXML(data, 'addAgreementToService')
+          GoTransverseTractApi.post_request_for(self, {eid: eid}, xml_data, "addAgreement")
         end
 
         #
         # @param {Long} eid
         # @param {Hash} service
         #
-        def self.add_counter eid, service
-          GoTransverseTractApi.post_request_for(self, {eid: eid}, service, "addCounter")
+        def add_counter eid, service
+          data = {
+            :addCounterToService => {},
+            :service => {eid: eid},
+            :usageRuleCounter => {
+              :attributes => {
+                :name => service[:usage_rule_counter][:name],
+                :description => service[:usage_rule_counter][:description],
+                :status => service[:usage_rule_counter][:status],
+                :entityRelationType => service[:usage_rule_counter][:entity_relation_type],
+                :uom => service[:usage_rule_counter][:uom],
+                :threshold => service[:usage_rule_counter][:threshold]
+              },
+              :servicePeriodCounterResetCriteria => {}
+            }
+          }
+
+          xml_data = GoTransverseTractApi.generateXML(data, 'addCounterToService')
+          GoTransverseTractApi.post_request_for(self, {eid: eid}, xml_data, "addCounter")
         end
 
         #
         # @param {Long} eid
         # @param {Hash} service
         #
-        def self.add_custom_field_value eid, service
-          GoTransverseTractApi.post_request_for(self, {eid: eid}, service, "addCustomFieldValue")
+        def add_custom_field_value eid, service
+          data = {
+            :addCustomFieldValueToService => {},
+            :service => {eid: eid},
+            :customFieldValue => {
+              :attributes => {
+                :value => service[:custom_field_value][:value]
+              },
+              :customField => {
+                eid: service[:custom_field_value][:custom_field][:eid]
+              }
+            }
+          }
+
+          xml_data = GoTransverseTractApi.generateXML(data, 'addCustomFieldValueToService')
+          GoTransverseTractApi.post_request_for(self, {eid: eid}, xml_data, "addCustomFieldValue")
         end
 
         #
         # @param {Long} eid
         # @param {Hash} service
         #
-        def self.remove_custom_field_value eid, service
-          GoTransverseTractApi.post_request_for(self, {eid: eid}, service, "removeCustomFieldValue")
+        def remove_custom_field_value eid, service
+          data = {
+            :removeCustomFieldValueFromService => {},
+            :service => {eid: eid},
+            :customFieldValue => {
+              eid: service[:custom_field_value][:eid]
+            }
+          }
+
+          xml_data = GoTransverseTractApi.generateXML(data, 'removeCustomFieldValueFromService')
+          GoTransverseTractApi.post_request_for(self, {eid: eid}, xml_data, "removeCustomFieldValue")
         end
 
         #
         # @param {Long} eid
         # @param {Hash} service
         #
-        def self.add_discount_identifier eid, service
-          GoTransverseTractApi.post_request_for(self, {eid: eid}, service, "addDiscountIdentifier")
+        def add_discount_identifier eid, service
+          api_data = GoTransverseTractApi::ApiData.new
+
+          data = { 
+            :addDiscountIdentifierToService => {},
+            :service => {
+              :attributes => {
+                :amount => service[:amount],
+                :startDate => service[:start_date],
+                :status => service[:status],
+                :description => service[:description],
+                :renewalCount => service[:renewal_count],
+                eid: service[:eid],
+                :queryScope => service[:query_scope]
+              },
+              :billingAccount => {
+                eid: service[:billing_account][:eid],
+                :queryScope => service[:billing_account][:query_scope]
+              },
+              :serviceResources => GoTransverseTractApi::ApiData.new.get_page_info(service[:service_resources]),
+              :product => {
+                eid: service[:product][:eid],
+                :queryScope => service[:product][:query_scope]
+              },
+              :servicePeriods => api_data.get_page_info(service[:service_periods]),
+              :servicePrices => api_data.get_page_info(service[:service_prices]),
+              :serviceUsageRules => api_data.get_page_info(service[:service_usage_rules]),
+              :counters => api_data.get_page_info(service[:counters]),
+              :customFieldValues => api_data.get_page_info(service[:custom_field_values])
+            },
+            :discountIdentifier => {
+              :attributes => {
+                :status => service[:discount_identifier][:status],
+                :unlimited => service[:discount_identifier][:unlimited],
+                :uses => service[:discount_identifier][:uses],
+                :identifier => service[:discount_identifier][:identifier],
+                eid: service[:discount_identifier][:eid],
+                :queryScope => service[:discount_identifier][:query_scope]
+              },
+              :category => {
+                eid: service[:discount_identifier][:category][:eid],
+                :queryScope => service[:discount_identifier][:category][:query_scope]
+              }
+            }
+          }
+
+          xml_data = GoTransverseTractApi.generateXML(data, 'addDiscountIdentifierToService')
+          GoTransverseTractApi.post_request_for(self, {eid: eid}, xml_data, "addDiscountIdentifier")
         end
 
         #
@@ -169,7 +343,17 @@ module GoTransverseTractApi
         # @param {Hash} service
         #
         def change_price eid, service
-          GoTransverseTractApi.post_request_for(self, {eid: eid}, service, "changePrice")
+          data = {
+            :changeServicePrice => {
+              :attributes => {
+                :newRecurringUnitPrice => service[:new_recurring_unit_price]
+              },
+              :service => {eid: eid}
+            }
+          }
+
+          xml_data = GoTransverseTractApi.generateXML(data, 'changeServicePrice')
+          GoTransverseTractApi.post_request_for(self, {eid: eid}, xml_data, "changePrice")
         end
 
         #
@@ -177,7 +361,18 @@ module GoTransverseTractApi
         # @param {Hash} service
         #
         def change_quantity eid, service
-          GoTransverseTractApi.post_request_for(self, {eid: eid}, service, "changeQuantity")
+          data = {
+            :changeServiceQuantity => {
+              :attributes => {
+                :newQuantity => service[:new_quantity],
+                :effectiveDate => service[:effective_date]
+              },
+              :service => {eid: eid}
+            }
+          }
+
+          xml_data = GoTransverseTractApi.generateXML(data, 'changeServiceQuantity')
+          GoTransverseTractApi.post_request_for(self, {eid: eid}, xml_data, "changeQuantity")
         end
 
         #
@@ -185,7 +380,55 @@ module GoTransverseTractApi
         # @param {Hash} service
         #
         def renew eid, service
-          GoTransverseTractApi.post_request_for(self, {eid: eid}, service, "renew")
+          data = {
+            :renewService => {},
+            :service => {
+              :attributes => {eid: eid},
+              :billingAccount => {
+                eid: service[:billing_account][:eid]
+              }
+            },
+            :order => { 
+              :attributes => {},
+              :orderItems => {
+                :attributes => {},
+                :orderItem => {
+                  :attributes => {
+                    :quantity => service[:order][:order_items][:order_item][:quantity],
+                    :sequence => service[:order][:order_items][:order_item][:sequence]
+                  },
+                  :product => {
+                    eid: service[:order][:order_items][:order_item][:product][:eid]
+                  },
+                  :selectedAgreement => {
+                    eid: service[:order][:order_items][:order_item][:selected_agreement][:eid]
+                  }
+                }
+              },
+              :billingAccount => { eid: service[:order][:billing_account][:eid] },
+              :payments => { 
+                :attributes => {},
+                :payment => {
+                  :attributes => {
+                    :amount => service[:order][:payments][:payment][:amount],
+                    :description => service[:order][:payments][:payment][:description]
+                  },
+                  :billingAccount => { eid: service[:order][:payments][:payment][:billing_account][:eid] },
+                  :creditCardPayment => {
+                    :cardType => service[:order][:payments][:payment][:credit_card_payment][:card_type],
+                    :cardHolderFirstName => service[:order][:payments][:payment][:credit_card_payment][:card_holder_first_name],
+                    :cardHolderMiddleName => service[:order][:payments][:payment][:credit_card_payment][:card_holder_middle_name],
+                    :cardHolderLastName => service[:order][:payments][:payment][:credit_card_payment][:card_holder_last_name],
+                    :cardIdentifierNumber => service[:order][:payments][:payment][:credit_card_payment][:card_identifier_number],
+                    :cardExpiration => service[:order][:payments][:payment][:credit_card_payment][:card_expiration]
+                  }
+                }
+              }
+            }
+          }
+
+          xml_data = GoTransverseTractApi.generateXML(data, 'renewService')
+          GoTransverseTractApi.post_request_for(self, {eid: eid}, xml_data, "renew")
         end
 
         #
@@ -193,7 +436,13 @@ module GoTransverseTractApi
         # @param {Hash} service
         #
         def deactivate eid, service
-          GoTransverseTractApi.post_request_for(self, {eid: eid}, service, "deactivate")
+          data = {
+            :deactivateService => {},
+            :service => {eid: eid}
+          }
+
+          xml_data = GoTransverseTractApi.generateXML(data, 'deactivateService')
+          GoTransverseTractApi.post_request_for(self, {eid: eid}, xml_data, "deactivate")
         end
 
         #