gotransverse-tract-api 0.5.0 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3a006a5aaaeae6a6d56f4ed22478c393c416cddd
-  data.tar.gz: dd75eceecbea5cebc3e05b2f78c0b92c83203cf0
+  metadata.gz: 1340d5bebe6cca5359967a7b96282e234aa5ec03
+  data.tar.gz: 6d944de781f4a991719829fd87ace1de13fafc83
 SHA512:
-  metadata.gz: d18ab13ad5bb93485dbc545d4f6fe6c29f6e229d74392e28183f278b4b1e5bcdac959d54ac5ff0d0da975855f69e389edc691d2320a6183322fc2ee42d292e9b
-  data.tar.gz: f3964ace33739b0247208969bbcf2b7707fce8a4fa6b74d9a6a7c19b6cdfc287a6e904e44fec6d8118b4bf0c0f477de906c5199848afd39d667c330df23a4d66
+  metadata.gz: 08606f90f2de2b87b6d0bdee0c49e2710a58d42d87573d3d83340f27567fbb90ef8952bf662fbfcdfc73cebeb1a81996adbdf0e9343de6a7e755951218091710
+  data.tar.gz: f7a22b021f12a963c3f9f66a8f2e6fffb3b247888887f72e5ab33065a2829c3767a878b4c2499b23a649db96a69b5f6d372bed6121f6c70eef981b7b369bd001

data/lib/gotransverse-tract-api.rb

@@ -48,6 +48,16 @@ require "gotransverse-tract-api/order/people"
 require "gotransverse-tract-api/order/product_relation"
 require "gotransverse-tract-api/order/renewal_order"
 require "gotransverse-tract-api/order/sales_order"
+require "gotransverse-tract-api/order/agreement_configuration"
+require "gotransverse-tract-api/order/discount_configuration"
+require "gotransverse-tract-api/order/inventory_item"
+require "gotransverse-tract-api/order/order_item_usage_rule"
+require "gotransverse-tract-api/order/price_range"
+require "gotransverse-tract-api/order/product_usage_rule"
+require "gotransverse-tract-api/order/recurring_product_price"
+require "gotransverse-tract-api/order/scheduled_charge"
+require "gotransverse-tract-api/order/usage_rate"
+require "gotransverse-tract-api/product/service_resource_category"
 
 require "gotransverse-tract-api/product/action"
 require "gotransverse-tract-api/product/discount_category"
@@ -239,7 +249,7 @@ module GoTransverseTractApi
       when :get
         response = http_client.get(api_url, api_params)
       when :post
-        response = http_client.post(api_url, request_body, {'Content-Type' => 'application/xml'})
+        response = http_client.post(api_url, request_body, {'Content-Type' => 'application/xml', 'Accept' => 'application/xml'})
       when :put
         response = http_client.put(api_url, request_body, api_params)
     end

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

@@ -56,13 +56,8 @@ module GoTransverseTractApi
           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)
-          }
+          attributes: {},
+          orderItem: Order::OrderItem.get_order_item(sales_order[:order_items][:order_item])
         },
         billingAccount: get_billing_account(sales_order[:billing_account])
       }
@@ -176,6 +171,14 @@ module GoTransverseTractApi
     end
 
     def get_billing_account(billing_account)
+      {
+        attributes: {
+          eid: billing_account[:eid]
+        }
+      }
+    end
+
+    def get_full_billing_account(billing_account)
       ba_details = {
         attributes: {
           accountNum: billing_account[:account_num],
@@ -187,7 +190,7 @@ module GoTransverseTractApi
           startDate: billing_account[:start_date],
           taxExempt: billing_account[:tax_exempt],
           eid: billing_account[:eid]
-        },
+        }.delete_if{|k,v| v.nil?},
         dailyBillCycle: {
           name: billing_account[:daily_bill_cycle][:name],
           startDate: billing_account[:daily_bill_cycle][:start_date],
@@ -197,7 +200,7 @@ module GoTransverseTractApi
           usePaymentTerm: billing_account[:daily_bill_cycle][:use_payment_term],
           status: billing_account[:daily_bill_cycle][:status],
           eid: billing_account[:daily_bill_cycle][:eid]
-        },
+        }.delete_if{|k,v| v.nil?},
         person: {
           attributes: {
             firstName: billing_account[:person][:first_name],
@@ -205,22 +208,22 @@ module GoTransverseTractApi
             eid: billing_account[:person][:eid]
           },
           addresses: get_addresses(billing_account[:person])
-        },
+        }.delete_if{|k,v| v.nil?},
         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]
-        },
+        }.delete_if{|k,v| v.nil?},
         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]
-        }
+        }.delete_if{|k,v| v.nil?}
       }
 
-      ba_details
+      ba_details.delete_if{|k,v| v.nil?}
     end
 
     def get_addresses(entity)

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

@@ -150,31 +150,32 @@ module GoTransverseTractApi
       def self.create_payment payment
         data = {
           payment: {
+            useRecurringPayment: payment[:use_recurring_payment],
             amount: payment[:amount],
             description: payment[:description]
           },
           billingAccount: {
-            eid: payment[:billing_account][:eid]
+            eid: payment[:billing_account].try(:[],: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]
-          },
+            cardType: payment[:credit_card_payment].try(:[],:card_type),
+            cardHolderFirstName: payment[:credit_card_payment].try(:[],:card_holder_first_name),
+            cardHolderLastName: payment[:credit_card_payment].try(:[],:card_holder_last_name),
+            cardIdentifierNumber: payment[:credit_card_payment].try(:[],:card_identifier_number),
+            cardExpiration: payment[:credit_card_payment].try(:[],:card_expiration)
+          }.delete_if{|k,v| v.nil?},
           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]
-          },
+            countryCode: payment[:phone_number].try(:[],:country_code),
+            areaCode: payment[:phone_number].try(:[],:area_code),
+            number: payment[:phone_number].try(:[],:number),
+            extension: payment[:phone_number].try(:[],:extension),
+            purpose: payment[:phone_number].try(:[],:purpose)
+          }.delete_if{|k,v| v.nil?},
           emailAddress: {
-            email: payment[:email_address][:email],
-            purpose: payment[:email_address][:purpose]
-          }
-        }
+            email: payment[:email_address].try(:[],:email),
+            purpose: payment[:email_address].try(:[],:purpose)
+          }.delete_if{|k,v| v.nil?}
+        }.delete_if{|k,v| v.empty?}
 
         xml_data = GoTransverseTractApi.generateXML(data, 'payment')
         GoTransverseTractApi.post_request_for(self, {}, xml_data, "")

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

@@ -21,7 +21,7 @@ module GoTransverseTractApi
         # @param {Long} account_num
         #
         def find_by_account_num account_num
-          GoTransverseTractApi.get_response_for(self, {account_num: account_num})
+          GoTransverseTractApi.get_response_for(self, {account_num: account_num, query_scope: 'DEEP'})
         end
 
         #

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

@@ -65,6 +65,14 @@ module GoTransverseTractApi
           GoTransverseTractApi.get_response_for(self, {thru_date: thru_date})
         end
 
+        #
+        # @param {Hash} agreement
+        #
+        def get_selected_agreement agreement
+          {
+            eid: agreement[:eid]
+          }
+        end
       end
     end
 

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

@@ -0,0 +1,24 @@
+module GoTransverseTractApi
+
+  module Order
+
+    class AgreementConfiguration
+
+      def self.get_agreement_conf agreement_conf
+        {
+          nextAgreement: agreement_conf[:next_agreement],
+          nextServiceProduct: agreement_conf[:next_service_product],
+          nextServiceProductPrice: agreement_conf[:next_service_product_price],
+          endDate: agreement_conf[:end_date],
+          endAction: agreement_conf[:end_action],
+          nextEndAction: agreement_conf[:next_end_action],
+          preserveServicePrice: agreement_conf[:preserve_service_price],
+          nextPreserveServicePrice: agreement_conf[:next_preserve_service_price]
+        }.delete_if{|k,v| v.nil?}
+      end
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,28 @@
+module GoTransverseTractApi
+
+  module Order
+
+    class DiscountConfiguration
+
+      def self.get_discount_configurations discount_configurations
+        disc_configurations = {
+          attributes: {},
+          discountConfiguration: {
+            attributes: {},
+            discountIdentifier: {
+              eid: discount_configurations[:discount_configuration][:discount_identifier][:eid]
+            }
+          }
+        }
+
+        disc_configurations
+      end
+
+    end
+
+  end
+
+end
+            #overrideAmount: discount_configurations[:override_amount],
+            #overridePercentage: discount_configurations[:override_percentage],
+            #overrideDuration: discount_configurations[:override_duration]

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

@@ -0,0 +1,22 @@
+module GoTransverseTractApi
+
+  module Order
+
+    class InventoryItem
+
+      class << self
+        def get_inventory_item inventory_item
+          {
+            eid: inventory_item[:eid],
+            product: inventory_item[:product],
+            serialNumber: inventory_item[:serial_number],
+            status: inventory_item[:status],
+          }
+        end
+      end
+
+    end
+
+  end
+
+end

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

@@ -190,6 +190,49 @@ module GoTransverseTractApi
         GoTransverseTractApi.post_request_for(self, {eid: eid}, xml_data, "deny")
       end
 
+      #
+      # @param {Hash} order_item
+      #
+
+      def self.get_order_item(order_item)
+        if order_item.has_key?(:price_list)
+          price_list = Product::PriceList.get_price_list(order_item[:price_list])
+        end
+
+        if order_item.has_key?(:inventory_item)
+          inventory_item = InventoryItem.get_inventory_item(order_item[:inventory_item])
+        end
+
+        if order_item.has_key?(:scheduled_charges)
+          scheduled_charges = ScheduledCharge.get_scheduled_charges(order_item[:scheduled_charges])
+        end
+
+        orderItem = {
+          attributes: {
+            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],
+            description: order_item[:description],
+            eid: order_item[:eid]
+          }.delete_if{|k,v| v.nil?},
+          orderItemUsageRules: OrderItemUsageRule.get_order_item_usage_rule(order_item[:order_item_usage_rules]),
+          recurringProductPrice: RecurringProductPrice.get_recurring_product_price(order_item[:recurring_product_price]),
+          product: Product::Product.get_product_info(order_item[:product]),
+          priceList: price_list,
+          selectedAgreement: Agreement.get_selected_agreement(order_item[:selected_agreement]),
+          serviceResources: Service::ServiceResource.get_service_resource(order_item[:service_resources]),
+          inventoryItem: inventory_item, 
+          agreementConfiguration: AgreementConfiguration.get_agreement_conf(order_item[:agreement_configuration]),
+          scheduledCharges: scheduled_charges, 
+          discountConfigurations: DiscountConfiguration.get_discount_configurations(order_item[:discount_configurations])
+        }
+
+        orderItem.delete_if{|k,v| v.nil?}
+      end
+
     end
 
   end

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

@@ -0,0 +1,65 @@
+module GoTransverseTractApi
+
+  module Order
+
+    class OrderItemUsageRule
+
+      class << self
+
+        #
+        # @param {Long} eid
+        #
+        def find_by_eid eid
+          GoTransverseTractApi.get_response_for(self, {eid: eid})
+        end
+
+        #
+        # @param {Long} order_item_eid
+        #
+        def find_by_order_item_eid order_item_eid
+          GoTransverseTractApi.get_response_for(self, {order_item_eid: order_item_eid})
+        end
+
+
+        def get_order_item_usage_rule(order_item_usage_rule)
+          if order_item_usage_rule.has_key?(:match_all_order_item_usage_rule)
+            if order_item_usage_rule[:match_all_order_item_usage_rule].has_key?(:usage_rate)
+              usage_rate = UsageRate.get_usage_rate(order_item_usage_rule[:match_all_order_item_usage_rule][:usage_rate])
+            end
+          end 
+
+          order_item_usage_rules = {
+            attributes: {},
+            matchAllOrderItemUsageRule: {
+              attributes: {
+                eid: order_item_usage_rule[:match_all_order_item_usage_rule][:eid],
+                limit: order_item_usage_rule[:match_all_order_item_usage_rule][:limit],
+                usageUom: order_item_usage_rule[:match_all_order_item_usage_rule][:usage_uom],
+                name: order_item_usage_rule[:match_all_order_item_usage_rule][:name],
+                order: order_item_usage_rule[:match_all_order_item_usage_rule][:order],
+                proratedOnOrder: order_item_usage_rule[:match_all_order_item_usage_rule][:prorated_on_order],
+                proratedOnCancel: order_item_usage_rule[:match_all_order_item_usage_rule][:prorated_on_cancel],
+                rollOverType: order_item_usage_rule[:match_all_order_item_usage_rule][:roll_over_type],
+                allowanceType: order_item_usage_rule[:match_all_order_item_usage_rule][:allowance_type],
+                validFrom: order_item_usage_rule[:match_all_order_item_usage_rule][:valid_from],
+                validTo: order_item_usage_rule[:match_all_order_item_usage_rule][:valid_to],
+                ruleType: order_item_usage_rule[:match_all_order_item_usage_rule][:rule_type],
+                status: order_item_usage_rule[:match_all_order_item_usage_rule][:status],
+                chargeCategory: order_item_usage_rule[:match_all_order_item_usage_rule][:charge_category]
+              }.delete_if{|k,v| v.nil?},
+              matchAllProductUsageRule: {
+                eid: order_item_usage_rule[:match_all_order_item_usage_rule][:match_all_product_usage_rule][:eid]
+              },
+              usageRate: usage_rate
+            }
+          }
+
+          order_item_usage_rules.delete_if{|k,v| v.nil?}
+        end
+      end
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,29 @@
+module GoTransverseTractApi
+
+  module Order
+
+    class PriceRange
+
+      class << self
+        def get_price_ranges(price_ranges)
+          priceRanges = {
+            attributes: {},
+            priceRange: {
+              quantityBeginRange: price_ranges[:price_range][:quantity_begin_range],
+              quantityEndRange: price_ranges[:price_range][:quantity_end_range],
+              price: price_ranges[:price_range][:price],
+              level: price_ranges[:price_range][:level],
+              currencyType: price_ranges[:price_range][:currency_type],
+              eid: price_ranges[:price_range][:eid]
+            }
+          }
+
+          priceRanges
+        end
+      end
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,40 @@
+module GoTransverseTractApi
+
+  module Order
+
+    class ProductUsageRule
+
+      class << self
+        def get_product_usage_rules(product_usage_rules)
+          product_usage_rule = {
+            attributes: api_data.get_page_info(product_usage_rule),
+            matchAllProductUsageRule: {
+              attributes: {
+                eid: product_usage_rule[:eid],
+                limit: product_usage_rule[:limit],
+                usageUom: product_usage_rule[:usage_uom],
+                name: product_usage_rule[:name],
+                order: product_usage_rule[:order],
+                proratedOnOrder: product_usage_rule[:prorated_on_order],
+                proratedOnCancel: product_usage_rule[:prorated_on_cancel],
+                rollOverType: product_usage_rule[:roll_over_type],
+                allowanceType: product_usage_rule[:allowance_type],
+                validFrom: product_usage_rule[:valid_from],
+                validTo: product_usage_rule[:valid_to],
+                ruleType: product_usage_rule[:rule_type],
+                status: product_usage_rule[:status],
+                chargeCategory: product_usage_rule[:charge_category]
+              },
+              usageRate: UsageRate.get_usage_rate(product_usage_rule[:usage_rate])
+            }
+          }
+
+          product_usage_rule
+        end
+      end
+
+    end
+
+  end
+
+end