ruby_omx 0.0.19 → 0.0.20

data/lib/ruby_omx/base.rb

@@ -5,30 +5,14 @@ module RubyOmx
 	class Base
   	attr_accessor :connection
 
-    #def self.debug; @@debug ||= false end
-    #def self.debug=(bool); @@debug = bool end
-      
     def initialize(options ={})
       @http_biz_id = options['http_biz_id']
       @udi_auth_token = options['udi_auth_token']
       raise RubyOmx::MissingAccessKey.new(['udi auth token', 'http biz id']) unless @udi_auth_token && @http_biz_id
       @connection = RubyOmx::Connection.connect(options)
     end
-      
-    def connection
-      raise RubyOmx::NoConnectionEstablished.new if !connected?
-      @connection
-    end
 
-    #def connected?
-    #  !@connection.nil?
-    #end
 
-    #def disconnect
-    #  @connection.http.finish if @connection.persistent?
-    #  @connection = nil
-    #end
-      
     # Wraps the current connection's request method and picks the appropriate response class to wrap the response in.
     # If the response is an error, it will raise that error as an exception. All such exceptions can be caught by rescuing
     # their superclass, the ResponseError exception class.
@@ -38,7 +22,7 @@ module RubyOmx
     def request(verb, body = nil, attempts = 0, &block)
         # Find the connection method in connection/management.rb which is evaled into Amazon::MWS::Base
       response = @connection.request(verb, body, attempts, &block)
-        
+
         # Each calling class is responsible for formatting the result
       return response
     rescue InternalError, RequestTimeout
@@ -49,7 +33,7 @@ module RubyOmx
         retry
       end
     end
-      
+
     # Make some convenience methods
     [:get, :post, :put, :delete, :head].each do |verb|
       class_eval(<<-EVAL, __FILE__, __LINE__)
@@ -58,5 +42,6 @@ module RubyOmx
         end
       EVAL
     end
+ 
   end
 end

data/lib/ruby_omx/connection.rb

@@ -2,9 +2,7 @@ module RubyOmx
      
   class Connection
 
-    def self.connect(options = {})
-      new(options)
-    end
+    def self.connect(options = {}); new(options) end
       
     def initialize(params = {})
       
@@ -26,7 +24,7 @@ module RubyOmx
       http.verify_mode 	= OpenSSL::SSL::VERIFY_NONE
       return http
     end
-      
+
     # Make the request, based on the appropriate request object
     # Called from RubyOmx::Base
     def request(verb, body = nil, attempts = 0, &block)
@@ -40,7 +38,7 @@ module RubyOmx
       @http = connect
       attempts == 3 ? raise : (attempts += 1; retry)
     end
-     
+
   end
 end
 

data/lib/ruby_omx/exceptions.rb

@@ -7,52 +7,14 @@ module RubyOmx
   # Abstract super class for all invalid options.
   class InvalidOption < RubyOmxException
   end
-    
-  #class InvalidMessageType < RubyOmxException
-  #end
-    
-  #class InvalidReportType < RubyOmxException
-  #end
-    
-  #class InvalidSchedule < RubyOmxException
-  #end
-    
-  class MissingConnectionOptions < RubyOmxException
-  end
   
-  class MissingOrderOptions < RubyOmxException
+  class MissingRequestOptions < RubyOmxException
   end
-
-  class MissingPurchaseOrderOptions < RubyOmxException
-  end
-  
   
-  class MissingItemOptions < RubyOmxException
-  end
-    
-  # All responses with a code between 300 and 599 that contain an <Error></Error> body are wrapped in an
-  # ErrorResponse which contains an Error object. This Error class generates a custom exception with the name
-  # of the xml Error and its message. All such runtime generated exception classes descend from ResponseError
-  # and contain the ErrorResponse object so that all code that makes a request can rescue ResponseError and get
-  # access to the ErrorResponse.
-  # class ResponseError < RubyOmxException
-  #   def initialize(formatted_response)
-  #     instance_eval(<<-EVAL, __FILE__, __LINE__)
-  #       def request_id
-  #         '#{formatted_response["RequestID"]}'
-  #       end
-  #     EVAL
-  #     
-  #     formatted_response["Error"].each do |key, value|
-  #       instance_eval(<<-EVAL, __FILE__, __LINE__)
-  #         def #{key.underscore}
-  #           '#{value}'
-  #         end
-  #       EVAL
-  #     end
-  #   end
-  # end
     
+  class MissingConnectionOptions < RubyOmxException
+  end
+        
   class RequestTimeout < ResponseError
   end
     
@@ -62,13 +24,13 @@ module RubyOmx
   end
     
   # Raised if an unrecognized option is passed when establishing a connection.
-  class InvalidConnectionOption < InvalidOption
-    def initialize(invalid_options)
-      message = "The following connection options are invalid: #{invalid_options.join(', ')}. "    +
-                "The valid connection options are: #{Connection::Options::VALID_OPTIONS.join(', ')}."
-      super(message)
-    end
-  end
+  #class InvalidConnectionOption < InvalidOption
+  #  def initialize(invalid_options)
+  #    message = "The following connection options are invalid: #{invalid_options.join(', ')}. "    +
+  #              "The valid connection options are: #{Connection::Options::VALID_OPTIONS.join(', ')}."
+  #    super(message)
+  #  end
+  #end
     
   # Raised if the access key arguments are missing when establishing a connection.
   class MissingAccessKey < InvalidOption
@@ -79,10 +41,10 @@ module RubyOmx
   end
     
   # Raised if a request is attempted before any connections have been established.
-  class NoConnectionEstablished < RubyOmxException
-    def initialize
-      super("\nPlease use RubyOmx::Base.establish_connection! before making API calls.")
-    end
-  end
+  #class NoConnectionEstablished < RubyOmxException
+  #  def initialize
+  #    super("\nPlease use RubyOmx::Base.establish_connection! before making API calls.")
+  #  end
+  #end
         
 end

data/lib/ruby_omx/items.rb

@@ -2,65 +2,41 @@ module RubyOmx
   module Items
 
 		# ItemInformationRequest (ITIR100)	This request type lists the name, default prices, inventory availability, sub-items, cross-sell items, substitution items, and bundle items for a given item code.			
-		def get_item_info(params ={})
-			required_fields = [
-				params[:item_code]
-			]
-			raise MissingItemOptions if required_fields.any? {|option| option.nil?}
-			item_code = params[:item_code]
-			raw_xml = params[:raw_xml] ||= false
-
-			doc = Nokogiri::XML::Document.new
-			root_tag = RubyOmx.add_child_helper(doc,'ItemInformationRequest','version','1.00',nil)
-			udi_parameter = RubyOmx.add_child_helper(root_tag,'UDIParameter',nil,nil,nil)
-			RubyOmx.add_child_helper(udi_parameter,'Parameter','key','HTTPBizID',@http_biz_id)
-			RubyOmx.add_child_helper(udi_parameter,'Parameter','key','ItemCode',item_code)
-			RubyOmx.add_child_helper(udi_parameter,'Parameter','key','OutputSubItemAttributes','True')
-      response = post(doc.to_xml)
-      if raw_xml==true || raw_xml==1
-      	return response
-      else
-      	ItemInformationResponse.format(response)
-      end
-    
-    end
+		def build_item_info_request(attrs={})
+		  ItemInfoRequest.new(attrs.merge({:udi_auth_token=>@udi_auth_token, :http_biz_id=>@http_biz_id}))
+		end
 
-		#CustomItemAttributeInformationRequest (CIAIR200)	This request type lists all the custom item attributes names and values for a given item code or list of item codes, in one or all custom item attribute groups.
-		def get_custom_item_attribute_info(params ={})
-			required_fields = [
-				params[:item_code]
-			]
-			raise MissingItemOptions if required_fields.any? {|option| option.nil?}
-			item_code = params[:item_code]
-			raw_xml = params[:raw_xml] ||= false
+		def send_item_info_request(attrs={})
+		  request = build_item_info_request(attrs)
+      response = post(request.to_xml.to_s)
+      return response if request.raw_xml==true || request.raw_xml==1
+      ItemInfoResponse.format(response)		  
+		end
+		alias_method :get_item_info, :send_item_info_request
 		
-			doc = Nokogiri::XML::Document.new
-			root_tag = RubyOmx.add_child_helper(doc,'CustomItemAttributeInformationRequest','version','2.00',nil)
-			udi_parameter = RubyOmx.add_child_helper(root_tag,'UDIParameter',nil,nil,nil)
-			RubyOmx.add_child_helper(udi_parameter,'Parameter','key','HTTPBizID',@http_biz_id)
-			RubyOmx.add_child_helper(udi_parameter,'Parameter','key','ItemCode',item_code)
-			RubyOmx.add_child_helper(udi_parameter,'Parameter','key','AttributeGroupID','All')
-      response = post(doc.to_xml)
-      if raw_xml==true || raw_xml==1
-      	return response
-      else
-      	CustomItemAttributeInformationResponse.format(response)
-      end
+		def build_custom_item_info_request(attrs={})
+		  CustomItemInfoRequest.new(attrs.merge({:udi_auth_token=>@udi_auth_token, :http_biz_id=>@http_biz_id}))		  
 		end
 		
-		#CustomItemAttributeUpdateRequest (CIAUR100)	This request type is used to set or update the custom item attribute values for a given item code.
-		#ItemCategoryUpdateRequest (ITCATUR100)	This request type is used to set the categories for an item. Categories can be used as the basis for webstore sections, or other classification needs in the application.
-		#ItemCustomizationGroupAssignmentRequest (ICGAR200)	This request type allows for assigning a shared customization group to an item, by name or by ID.
-		#ItemCustomizationGroupUpdateRequest (ICGUR200)	This request type is used to update shared item customization groups in the account.
-		#ItemCustomizationUpdateRequest (ICUR200)	This request type is used to add and update individual item customizations by item, rather than shared customization groups.
-		#ItemListRequest (ILR100)	This command returns a list of items.
-		#ItemLocationUpdateRequest (ILUR100)	This command enables you to update item location information.
-		#ItemLocatorRequest (ITLR100)	This request type lists possible matches for an item given search information.
-		#ItemPriceUpdateRequest (IPUR100)	This request type is used to update item default prices or keycode prices.
-		#ItemUpdateRequest (ITUR200)	This command enables you to create items, or update item information (with selective partial updates).
-		#LocationUpdateRequest (LUR100)	This command enables you to update location information.
-		#SubItemUpdateRequest (SITUR100)	This request type is used to update parent/sub-item associations, or to create new sub-items for a given parent item.
-		#SupplierItemUpdateRequest (SUPITUR100)	This request type is used to create or update a supplier-item association.
-    
+		def send_custom_item_info_request(attrs={})
+		  request = build_custom_item_info_request(attrs)
+      response = post(request.to_xml.to_s)
+      return response if request.raw_xml==true || request.raw_xml==1
+      CustomItemInfoResponse.format(response)
+		end
+		alias_method :get_custom_item_info, :send_custom_item_info_request
+  
+    def build_item_update_request(attrs={})
+      ItemUpdateRequest.new(attrs.merge({:udi_auth_token=>@udi_auth_token, :http_biz_id=>@http_biz_id}))
+    end
+
+    def send_item_update_request(attrs={})
+		  request = build_item_update_request(attrs)
+      response = post(request.to_xml.to_s)
+      return response if request.raw_xml==true || request.raw_xml==1
+      ItemUpdateResponse.format(response)		  
+		end
+		alias_method :append_item, :send_item_update_request
+
   end
 end

data/lib/ruby_omx/memos.rb

@@ -1,12 +1,12 @@
 module RubyOmx
   module Memos
     
-    def build_memo_submission_request(params={})
-		  MemoSubmissionRequest.new(params.merge({:udi_auth_token=>@udi_auth_token, :http_biz_id=>@http_biz_id}))
+    def build_memo_submission_request(attrs={})
+		  MemoSubmissionRequest.new(attrs.merge({:udi_auth_token=>@udi_auth_token, :http_biz_id=>@http_biz_id}))
 		end
 		
-		def send_memo_submission_request(params={})
-		  request = build_memo_submission_request(params)
+		def send_memo_submission_request(attrs={})
+		  request = build_memo_submission_request(attrs)
       response = post(request.to_xml.to_s)
       return response if request.raw_xml==true || request.raw_xml==1
       MemoSubmissionResponse.format(response)		  

data/lib/ruby_omx/node.rb

@@ -0,0 +1,30 @@
+module RubyOmx
+   
+  # Base class for request and response classes, which implement XML mapping via ROXML
+  class Node
+    include ROXML
+    xml_convention :camelcase
+    
+    def initialize(attrs={})
+      attrs.map { |(k, v)| send("#{k}=", v) } if attrs.present?
+    end
+
+    def accessors
+      roxml_references.map {|r| r.accessor}
+    end
+
+    # render a ROXML node as a normal hash, eliminating the @ and some unneeded admin fields
+  	def as_hash
+  		obj_hash = {}
+  		self.instance_variables.each do |v|
+  			m = v.to_s.sub('@','')
+  			if m != 'roxml_references' && m!= 'promotion_ids'
+  				obj_hash[m.to_sym] = self.instance_variable_get(v)
+  			end
+  		end
+  		return obj_hash
+  	end
+
+  end
+
+end

data/lib/ruby_omx/orders.rb

@@ -3,37 +3,37 @@ module RubyOmx
     
     # Universal Direct Order Appending (UDOA)
     
-    def build_udoa_request(params={})
-		  UDOARequest.new(params.merge({:http_biz_id=>@http_biz_id, :udi_auth_token=>@udi_auth_token}))
+    def build_udoa_request(attrs={})
+		  UDOARequest.new(attrs.merge({:http_biz_id=>@http_biz_id, :udi_auth_token=>@udi_auth_token}))
 		end
 		
-		def send_udoa_request(params={})
-		  request = build_udoa_request(params)
+		def send_udoa_request(attrs={})
+		  request = build_udoa_request(attrs)
       response = post(request.to_xml.to_s)
       return response if request.raw_xml==true || request.raw_xml==1
-      UDOAResponse.format(response)		  
+      UDOAResponse.format(response)
 		end
 		alias_method :append_order, :send_udoa_request
 		
 
 		# Order Information
 		
-		def build_info_request(params={})
-	    OrderInformationRequest.new(params.merge({:http_biz_id=>@http_biz_id, :udi_auth_token=>@udi_auth_token}))
+		def build_info_request(attrs={})
+	    OrderInfoRequest.new(attrs.merge({:http_biz_id=>@http_biz_id, :udi_auth_token=>@udi_auth_token}))
 		end
 
-    def send_info_request(params={})
-		  request = build_info_request(params)
+    def send_info_request(attrs={})
+	    @connection = RubyOmx::Connection.connect({ "http_biz_id" => @http_biz_id, "udi_auth_token" => @udi_auth_token, "server"=>ALT_HOST })
+		  request = build_info_request(attrs)
       response = post(request.to_xml.to_s)
       return response if request.raw_xml==true || request.raw_xml==1
-      OrderInformationResponse.format(response)
+      OrderInfoResponse.format(response)
     end
 
 
     # Smart Report Information
-
-    def send_smart_report_request(params={})
-      schedule_id = params[:schedule_id] ||= 1
+    def send_smart_report_request(attrs={})
+      schedule_id = attrs[:schedule_id] ||= 1
       response = get("https://omx.ordermotion.com/en/net/SmartReports.aspx?HTTPBizID=#{@http_biz_id}&ScheduleID=#{schedule_id}")
       SmartReportResponse.format(response)
     end

data/lib/ruby_omx/purchase_orders.rb

@@ -1,12 +1,13 @@
 module RubyOmx
   module PurchaseOrders
     
-    def build_purchase_order_update_request(params={})
-		  PurchaseOrderUpdateRequest.new(params.merge({:udi_auth_token=>@udi_auth_token, :http_biz_id=>@http_biz_id}))
+    def build_purchase_order_update_request(attrs={})
+		  PurchaseOrderUpdateRequest.new(attrs.merge({:udi_auth_token=>@udi_auth_token, :http_biz_id=>@http_biz_id}))
 		end
 		
-		def send_purchase_order_update_request(params={})
-		  request = build_purchase_order_update_request(params)
+		def send_purchase_order_update_request(attrs={})
+		  @connection = RubyOmx::Connection.connect({ "http_biz_id" => @http_biz_id, "udi_auth_token" => @udi_auth_token, "server"=>ALT_HOST })
+		  request = build_purchase_order_update_request(attrs)
       response = post(request.to_xml.to_s)
       return response if request.raw_xml==true || request.raw_xml==1
       PurchaseOrderUpdateResponse.format(response)		  

data/lib/ruby_omx/request/custom_item_info_request.rb

@@ -0,0 +1,17 @@
+module RubyOmx
+
+  class CustomItemInfoRequest < Request
+
+    def initialize(attrs={})
+      return super unless attrs.any?
+  	  raise MissingRequestOptions if attrs[:item_code].nil?
+      super
+      self.version = attrs[:version] ||= '2.00'
+      self.udi_parameters << UDIParameter.new({:key=>'ItemCode', :value=>attrs[:item_code]})
+      self.udi_parameters << UDIParameter.new({:key=>'AttributeGroupID', :value=>(attrs[:attribute_group_id]||='All')})
+      
+    end
+    attr_accessor :item_code, :attribute_group_id
+    xml_name "CustomItemAttributeInformationRequest"
+  end
+end

data/lib/ruby_omx/request/item_info_request.rb

@@ -0,0 +1,16 @@
+module RubyOmx
+
+  class ItemInfoRequest < Request
+
+    def initialize(attrs={})
+      return super unless attrs.any?
+  	  raise MissingRequestOptions if attrs[:item_code].nil?
+      super
+      self.version = attrs[:version] ||= '1.00'
+      self.udi_parameters << UDIParameter.new({:key=>'ItemCode', :value=>attrs[:item_code]})      
+    end
+    
+    attr_accessor :item_code
+    xml_name "ItemInformationRequest"
+  end
+end

data/lib/ruby_omx/request/item_update_request.rb

@@ -0,0 +1,37 @@
+module RubyOmx
+
+  class ItemUpdateItem < Node
+    xml_accessor :item_code #<ItemCode>APPLE</ItemCode>
+    xml_accessor :product_status #<ProductStatus>True</ProductStatus>
+    xml_accessor :incomplete_flag #<IncompleteFlag>True</IncompleteFlag>
+		xml_accessor :product_name #<ProductName>Deluxe Princess Fiona™ Child</ProductName>
+		xml_accessor :product_group, :as=>Integer #<ProductGroup>45</ProductGroup>
+		xml_accessor :cost_of_goods, :as=>Float #<CostOfGoods>10</CostOfGoods>
+		xml_accessor :upc_code, :from=>'UPCCode'	#<UPCCode></UPCCode>
+		xml_accessor :accounting_reference #<AccountingReference></AccountingReference>
+		xml_accessor :allow_order_line_info #<AllowOrderLineInfo>True</AllowOrderLineInfo>
+		xml_accessor :launch_date #<LaunchDate>2/23/2006</LaunchDate>
+		xml_accessor :file_sub_code, :as=>Integer #<FileSubCode>20</FileSubCode>
+		xml_accessor :inventory_product_flag #<InventoryProductFlag>True</InventoryProductFlag>
+		xml_accessor :tax_code #<TaxCode>TC4</TaxCode>
+		xml_accessor :inventory_type, :as=>Integer # <InventoryType>3</InventoryType>    
+    xml_accessor :drop_ship_file_sub_code, :as=>Integer #<DropShipFileSubCode>31</DropShipFileSubCode>
+		
+  end
+
+  class ItemUpdateRequest < Request
+
+    def initialize(attrs={})
+      return super unless attrs.any?
+      required_fields = [:items] #:item_code, :product_status, :product_name, :product_group, :tax_code, :file_sub_code, :inventory_product_flag, :launch_date
+  		raise MissingRequestOptions if required_fields.any? { |option| attrs[option].nil? }  		
+      super
+      self.version = attrs[:version] ||= '2.00'
+      self.items = attrs[:items].collect { |h| ItemUpdateItem.new(h) }
+    end
+    
+    xml_name "ItemUpdateRequest"
+    xml_accessor :items, :as=>[ItemUpdateItem], :in=>'Items'
+  end
+
+end

data/lib/ruby_omx/request/memo_submission_request.rb

@@ -0,0 +1,21 @@
+module RubyOmx
+
+  class MemoSubmissionRequest < Request
+    def initialize(a={})
+      super
+      self.version = a[:version] ||= '1.00'
+    end
+    
+    attr_accessor :order_number, :order_id, :store_code
+    
+    xml_name "MemoSubmissionRequest"
+    xml_accessor :lead_number, :in=>'Memo'
+    xml_accessor :customer_number, :in=>'Memo'
+    xml_accessor :order_number, :in=>'Memo'
+    xml_accessor :shipment_number, :in=>'Memo'
+    xml_accessor :reminder_date, :in=>'Memo', :as=>DateTime # Dates are almost the same as the W3C Schema "date" type, but with a space instead of the "T" separating the date from the time.
+    xml_accessor :memo_type, :in=>'Memo', :as=>Integer
+    xml_accessor :memo_text, :in=>'Memo'
+    xml_accessor :memo_transmission_date, :in=>'Memo', :as=>DateTime
+  end
+end

data/lib/ruby_omx/request/order_info_request.rb

@@ -0,0 +1,22 @@
+module RubyOmx
+
+  class OrderInfoRequest < Request
+
+    def initialize(attrs={})
+      return super unless attrs.any?
+      
+      # Require either an order number or a store code and an order id to locate the order
+      raise MissingRequestOptions if attrs[:order_number].nil? && (attrs[:store_code].nil? || attrs[:order_id].nil?)
+      super
+      self.version = attrs[:version] ||= '1.00'
+      self.udi_parameters << RubyOmx::UDIParameter.new({:key=>'OrderNumber', :value=>attrs[:order_number]}) if attrs[:order_number]
+      self.udi_parameters << RubyOmx::UDIParameter.new({:key=>'OrderID', :value=>attrs[:order_id]}) if attrs[:order_id]
+      self.udi_parameters << RubyOmx::UDIParameter.new({:key=>'StoreCode', :value=>attrs[:store_code]}) if attrs[:store_code]
+      self.udi_parameters << RubyOmx::UDIParameter.new({:key=>'level', :value=>attrs[:level] ||=2 })
+    end
+    
+    attr_accessor :order_number, :order_id, :store_code
+    
+    xml_name "OrderInformationRequest"
+  end
+end

data/lib/ruby_omx/request/purchase_order_update_request.rb

@@ -0,0 +1,21 @@
+module RubyOmx
+
+  class PurchaseOrderUpdateRequest < Request
+
+    def initialize(attrs={})
+      return super unless attrs.any?
+      raise MissingRequestOptions if attrs[:po_number].nil? && attrs[:supplier_id].nil?
+      super
+      self.version = attrs[:version] ||= '1.00'
+
+      # Instantiate LineItem variables for each
+      self.line_items = attrs[:line_items].collect { |h| LineItem.new(h) }
+    end
+    
+    xml_name "PurchaseOrderUpdateRequest"
+    xml_accessor :po_number, :from=>'@PONumber', :in=>'PurchaseOrder' #<PurchaseOrder PONumber="16651" supplierID="76">
+    xml_accessor :supplier_id, :from=>'@supplierID', :in=>'PurchaseOrder'
+    xml_accessor :cross_reference #<CrossReference>PO 12345</CrossReference>
+    xml_accessor :line_items, :as => [RubyOmx::LineItem], :in => 'PurchaseOrder/LineDetail'
+  end
+end

data/lib/ruby_omx/request/udoa_request.rb

@@ -0,0 +1,84 @@
+module RubyOmx
+    
+  class Address < Node
+    xml_name "Address"
+    xml_accessor :address_type, :from => '@type'
+    xml_accessor :title_code, :company, :firstname, :lastname, :address1, :address2, :city, :state, :phone_number, :email
+    xml_accessor :zip, :from => 'ZIP'
+    xml_accessor :tld, :from => 'TLD'
+  end
+    
+  class CustomField < Node
+    xml_name 'Field'
+    xml_accessor :field_id, :from => '@fieldID'
+    xml_accessor :line_number, :from => '@lineNumber'
+    xml_accessor :value, :from => :content
+  end
+    
+  class Flag < Node
+    xml_name 'Flag'
+    xml_accessor :name, :from => '@name'
+    xml_accessor :value, :from => :content      
+  end
+
+  class UDOARequest < Request
+    def initialize(attrs={})
+      return super unless attrs.any?
+
+  		required_fields = [:queue_flag, :verify_flag, :keycode, :order_date, :order_id, :bill_to, :line_items, :method_code]
+  		raise MissingRequestOptions if required_fields.any? { |option| attrs[option].nil? }
+      super
+      self.version = attrs[:version] ||= '2.00'
+      self.payment_type = attrs[:payment_type] ||= '6'  #6 for open invoice
+      self.origin_type = attrs[:origin_type] ||= '2'    # 2 = phone order, 3 = internet order      
+      self.udi_parameters << UDIParameter.new({:key=>'Keycode', :value=>attrs[:keycode]})
+      self.udi_parameters << UDIParameter.new({:key=>'VerifyFlag', :value=>attrs[:verify_flag] ||= 'True' }) # Determines whether a successful order should be saved, or only verified/calculated. When set to "True", OrderMotion will behave as if the order was placed, but not return an Order Number in the response.
+      self.udi_parameters << UDIParameter.new({:key=>'QueueFlag', :value=>attrs[:queue_flag] ||= 'False' })  # Determines whether any orders with errors will be stored in the OrderMotion "Outside Order Queue",  to be corrected by an OrderMotion user before resubmission. If set to "True", almost all orders will be   accepted by OrderMotion, but additional order information will only be returned in the response if the order   is successfully placed. Otherwise, any order with any error (eg invalid ZIP code) will be rejected.
+      self.udi_parameters << UDIParameter.new({:key=>'Vendor', :value=>attrs[:vendor] }) if attrs[:vendor].present? 
+      self.bill_to = Address.new(attrs[:bill_to])
+      self.ship_to = Address.new(attrs[:ship_to])
+      
+      # Instantiate LineItem variables for each
+      i = 0
+      self.line_items = attrs[:line_items].collect { |h|
+        i+=1
+        h[:line_number] = h[:line_number] ||= i  # Provide line numbers if they are omitted
+        LineItem.new(h)
+      }
+        
+      self.custom_fields = attrs[:custom_fields].collect { |h| CustomField.new(h) } if attrs[:custom_fields].present?
+      self.flags = attrs[:flags].collect { |h| Flag.new(h) } if attrs[:flags].present?
+    end
+      
+    attr_accessor :keycode, :queue_flag, :verify_flag, :vendor
+      
+    xml_name "UDOARequest"
+    xml_accessor :order_date, :in => 'Header', :as => DateTime  # Dates are almost the same as the W3C Schema "date" type, but with a space instead of the "T" separating the date from the time.
+    xml_accessor :order_id, :in => 'Header', :from => 'OrderID'
+    xml_accessor :origin_type, :in => 'Header'
+    xml_accessor :store_code, :in => 'Header'
+    xml_accessor :bill_to, :as => Address, :in => 'Customer'
+    xml_accessor :flags, :as => [Flag], :in => 'Customer/FlagData'
+    xml_accessor :ship_to, :as => Address, :in => 'ShippingInformation'
+
+    xml_accessor :method_code, :in => 'ShippingInformation', :as => Integer
+    xml_accessor :shipping_amount, :in => 'ShippingInformation', :as => Float
+    xml_accessor :handling_amount, :in => 'ShippingInformation', :as => Float
+    xml_accessor :special_instructions, :in => 'ShippingInformation'
+    xml_accessor :gift_wrapping, :in => 'ShippingInformation'
+    xml_accessor :gift_message, :in => 'ShippingInformation'            
+
+    xml_accessor :payment_type, :in => 'Payment', :from => '@type'
+  	xml_accessor :card_number, :in => 'Payment'
+  	xml_accessor :card_verification, :in => 'Payment'
+  	xml_accessor :card_exp_date_month, :in => 'Payment'
+  	xml_accessor :card_exp_date_year, :in => 'Payment'
+    xml_accessor :card_status, :in => 'Payment'
+  	xml_accessor :card_auth_code, :in => 'Payment' 	    	
+  	xml_accessor :card_transaction_id, :from => 'CardTransactionID', :in => 'Payment'
+
+    xml_accessor :line_items, :as => [LineItem], :in => 'OrderDetail'
+    xml_accessor :custom_fields, :as => [CustomField], :in => 'CustomFields/Report'
+    xml_accessor :total_amount, :in => 'Check'  
+  end
+end

data/lib/ruby_omx/request.rb

@@ -0,0 +1,24 @@
+module RubyOmx
+   
+  # UDI Parameters are included in every OMX request
+  class UDIParameter < Node
+    xml_name "Parameter"
+    xml_accessor :key, :from => '@key'
+    xml_accessor :value, :from => :content
+  end
+
+  class Request < Response
+    
+    def initialize(attrs=nil)
+      self.udi_parameters = [UDIParameter.new({:key=>'UDIAuthToken', :value=>attrs.delete(:udi_auth_token)})]
+      self.udi_parameters << UDIParameter.new({:key=>'HTTPBizID', :value=>attrs.delete(:http_biz_id)})
+      super
+			raw_xml = attrs[:raw_xml] ||= false
+   end
+   
+   attr_accessor :raw_xml
+   xml_accessor :udi_parameters, :as => [UDIParameter], :in => 'UDIParameter'
+   xml_accessor :version, :from => '@version'
+  end
+
+end