afasgem 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c5bf46bef866cc1a2121ae0a52298e6beba6d9dd
+  data.tar.gz: 056bf5b73c04c3c8f03060763e5ea10e21b791b0
+SHA512:
+  metadata.gz: c14c4274605b912888249c0d08b0a8b3c35f60bdce9bfb012e9cfa2c81126807bab61822ee4f155e83bcaf7251bc4c1911528b6f0c664d54c214f4668087e30e
+  data.tar.gz: 72541628f918b44920f72e8613f171ecd1a0e456d83d1f25ff6240364a0980c91e29d341780ad350e1b1ecb4dc24ba92d6bad83aad1e907b56cf2abf92fe9be8

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+/spec/afas_env.rb

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.2.3
+before_install: gem install bundler -v 1.10.6

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in afasgem.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Sprint ICT, Subhi Dweik
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,230 @@
+# Afasgem
+
+This very creatively named get wraps communication with AFAS get and updateconnectors
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'afasgem'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install afasgem
+
+## Usage
+
+### General config
+
+This gem can be configured using the well known ruby configure block
+
+```
+# Start the config block
+Afasgem.configuration do |config|
+ # The WSDL url of the AFAS getconnector
+ # Probable format: https://<Environment number>.afasonlineconnector.nl/ProfitServices/AppConnectorGet.asmx?WSDL
+ config.getconnector_url = 'getconnectorurl'
+
+ # The WSDL url of the AFAS updateconnector
+ # Probable format: https://<Environment number>.afasonlineconnector.nl/ProfitServices/AppConnectorUpdate.asmx?WSDL
+ config.updateconnector_url = 'updateconnectorurl'
+
+ # The WSDL url of the AFAS updateconnector
+ # Probable format: ?
+ config.dataconnector_url = 'dataconnectorurl'
+
+ # The token to use
+ config.token = 'token'
+
+ # The number of rows to fetch when not specified
+ config.default_results = 150
+
+ # Whether to log all requests to the console
+ config.debug = true
+end
+```
+
+To start communicating with AFAS you need to construct a connector using the
+`Afasgem.getconnector_factory` and `Afasgem.updateconnector_factory`. Both take
+the connectorId (the name of the connector, for example `Profit_Debtor`) as an
+argument
+
+This will return a configured get or updateconnector instance that is ready to communicate.
+
+### Getconnector
+
+Create a getconnector using the factory after configuring afasgem
+
+```
+conn = Afasgem.getconnector_factory('Profit_Debtor')
+```
+
+#### Fetching data
+
+The easiest way to get data out of a connector is to simply call `get_data`.
+This will return an array of results, each in a hash. This hash will have the
+AFAS field names as keys.
+
+```
+conn.get_data # [{result 1}, {result 2}]
+```
+
+The data xml is available using `get_data_xml`. This is the xml that contains
+the data itself. Not the full SOAP request
+
+`get_result` will return the full response as a hash. This also is not the full
+SOAP request but just the interesting part of the response
+
+When using `get_result`, `get_data`, or `get_data_xml`, the response
+is cached and new requests will only be done when something was changed using
+the pagination handlers below.
+
+Calling `execute` issues a new request, even if nothing was changed
+
+To get all data at once, the `get_all_results` method is available. This will
+fetch all rows in a connector. Sadly there is no way to tell how many records
+there are in total before fetching them all.
+
+
+
+#### Handling pagination
+
+```
+conn.take(n) # Configures the connector to fetch n records at a time
+conn.skip(n) # Configures the connector to skip the first n records
+conn.page(n) # Provides a simple way to get the nth page of results, 1 indexed
+conn.next # Gets the next page of results
+conn.previous # Gets the previous page of results
+```
+
+All of the above methods provide fluent interfaced, meaning they can be chained.
+
+```
+# Will fetch result 15-25 since we are fetching 10 results a page,
+# skipping the first 5 and then going to page 2
+conn.take(10).skip(5).next.get_data
+```
+
+#### Filtering
+
+This gem also wraps the filter functionality of the AFAS api. When adding a filter it is added with an and respective to the filters already in place. To filter using an OR you have to explicitly call `add_or`
+
+```
+# Filter where Field == 'val'
+conn.add_filter('Field', FilterOperators::EQUAL, 'val')
+
+# Filter where Field == 'val' && Field2 == 'val2'
+conn.add_filter('Field', FilterOperators::EQUAL, 'val')
+ .add_filter('Field2', FilterOperators::EQUAL, 'val2')
+
+# Filter where Field == 'val' || Field2 == 'val2'
+conn.add_filter('Field', FilterOperators::EQUAL, 'val')
+ .add_or
+ .add_filter('Field2', FilterOperators::EQUAL, 'val2')
+
+# Filter where (Field == 'val' && Field2 == 'val2') || (Field3 == 'val3')
+conn.add_filter('Field', FilterOperators::EQUAL, 'val')
+ .add_filter('Field2', FilterOperators::EQUAL, 'val2')
+ .add_or
+ .add_filter('Field3', FilterOperators::EQUAL, 'val3')
+```
+
+To clear the filters in place use `clear_filters`
+
+Available operators:
+```
+	EQUAL                                # Value is exactly equal
+	LARGER_OR_EQUAL                      # Value is larger than or equal
+	SMALLER_OR_EQUAL                     # Value is smaller than or equal
+	LARGER_THAN                          # Value is larger than
+	SMALLER_THAN                         # Value is smaller than
+	LIKE                                 # Text contains value
+	NOT_EQUAL                            # Value is not equal
+	EMPTY                                # Field is null
+	NOT_EMPTY                            # Field is not null
+	STARTS_WITH                          # Text starts with
+	NOT_LIKE                             # Text does not contain
+	NOT_STARTS_WITH                      # Text does not start with
+	ENDS_WITH                            # Text ends with
+	NOT_ENDS_WITH                        # Text does not end with
+```
+
+## Updateconnector data
+
+To view the fields an updateconnector accepts, there is `bin/connector_format`. This script takes a few params and then lists the fields the passed updateconnector would accept
+
+```
+Usage: connector_format [options]
+ -u, --username NAME              AFAS username
+ -p, --password PASSWORD          AFAS password
+ -c, --connector CONNECTOR        Name of the UpdateConnector
+ -e, --environment ENVIRONMENT    Name of the environment
+ -h, --help                       Show this message
+```
+
+## Updateconnector
+
+To Actually write data to the AFAS api you can use the `updateconnector_factory`. This factory will return an `UpdateConnector` object that has the following methods:
+```
+# Create a connector for the FbItemArticle updateconnector
+connector = Afasgem.updateconnector_factory('FbItemArticle')
+connector.insert(hash) # Insert data
+connector.update(hash) # Update existing data
+connector.delete(hash) # Delete existing data
+```
+
+The methods all take a hash that represents the object. Keys in this hash are expected to be fieldnames, while their values are treated like the field's values.
+
+```
+hash = { A: 'b', C: 5 } # => <A>b</A><C>5</C>
+```
+
+The wrapping xml is inferred using the updateconnector name and some constrant data.
+
+Some objects accept nested objects as well as the usual fields. Those should be stored in the Objects key of the passed hash.
+
+```
+# <A>b</A><C>5</C>
+# <Objects>
+# <X>
+#    <Element>
+#             <Fields action='someaction'>
+#                     <D>1</D>
+#                     <E>2</E>
+#             </Fields>
+#    </Element>
+# </X>
+# <Y>
+#    <Element>
+#             <Fields action='someaction'>
+#                     <F>3</F>
+#                     <G>4</G>
+#             </Fields>
+#    </Element>
+# </Y>
+# </Objects>
+# etc...
+hash = { A: 'b', C: 5, Objects: { X: { D: 1, E: 2}, Y: { F: 3, G: 4} } 
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/Bonemind/Afasgem.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/afasgem.gemspec

@@ -0,0 +1,32 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'afasgem/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "afasgem"
+  spec.version       = Afasgem::VERSION
+  spec.authors       = ["Subhi Dweik"]
+  spec.email         = ["subhime@gmail.com"]
+
+  spec.summary       = %q{A gem that wraps basic afas api functionality}
+  spec.homepage      = "https://github.com/Bonemind/Afasgem"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'savon', '>= 2.11.1'
+  spec.add_dependency 'httpclient'
+  spec.add_dependency 'rubyntlm', '~> 0.3.2'
+
+  spec.add_development_dependency "bundler", "~> 1.10"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency 'pry'
+  spec.add_development_dependency 'pry-nav'
+  spec.add_development_dependency 'pry-stack_explorer'
+  spec.add_development_dependency 'pry-doc'
+end

data/bin/connector_format.rb

@@ -0,0 +1,177 @@
+require 'savon'
+require 'pp'
+require 'optparse'
+
+# Parse xml to a hash
+def from_xml(xml_io)
+	begin
+		result = Nokogiri::XML(xml_io)
+		return { result.root.name.to_sym => xml_node_to_hash(result.root)}
+	rescue Exception => e
+		puts e.backtrace
+		raise
+	end
+end
+
+# Parse each node to a hash
+def xml_node_to_hash(node)
+	# If we are at the root of the document, start the hash
+	if node.element?
+		result_hash = {}
+		if node.attributes != {}
+			attributes = {}
+			node.attributes.keys.each do |key|
+				attributes[node.attributes[key].name.to_sym] = node.attributes[key].value
+			end
+		end
+		if node.children.size > 0
+			node.children.each do |child|
+				result = xml_node_to_hash(child)
+
+				if child.name == "text"
+					unless child.next_sibling || child.previous_sibling
+						return result unless attributes
+						result_hash[child.name.to_sym] = result
+					end
+				elsif result_hash[child.name.to_sym]
+
+					if result_hash[child.name.to_sym].is_a?(Object::Array)
+						result_hash[child.name.to_sym] << result
+					else
+						result_hash[child.name.to_sym] = [result_hash[child.name.to_sym]] << result
+					end
+				else
+					result_hash[child.name.to_sym] = result
+				end
+			end
+			if attributes
+				#add code to remove non-data attributes e.g. xml schema, namespace here
+				#if there is a collision then node content supersets attributes
+				result_hash = attributes.merge(result_hash)
+			end
+			return result_hash
+		else
+			return attributes
+		end
+	else
+		return node.content.to_s
+	end
+end
+
+
+# The dataconnector url, will probably not need to change
+dataconnector_url = 'https://profitweb.afasonline.nl/profitservices/DataConnector.asmx?WSDL'
+
+# The username to use
+username = nil
+
+# The password to use
+password = nil
+
+# The connector we want a description of
+connector_name = nil
+
+# The AFAS environment, probably in the format: 'X12345XX'
+environment_id = nil
+
+# Create an optionparser
+OptionParser.new do |opts|
+	# Set username
+	opts.on('-u', '--username NAME', 'AFAS username') { |v| username = v }
+
+	# Set password
+	opts.on('-p', '--password PASSWORD', 'AFAS password') { |v| password = v }
+
+	# Set connector name
+	opts.on('-c', '--connector CONNECTOR', 'Name of the UpdateConnector') { |v| connector_name = v }
+
+	# Set environment
+	opts.on('-e', '--environment ENVIRONMENT', 'Name of the environment') { |v| environment_id = v }
+
+	# Display help
+	opts.on_tail("-h", "--help", "Show this message") do
+		puts opts
+		exit
+	end
+	# Parse
+end.parse!
+
+# All params are required, fail is one is missing
+fail ArgumentError.new('Username is required') unless username
+fail ArgumentError.new('Password is required') unless password
+fail ArgumentError.new('Connector name is required') unless connector_name
+fail ArgumentError.new('Environment name is required') unless environment_id
+
+# Setup Savon with the credentials the user supplied
+client = Savon.client(wsdl: dataconnector_url, basic_auth: [username, password])
+resp = client.call(:execute, {
+	message: {
+		environmentId: environment_id,
+		userId: username,
+		password: password,
+		dataID: 'GetXmlSchema',
+		parametersXml: "<Parameters><UpdateConnectorId>#{connector_name}</UpdateConnectorId></Parameters>"
+	}
+})
+
+# Get response xml out of wrapper
+xml = resp.hash[:envelope][:body][:execute_response][:execute_result]
+
+
+# Get the schema xml out of the response
+schemaxml = from_xml(xml)[:AfasDataConnector][:ConnectorData][:Schema]
+
+# Parse it ignoring namespaces. This because we only need the data and will not construct responses from the data
+schema = Nokogiri::XML(schemaxml).remove_namespaces!
+
+# Xpath to get the fields array of the main object
+main_object_xpath = '//*[@name="Fields" and not(ancestor::*[@name="Objects"])]'
+
+# Xpath to get the nested objects
+nested_objects_xpath = '//*[@name="Objects"]/complexType/sequence/*'
+
+# Xpath to get the fields of the nested objects
+nested_objects_fields_xpath = '*//*[@name="Fields"]/complexType/sequence'
+
+
+# Array of properties of the main object, contains comment and xml element alternating
+main = schema.xpath(main_object_xpath)[0].children.children.children
+nested = schema.xpath(nested_objects_xpath)
+
+# Prints the fields in a field array
+def print_fields(field_array)
+	field_array.each do |el|
+		if el.is_a?(Nokogiri::XML::Comment)
+			puts '-' * 80
+			puts el
+		end
+		if el.is_a?(Nokogiri::XML::Element)
+			puts el.attributes['name'].value
+			puts 'Optional' if el.attributes['nillable']
+		end
+	end
+end
+
+# Output the main connector name
+puts '*' * 8
+puts connector_name
+puts '*' * 80
+
+# Output the fields of the main object
+print_fields(main)
+
+# Iterate over nested objects
+nested.each do |el|
+
+	# PRint the name of the nested object
+	puts '=' * 80
+	puts el.attributes['name'].value
+	puts '=' * 80
+
+	# Get the fields for this object
+	fields = el.xpath(nested_objects_fields_xpath).children
+
+	# Print the fields for this object
+	print_fields(fields)
+end
+

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "afasgem"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/afasgem.rb

@@ -0,0 +1,46 @@
+require "afasgem/version"
+require 'afasgem/configuration'
+require 'afasgem/getconnector'
+require 'afasgem/updateconnector'
+require 'afasgem/operators'
+require 'savon'
+require 'nokogiri'
+
+module Afasgem
+	# Make the gem configurable
+	# See afasgem/configuration.rb for code origin
+	extend Configuration
+
+	# The WSDL url of the getconnector
+	define_setting :getconnector_url
+
+	# The WSDL url of the updateconnector
+	define_setting :updateconnector_url
+
+	# The WSDL url of the dataconnector
+	define_setting :dataconnector_url
+	# The token, this is only the actual token, not the whole xml thing
+	define_setting :token
+
+
+	# The number of results to request by default
+	define_setting :default_results, 100
+
+	# Defines whether the requests and responses should be printed
+	define_setting :debug, false
+
+	# Constructs a getconnect for the passed connector name
+	def self.getconnector_factory(name)
+		return GetConnector.new(name)
+	end
+
+	# Constructs an updateconnector for the passed connector name
+	def self.updateconnector_factory(name)
+		return UpdateConnector.new(name)
+	end
+
+	# Builds the token xml from the configured token
+	def self.get_token
+		return "<token><version>1</version><data>#{Afasgem::token}</data></token>"
+	end
+end

data/lib/afasgem/configuration.rb

@@ -0,0 +1,24 @@
+# Provides module configuration
+# # Source: https://viget.com/extend/easy-gem-configuration-variables-with-defaults
+module Configuration
+	def configuration
+		yield self
+	end
+
+	def define_setting(name, default = nil)
+		class_variable_set("@@#{name}", default)
+		define_class_method "#{name}=" do |value|
+			class_variable_set("@@#{name}", value)
+		end
+		define_class_method name do
+			class_variable_get("@@#{name}")
+		end
+	end
+
+	private
+	def define_class_method(name, &block)
+		(class << self; self; end).instance_eval do
+			define_method name, &block
+		end
+	end
+end

data/lib/afasgem/getconnector.rb

@@ -0,0 +1,279 @@
+# Implements communication with getconnectors
+class GetConnector
+
+	# Constructor, takes the name of the connector
+	def initialize(name)
+		@connectorname = name
+		@filters = []
+		if Afasgem::debug
+			# Build a debug client if the debug flag is set
+			@client = Savon.client(
+				wsdl: Afasgem::getconnector_url,
+				log: true,
+				log_level: :debug,
+				pretty_print_xml: true
+			)
+		else
+			# Build a normal client otherwise
+			@client = Savon.client(wsdl: Afasgem::getconnector_url)
+		end
+	end
+
+	# Set the number of results we want to have
+	# Provides a fluent interface
+	def take(count)
+		fail ArgumentError.new("Count cannot be lower than 1, #{count} given") unless count > 0
+		@result = nil
+		@resultcount = count
+		return self
+	end
+
+	# Set the number of results we want to skip
+	# Provides a fluent interface
+	def skip(count)
+		fail ArgumentError.new("Count cannot be lower than 1, #{count} given") unless count > 0
+		@result = nil
+		@skip = count
+		return self
+	end
+
+	# Set the page we want to fetch
+	# 1 indexed (i.e. page 1 will fetch result 0 to x)
+	# Provides a fluent interface
+	def page(number)
+		fail ArgumentError.new("Page number cannot be lower than 1, #{number} given") unless number > 0
+		@result = nil
+		@skip = (number - 1) * get_resultcount
+		return self
+	end
+
+	# Fetch the next page
+	# Provides a fluent interface
+	def next
+		@skip = (@skip || 0) + get_resultcount
+		@result = nil
+		return self
+	end
+
+	# Fetch the previous page
+	# Provides a fluent interface
+	def previous
+		@result = nil
+		@skip = (@skip || 0) - get_resultcount
+		@skip = [0, @skip].max
+		return self
+	end
+
+	# execute the request
+	# Provides a fluent interface
+	def execute
+		result = execute_request(get_resultcount, @skip)
+
+		@data_xml = result[0]
+		@result = result[1]
+		return self
+	end
+
+	# Fetches all results
+	# Data is not cached
+	def get_all_results
+		result_array = []
+		skip = 0
+		take = 1000
+		loop do
+			current_result = get_data_from_result(execute_request(take, skip)[1])
+			result_array.concat(current_result)
+			skip = skip + take
+			break if current_result.size != take
+		end
+		return result_array
+	end
+
+	# Adds a filter to the current filter list
+	# Provides a fluent interface
+	def add_filter(field, operator, value = nil)
+		if @filters.size == 0
+			@filters.push([])
+		end
+
+		# Only the EMPTY and NOT_EMPTY filters should accept a nil value
+		if !value
+			unless operator == FilterOperators::EMPTY || operator == FilterOperators::NOT_EMPTY
+				raise ArgumentError.new('Value can only be empty when using FilterOperator::EMPTY or FilterOperator::NOT_EMPTY')
+			end
+		end
+		@filters.last.push({field: field, operator: operator, value: value})
+		return self
+	end
+	
+	# Adds an OR to the current filter list
+	# Provides a fluent interface
+	def add_or
+		@filters.push([]) if @filters.last && @filters.last.size > 0
+		return self
+	end
+
+	# Clears the filters in place
+	# Provides a fluent interface
+	def clear_filters
+		@filters = []
+		return self
+	end
+
+	# Returns the result as a hash
+	# This includes the type definition
+	def get_result
+		execute unless @result
+		return @result
+	end
+
+	# Returns the actual data as a hash
+	def get_data
+		execute unless @result
+		return get_data_from_result(@result)
+	end
+
+	# Returns the raw xml
+	def get_data_xml
+		execute unless @data_xml
+		return @data_xml
+	end
+
+	private
+
+	# Actually fires the request
+	def execute_request(take, skip = nil)
+		message = {
+			token: Afasgem.get_token,
+			connectorId: @connectorname,
+			take: take
+		}
+
+		message[:skip] = skip if skip
+		filter_string = get_filter_string
+		message[:filtersXml] = filter_string if filter_string
+
+		resp = @client.call(:get_data, message: message)
+		xml_string = resp.hash[:envelope][:body][:get_data_response][:get_data_result]
+		return [xml_string, from_xml(xml_string)]
+	end
+
+	# Returns the filter xml in string format
+	def get_filter_string
+		return nil if @filters.size == 0
+		filters = []
+
+		# Loop over each filtergroup
+		# All conditions in a filtergroup are combined using AND
+		# All filtergroups are combined using OR
+		@filters.each_with_index do |filter, index|
+			fields = []
+
+			# Loop over all conditions in a filter group
+			filter.each do |condition|
+				field = condition[:field]
+				operator = condition[:operator]
+				value = condition[:value]
+
+				# Some filters operate on strings and need wildcards
+				# Transform value if needed
+				case operator
+					when FilterOperators::LIKE
+						value = "%#{value}%"
+					when FilterOperators::STARTS_WITH
+						value = "#{value}%"
+					when FilterOperators::NOT_LIKE
+						value = "%#{value}%"
+					when FilterOperators::NOT_STARTS_WITH
+						value = "#{value}%"
+					when FilterOperators::ENDS_WITH
+						value = "%#{value}"
+					when FilterOperators::NOT_ENDS_WITH
+						value = "%#{value}"
+					when FilterOperators::EMPTY
+						# EMPTY and NOT_EMPTY operators require the filter to be in a different format
+						# This because they take no value
+						fields.push("<Field FieldId=\"#{field}\" OperatorType=\"#{operator}\" />")
+						next
+					when FilterOperators::NOT_EMPTY
+						fields.push("<Field FieldId=\"#{field}\" OperatorType=\"#{operator}\" />")
+						next
+				end
+
+				# Add this filterstring to filters
+				fields.push("<Field FieldId=\"#{field}\" OperatorType=\"#{operator}\">#{value}</Field>")
+			end
+
+			# Make sure all filtergroups are OR'ed and add them
+			filters.push("<Filter FilterId=\"Filter #{index}\">#{fields.join}</Filter>")
+		end
+
+		# Return the whole filterstring
+		return "<Filters>#{filters.join}</Filters>"
+	end
+
+	# Returns the number of results we want to fetch
+	def get_resultcount
+		return @resultcount || Afasgem.default_results
+	end
+
+	# Returns the actual rows from a parsed response hash
+	def get_data_from_result(result)
+		return result[:AfasGetConnector][@connectorname.to_sym] || []
+	end
+
+
+	# Source of code below: https://gist.github.com/huy/819999
+	def from_xml(xml_io)
+		begin
+			result = Nokogiri::XML(xml_io)
+			return { result.root.name.to_sym => xml_node_to_hash(result.root)}
+		rescue Exception => e
+			# raise your custom exception here
+		end
+	end
+
+	def xml_node_to_hash(node)
+		# If we are at the root of the document, start the hash 
+		if node.element?
+			result_hash = {}
+			if node.attributes != {}
+				attributes = {}
+				node.attributes.keys.each do |key|
+					attributes[node.attributes[key].name.to_sym] = node.attributes[key].value
+				end
+			end
+			if node.children.size > 0
+				node.children.each do |child|
+					result = xml_node_to_hash(child)
+
+					if child.name == "text"
+						unless child.next_sibling || child.previous_sibling
+							return result unless attributes
+							result_hash[child.name.to_sym] = result
+						end
+					elsif result_hash[child.name.to_sym]
+
+						if result_hash[child.name.to_sym].is_a?(Object::Array)
+							result_hash[child.name.to_sym] << result
+						else
+							result_hash[child.name.to_sym] = [result_hash[child.name.to_sym]] << result
+						end
+					else
+						result_hash[child.name.to_sym] = result
+					end
+				end
+				if attributes
+					#add code to remove non-data attributes e.g. xml schema, namespace here
+					#if there is a collision then node content supersets attributes
+					result_hash = attributes.merge(result_hash)
+				end
+				return result_hash
+			else
+				return attributes
+			end
+		else
+			return node.content.to_s
+		end
+	end
+end

data/lib/afasgem/operators.rb

@@ -0,0 +1,17 @@
+# This module maps constants to AFAS filter ints
+module FilterOperators
+	EQUAL            = 1
+	LARGER_OR_EQUAL  = 2
+	SMALLER_OR_EQUAL = 3
+	LARGER_THAN      = 4
+	SMALLER_THAN     = 5
+	LIKE             = 6
+	NOT_EQUAL        = 7
+	EMPTY            = 8
+	NOT_EMPTY        = 9
+	STARTS_WITH      = 10
+	NOT_LIKE         = 11
+	NOT_STARTS_WITH  = 12
+	ENDS_WITH        = 13
+	NOT_ENDS_WITH    = 14
+end

data/lib/afasgem/updateconnector.rb

@@ -0,0 +1,91 @@
+class UpdateConnector
+
+	# Constructor, takes the connector name
+	def initialize(name)
+		@connectorname = name
+		if Afasgem::debug
+			# Build a debug client if the debug flag is set
+			@client = Savon.client(
+				wsdl: Afasgem::updateconnector_url,
+				log: true,
+				log_level: :debug,
+				pretty_print_xml: true
+			)
+		else
+			# Build a normal client otherwise
+			@client = Savon.client(wsdl: Afasgem::updateconnector_url)
+		end
+	end
+
+	# Method to return the savon client for this constructor
+	def client
+		return @client
+	end
+
+	# Executes an insert action using the passed object hash
+	def insert(objecthash)
+		xml = build_xml(objecthash, 'insert')
+		return execute(xml)
+	end
+
+	# Executes an update action using the passed object hash
+	def update(objecthash)
+		xml = build_xml(objecthash, 'update')
+		return execute(xml)
+	end
+
+	# Executes a delete action using the passed object hash
+	def delete(objecthash)
+		xml = build_xml(objecthash, 'delete')
+		return execute(xml)
+	end
+
+	private
+
+	# Builds the inner xml to send to the afas api from the passed hash and action
+	def build_xml(objecthash, action)
+		builder = Nokogiri::XML::Builder.new do |xml|
+			xml.send(@connectorname.to_sym, 'xmlns:xsi' => "http://www.w3.org/2001/XMLSchema-instance") {
+				xml.Element {
+					xml.Fields(Action: action) {
+						objecthash.each do |k, v|
+							xml.send(k.to_sym, v) unless k.to_s == 'Objects'
+							build_nested_xml(xml, v, action) if k.to_s == 'Objects'
+						end
+					}
+				}
+			}
+		end
+		return builder.to_xml.to_s
+	end
+
+	# Builds the xml for nested objects
+	def build_nested_xml(xml, objects, action)
+		xml.Objects {
+			objects.each do |obj, values|
+
+				xml.send(obj) {
+					xml.Element {
+						xml.Fields(Action: action) {
+							values.each do |k, v|
+								xml.send(k, v)
+							end
+						}
+					}
+				}
+			end
+		}
+	end
+
+	# Actually calls the afas api
+	def execute(xml)
+		message = {
+			token: Afasgem.get_token,
+			connectorType: @connectorname,
+			connectorVersion: 1,
+			dataXml: xml
+		}
+		resp = @client.call(:execute, message: message)
+		return resp
+	end
+end

data/lib/afasgem/version.rb

@@ -0,0 +1,3 @@
+module Afasgem
+  VERSION = "0.0.1"
+end

metadata

@@ -0,0 +1,202 @@
+--- !ruby/object:Gem::Specification
+name: afasgem
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Subhi Dweik
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-02-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: savon
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.11.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.11.1
+- !ruby/object:Gem::Dependency
+  name: httpclient
+  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: rubyntlm
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.2
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-nav
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-stack_explorer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-doc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- subhime@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- afasgem.gemspec
+- bin/connector_format.rb
+- bin/console
+- bin/setup
+- lib/afasgem.rb
+- lib/afasgem/configuration.rb
+- lib/afasgem/getconnector.rb
+- lib/afasgem/operators.rb
+- lib/afasgem/updateconnector.rb
+- lib/afasgem/version.rb
+homepage: https://github.com/Bonemind/Afasgem
+licenses:
+- MIT
+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.4.8
+signing_key: 
+specification_version: 4
+summary: A gem that wraps basic afas api functionality
+test_files: []
+has_rdoc: