ruby2soap 0.0.1

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    ODAzMDk5Nzc5NmQ0NDk4YzhhYWFjYjMxY2VjNDc3MTk0NGY2ODgzOQ==
+  data.tar.gz: !binary |-
+    MzRlMDcwYWI3YzdiNDQwMmE0ZDA2Yzg3MTFjZjUxNzQ2MDMyZjAxYw==
+SHA512:
+  metadata.gz: !binary |-
+    YzM5YmU1NWRmYmRjMGRlNzlkODA3ZjRhODVmOGIyOGUxZWMyNzVhYzc0ZDI2
+    Yjg4NmM4OTFhYThlOTBmZmI1ZmQ1ZjUxMGJlZGQ4NzM5MzRiZmJmZWVkYjJi
+    N2VmMDNiNDM5NGI1NmRhMzBmZDBmZGE1Y2NiYTAwYzEwNzc5NjY=
+  data.tar.gz: !binary |-
+    NjBiMmYxYmJhNzIzZDgxNDNmYzBmNDIzOTI3OGE3MDIwOTQyMjI1ZmU5OTRm
+    Y2I4MmZjZDgxYzhjN2I3ZTQ5YThiM2M2NDdkNzhkMmNmYTQ1NWZjZDFlNzhj
+    MjgwMGRiZTg5Y2RiYmVkMGIzMjM1ODRhMDk4NjI3NmM4YjYwZTM=

data/lib/ruby2soap.rb

@@ -0,0 +1,100 @@
+require 'net/http'
+require 'xmlsimple'
+require_relative 'wsdl\wsdl'
+include Wsdl
+#require 'soap/soap'
+#include Soap
+#include WebRequestHandler
+#require_relative 'wsdl.rb'
+#require_relative 'wsdl_parser.rb'
+#require_relative 'soap.rb'
+#include WsdlParser
+#include Soap
+
+#Dir["lib/*.rb"].each {|file| 
+#	require file
+#	#require_relative file# if file != 'wcf_handler'
+#	#include file.gsub('.rb','')
+#}
+
+# Handle the requests to the service
+class Ruby2Soap
+	# C'tor.
+	# Parse the wsdl and create a method to each WCF/WebService method
+	# Params:
+	# +service_url+:: the url of your service
+	# +save_cookeis+:: should save cookies of the result
+	def initialize(service_url,save_cookeis = true)
+		HTTPI.log = false
+		@cookies = []
+		@save_cookeis = save_cookeis
+
+		@uri = URI("#{service_url}")
+
+		wsdl = WsdlParser.parse(service_url)
+		@service_address = wsdl.location_address
+
+		wsdl.actions.each do |action|
+			define_wcf_action(action)
+		end
+
+		# maybe create class for each service and the function will be there
+	end
+
+	# Return the the current cookie set
+	def cookies
+		@cookies
+	end
+
+	private
+		# Define a method to the +Ruby2Soap+ object base on the method from the WSDL
+		# Params:
+		# +action+:: +SoapAction+ that have all the info about the method from the WSDL
+		def define_wcf_action(action)
+		 	self.class.send(:define_method ,action.name) do |data=nil,*args|
+				body = build_body(action, data)
+
+				res = send_wcf_action(action.soap_action,body,*args)
+				(@cookies << res.headers["Set-Cookie"]) if @save_cookeis
+				
+				result = get_wcf_response(res,action.name)
+				res.singleton_class.send(:define_method,:result) do
+					result
+				end
+
+				#if(res.code == '401') # not autorized
+				#	(raise "Please use ntlm") if res['WWW-Authenticate'].include?('NTLM')
+				#end
+
+				res
+			end
+
+			#create new method that takes the data and user and password and user ntlm
+		end
+
+		# Call to wcf method
+		# Params:
+		# +soap_action+:: the value of the SOAPAction header
+		# +body+:: the body of the HTTP request
+		# +args+:: metadata that indicate wich autountication to use
+		def send_wcf_action(soap_action,body,*args)
+			#req = Net::HTTP::Post.new(@uri.path)
+			#req = Net::HTTP::Post.new(@service_address)
+
+			#req["SOAPAction"] = soap_action
+			#req["Content-Type"] = "text/xml; charset=utf-8"
+			#req["Cookie"] = @cookies.join(',') unless @cookies.empty?
+			#req.body = body
+
+			yield(req) if block_given?
+
+			#get_web_response(req,@uri,*args)
+			# "Cookie" => (@cookies.join(',') unless @cookies.empty?)
+			cookies = @cookies.empty? ? "" : @cookies.join(',')
+			send_message_to_wcf(@service_address,
+							 {"SOAPAction" => soap_action,
+							  "Content-Type" => "text/xml; charset=utf-8",
+							  "Cookie" => cookies},
+							  body, *args)
+		end 
+end

data/lib/soap/soap.rb

@@ -0,0 +1,88 @@
+require_relative './soap_action'
+require_relative './soap_parameter'
+require 'xmlsimple'
+
+module Soap
+	# Covert the data to hash
+	# Params:
+	# +object+:: the object to covert to hash
+	def data_to_arr(object)
+		return '' if object.nil?
+		return [object] unless object.is_a? Hash
+
+		params = {}
+		object.each do |key,value|
+			params["#{@name_space}:#{key}"] = data_to_arr(value)
+		end
+
+		params
+	end
+
+	# Build the body that need to be send to the service when calling the soap action and return the result
+	# Params :
+	# +action+:: +SoapAction+ object that keep all the data about the soap action
+	# +data+:: the user data that he want to send to the server
+	def build_body(action , data)
+		@name_space = 'a'
+		body = {
+			'soap:Envelope' => {
+				'xmlns:soap' => 'http://schemas.xmlsoap.org/soap/envelope/',
+				'xmlns:xsi' => 'http://www.w3.org/2001/XMLSchema-instance',
+				'xmlns:xsd' => 'http://www.w3.org/2001/XMLSchema',
+				'soap:Body' => {
+					"#{action.name}" => {
+						"xmlns" => WsdlParser.target_namespace
+					}
+				}
+			}
+		}
+
+		if(!data.nil?)
+			data.each do |key, value|
+				build_param(body['soap:Envelope']['soap:Body']["#{action.name}"],action,key,value)
+			end
+		end
+
+		XmlSimple.xml_out(body, 'RootName' => nil)
+	end
+
+	# Parse the server response to hash that the user will work eith
+	# Params:
+	# +res+:: +HTTPI::Response+ object that represent the response from the server
+	# +action_name+:: the name of the action that the response is belongs to 
+	def get_wcf_response(res,action_name)
+		#res.error?
+		if res.code.to_i >= 400
+			'error please see body'
+		else
+			result = XmlSimple.xml_in(res.body)['Body'].first["#{action_name}Response"].first["#{action_name}Result"].first
+			if result.class == Hash
+				# I dont want to return the result xml attributes
+				result.select!{|k,v| v.class == Array}
+			end
+
+			result
+		end
+	end
+
+	# Adds to the action element in the +Hash+ and add the user send data to the hash
+	# Params:
+	# +action_element+:: the action element in the hash of the body
+	# +action+:: +SoapAction+ object that keep all the data about the soap action
+	# +key+:: the name of the parameter
+	# +value+:: the value of the parameter
+	def build_param(action_element,action,key,value)
+		if(action.parameters.nil?)
+			action_element["#{key}"] = ((value.is_a? Hash) ? data_to_arr(value) : [value])
+		else		
+			current_param = action.parameters.select{|p| p.name.upcase == key.to_s.upcase}.first
+			action_element["#{key}"] = ((value.is_a? Hash) ? data_to_arr(value) : [value])
+	
+			if !current_param.namespace.nil?
+				action_element["#{key}"].merge!("xmlns:#{@name_space}" => current_param.namespace)
+			end
+		end
+	end
+end
+
+

data/lib/soap/soap_action.rb

@@ -0,0 +1,9 @@
+module Soap
+	class SoapAction
+		attr_accessor :name, :soap_action, :parameters
+
+		def self.parse()
+			#TODO:parse from xml to SoapParamter object
+		end
+	end
+end

data/lib/soap/soap_parameter.rb

@@ -0,0 +1,17 @@
+module Soap
+	class SoapParamter
+		attr_accessor :name, :nullable, :type, :namespace
+
+		# Gets the xml element of the paramter and parse it to a +SoapParamter+ object
+		# Params:
+		# +param_element+:: +Hash+ that represent the xml element of the paramter
+		def self.parse(param_element)
+			param = SoapParamter.new
+			param.name = param_element['name']
+			param.type = param_element['type'].split(':').last
+			yield param if block_given?
+
+			param
+		end
+	end
+end

data/lib/web/secutry_protocols.rb

@@ -0,0 +1,10 @@
+module Web
+	# the secutry protocols that have support 
+	module SecutryProtocol
+		NTLM = 0
+		GGS_API = 1
+		KERBEROS = 1
+		BASIC = 2
+		DIGEST = 3
+	end
+end

data/lib/web/web_request_handler.rb

@@ -0,0 +1,88 @@
+require 'httpi'
+require_relative './secutry_protocols'
+
+# Handle all the communication to the service
+module Web
+	# Send Http get rquest to a url and return his result via +HTTPI+
+	# Params:
+	# +url+:: the url to send the request to
+	# +headers+:: hash that keeps the headers that need to be send to the service
+	def get_web_response(url,headers)
+		request = HTTPI::Request.new(url)
+
+		request.headers = headers
+		response = HTTPI.get(request)
+
+		response
+	end
+
+	# Send http request to the service
+	# Params:
+	# +url+:: the url to send the request to
+	# +headers+:: hash that keeps the headers that need to be send to the service
+	# +body+:: the body of the HTTP request
+	# +args+:: metadata that indicate wich autountication to use
+	def send_message_to_wcf(url,headers,body,*args)
+		request = HTTPI::Request.new(url)
+		request.headers = headers
+		request.body = body
+
+		#TODO: change to user self.send('use_'+)
+		case args.first
+			when SecutryProtocol::NTLM
+				use_ntlm(request,*args)
+			when SecutryProtocol::GGS_API
+				use_kerberos(request)
+			when SecutryProtocol::BASIC
+				use_basic(request,*args)
+			when SecutryProtocol::DIGEST
+				use_digest(request,*args)
+		end
+
+		response = HTTPI.post(request)
+		response
+	end
+
+	private
+		# Use ntlm auth in the request
+		# Params:
+		# +request+:: +HTTPI::Request+ request
+		# +args+:: keep the data that need to be uses for the NTLM auth
+		def use_ntlm(request,*args)
+			# the first is the security name
+			user = args[1]
+			password = args[2]
+			domain = args[3]
+
+			request.auth.ntlm(user,password,domain)# if request.auth.ntlm?
+		end
+
+		# Use kerberos auth in the request
+		# Params:
+		# +request+:: +HTTPI::Request+ request
+		def use_kerberos(request)
+			request.auth.gssnegotiate
+		end
+
+		# Use basic auth in the request
+		# Params:
+		# +request+:: +HTTPI::Request+ request
+		# +args+:: keep the data that need to be uses for the basic auth
+		def use_basic(request,*args)
+			user = args[1]
+			password = args[2]
+
+			request.auth.basic(user,password)
+		end
+
+		# Use digest auth in the request
+		# Params:
+		# +request+:: +HTTPI::Request+ request
+		# +args+:: keep the data that need to be uses for the digest auth
+		def use_digest(request,*args)
+			user = args[1]
+			password = args[2]
+
+			request.auth.digest(user,password)
+		end
+end

data/lib/wsdl/wsdl.rb

@@ -0,0 +1,7 @@
+require_relative '..\wsdl\wsdl_parser'
+
+module Wsdl
+	class Wsdl
+		attr_accessor :actions, :target_namespace, :location_address
+	end
+end

data/lib/wsdl/wsdl_parser.rb

@@ -0,0 +1,151 @@
+require 'xmlsimple'
+require_relative '..\soap\soap'
+require_relative '..\web\web_request_handler'
+include Soap
+include Web
+
+module Wsdl
+	class WsdlParser
+		# Parse the service wsdl to a +Wsdl+ object
+		# Params :
+		# +service+:: the url of the service
+		def self.parse(service)
+			@service = service
+			wsdl_xml = get_serivce_data('wsdl')
+			doc = XmlSimple.xml_in(wsdl_xml)
+
+			res = Wsdl.new
+			res.actions = get_soap_actions(doc)
+			res.location_address = get_location_address(doc)
+			res.target_namespace = doc['targetNamespace']
+
+			res
+		end
+
+		# Return the target namespace of the last wsdl parser.
+		# TODO: Remove this method and user tel +Wsdl+ it self to get the target namespace
+		def self.target_namespace
+			@@target_namespace
+		end
+
+		private
+			# Return the service data for specified extension (wsdl, xsd=xsd0, etc)
+			# Params:
+			# +extension+:: the extension the query the service with (wsdl, xsd=xsd0, etc)
+			def self.get_serivce_data(extension)
+				uri = URI("#{@service}")
+
+				res = get_web_response("#{@service}?#{extension}",
+										{"Accept" => 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+										 "Accept-Encoding" => 'gzip,deflate,sdch'})
+				res.body
+			end
+
+			# ???
+			def self.get_action_datacontact(action_name)
+				if @xsd_namespace.nil?
+					xsd0 = get_serivce_data('xsd=xsd0')
+					doc = XmlSimple.xml_in(xsd0)
+
+					import = doc['import']
+					@xsd_namespace = (import.first['namespace'] unless import.nil?)
+				end
+
+				@xsd_namespace
+			end
+
+			# Return list of +SoapAction+ 
+			# Params:
+			# +doc+:: +Hash+ that represent the wsdl xml
+			def self.get_soap_actions(doc)
+				result = []
+
+				@@target_namespace = doc['targetNamespace']
+				should_read_from_xsd = !doc['types'].first['schema'].first['import'].nil?
+
+				binding = doc['binding'].first
+				binding['operation'].each do |opp|
+					action = SoapAction.new
+
+					action.name = opp['name']
+					action.soap_action = opp['operation'].first['soapAction']
+					action.parameters = get_action_params(action.name, doc, should_read_from_xsd)
+
+					result << action
+				end
+
+				result
+			end
+
+			# Return the location address of the service
+			# Params:
+			# +doc+:: +Hash+ that represent the wsdl xml
+			def self.get_location_address(doc)
+				service = doc['service']
+				location = service.first['port'].first['address'].first['location']
+
+				location
+			end
+
+			# Return the parameters that the soap actiop requires as list of +SoapParamter+ objects
+			# Params :
+			# +action_name+:: the name of the soap action 
+			# +doc+:: hash the represent the WSDL
+			# +should_read_from_xsd+:: boolean that indicates whether it should read the parameters from the wsdl or imported xsd
+			def self.get_action_params(action_name,doc,should_read_from_xsd)
+				if(should_read_from_xsd)
+					get_action_params_from_xsd(action_name)
+				else
+					get_action_params_from_wsdl(action_name,doc)
+				end
+			end
+
+			# Parse the soap action element in the wsdl and return the parameters that the soap actiop requires as list of +SoapParamter+ objects 
+			# Params:
+			# +action_name+:: the name of the soap action
+			# +doc+:: hash the represent the WSDL
+			def self.get_action_params_from_wsdl(action_name, doc)
+				#puts opp['input'].first
+				if @schema.nil?
+					@schema =  doc['types'].first['schema'].first
+				end
+
+				action_element = @schema['element'].select{|e| e['name'] == action_name}.first
+				action_params_elements = action_element['complexType'].first['sequence'].first['element']
+
+				action_params_elements.map do |element|
+					SoapParamter.parse(element) do |param|
+						param.nullable = ['minOccurs'] == 0
+					end
+				end
+			end
+
+			# Parse the imported xsd and return the parameters that the soap actiop requires as list of +SoapParamter+ objects 
+			# Params:
+			# +action_name+:: the name of the soap action
+			def self.get_action_params_from_xsd(action_name)
+				if @elements.nil?
+					#@elements = {}
+					xsd0 = get_serivce_data('xsd=xsd0')
+					doc = XmlSimple.xml_in(xsd0)
+
+					@elements = doc['element']
+
+					# the page dose not have imported shceme
+					return nil if @elements.nil? 
+				end
+
+				element = @elements.select{|e| e['name'] == action_name}.first
+				sequence = element['complexType'].first['sequence'].first
+
+				return [] if sequence['element'].nil?
+				sequence['element'].map do |e|
+					SoapParamter.parse(e) do |param|
+						param.nullable = e['nillable']
+						namespace_element = e.select{|key,value| key.match(/xmlns(.*)/)}.first
+						(param.namespace = namespace_element[1]) unless namespace_element.nil?
+					end
+				end
+			end
+	end
+end

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification
+name: ruby2soap
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Eric Feldman
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-04-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: xml-simple
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: httpi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: enable communication between ruby and soap services
+email: ericfeldman93@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/ruby2soap.rb
+- lib/soap/soap.rb
+- lib/soap/soap_action.rb
+- lib/soap/soap_parameter.rb
+- lib/web/secutry_protocols.rb
+- lib/web/web_request_handler.rb
+- lib/wsdl/wsdl.rb
+- lib/wsdl/wsdl_parser.rb
+homepage: https://github.com/ericman93/ruby2soap
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.1
+signing_key: 
+specification_version: 4
+summary: Communication between ruby and soap services
+test_files: []