crv_api_client 0.1.3

data/lib/crv_api_client/api/reproduction.rb

@@ -0,0 +1,9 @@
+module CrvApiClient
+  module Api
+    module Reproduction
+      require 'crv_api_client/api/reproduction/reproduction'
+      require 'crv_api_client/api/reproduction/reproduction_driver'
+      require 'crv_api_client/api/reproduction/reproduction_mapping_registry'
+    end
+  end
+end

data/lib/crv_api_client/api.rb

@@ -0,0 +1,6 @@
+module CrvApiClient
+  module Api
+    autoload :Animals, 'crv_api_client/api/animals'
+    autoload :Reproduction, 'crv_api_client/api/reproduction'
+  end
+end

data/lib/crv_api_client/errors.rb

@@ -0,0 +1,57 @@
+module CrvApiClient
+  module Errors
+
+
+    class CrvError < StandardError
+
+    end
+
+    class CrvRequestError < CrvError
+      attr_reader :data, :code, :type
+      def initialize(code, data, type)
+        @data = data
+        @code = code
+        @type = type
+      end
+    end
+    # General animal error class
+    class AnimalError < CrvError; end
+    # General keeper error class
+    class KeeperError < CrvError; end
+    # General Request error class
+    class RequestError < CrvError; end
+    # General Authorization error
+    class AuthorizationError < CrvError; end
+    # General Authentication error
+    class AuthenticationError < CrvError; end
+
+
+
+    #code 9
+    class AnimalUnknownError < AnimalError; end
+    #code 10
+    class AnimalDeadError < AnimalError; end
+    #code 11
+    class AnimalExportedError < AnimalError; end
+    #code 12
+    class AnimalUnknownKeeperOnReferenceDateError < AnimalError; end
+
+
+    #code 13
+    class KeeperUnknownError < KeeperError; end
+    #code 14
+    class KeeperNoAccessInvalidCustomerError < KeeperError; end
+    #code 15
+    class KeeperNoAccessInvalidOrganizationError < KeeperError; end
+    #code 16
+    class KeeperNoAccessNoEmployeeRelationship < KeeperError; end
+
+    class InvalidValueInMessageError < RequestError; end
+    #code 19
+    class UsernamePasswordInvalid < AuthenticationError; end
+    #code 22
+    class UserNotAuthorized < AuthenticationError; end
+
+
+  end
+end

data/lib/crv_api_client/helpers/attributes.rb

@@ -0,0 +1,34 @@
+module CrvApiClient
+  module Helpers
+    module Attributes
+
+      #defines an public attribute reader and a private writer
+      #name: the instance variable name for which a get method has to be created
+      #type: The object type.
+      def attr_reader_with_type(name, type)
+        define_attribute_methods(name, type)
+        class_eval { private "#{name}=" }
+      end
+
+      #defines an public attribute writer and reader.
+      #name: the instance variable name for which a get method has to be created
+      #type: The object type.
+      def attr_accessor_with_type(name, type)
+        define_attribute_methods(name, type)
+      end
+
+      private
+      #defines the attribute set and get methods and
+      def define_attribute_methods(name, type)
+        define_method(name) do
+          instance_variable_get("@#{name}")
+        end
+
+        define_method("#{name}=") do |value|
+          raise ArgumentError.new("Invalid Type, #{value.class.name} is not a #{type.name} ") unless (value.is_a?(type) || value.nil?)
+          instance_variable_set("@#{name}", value)
+        end
+      end
+    end
+  end
+end

data/lib/crv_api_client/helpers/crv.rb

@@ -0,0 +1,89 @@
+module CrvApiClient
+  module Helpers
+    module Crv
+      include Endpoint
+
+      def get_keeper(crv_id, country)
+        keeper = endpoint_participant_id.new
+        keeper.participantCode = crv_id
+        country = country.upcase unless country.nil?
+        case(country)
+          when nil, "NL" # Netherlands
+            keeper.participantCodeType = "UBN"
+            keeper.countryCode = "NLD"
+          when "BE" # Belgium
+            keeper.participantCodeType = "UVN"
+            keeper.countryCode = "BE"
+          when "DE" # Germany
+            keeper.participantCodeType = "LDE"
+            keeper.countryCode = "DE"
+          when "CZ" # Czech
+            keeper.participantCodeType = "LCZ"
+            keeper.countryCode = "CZ"
+        end
+        keeper
+      end
+
+      def get_crv_organisation_code(country)
+        country = country.upcase unless country.nil?
+        value = case country
+                  when nil, "NL" then "crv.nl" # Netherlands
+                  when "BE" then "crv.be" # Belgium
+                  when "DE" then "crv.de" # Germany
+                  when "CZ" then "crv.cz" # Czech
+                end
+        value
+      end
+
+      def context_message(keeper,
+                          context_message_detail: [],
+                          username: "",
+                          password: "",
+                          provider: nil,
+                          customer: nil,
+                          animal: nil,
+                          process_code: "",
+                          organisation: nil)
+        context = endpoint_context_message.new
+        context.sessionId = ""
+        context.processId = ""
+        context.instanceId = ""
+        context.username = username
+        context.userType = "C"
+        context.password = password
+        context.organisation = organisation
+        context.provider = provider
+        context.customer = customer
+        context.keeper = keeper
+        context.animal = animal
+        context.processCode = process_code
+        context.messageSource = ""
+        context.languageCode = ""
+        context.timeZone = ""
+        context.contextMessageDetail = context_message_detail
+        context
+      end
+      protected
+
+      def perform_service_message_validation(serviceMessage)
+        case(serviceMessage.serviceStatus.to_i)
+          when 1..200
+            raise ::CrvApiClient::Errors::CrvRequestError.new(serviceMessage.serviceStatus,
+                                      serviceMessage.messageText,
+                                      serviceMessage.messageType)
+        end
+
+      end
+
+
+      private
+
+
+      def keeper_and_context_message_detail(crv_id,countryCode= nil)
+        keeper = get_keeper("#{crv_id}", countryCode)
+        contextMessageDetail = endpoint_context_message_detail.new("organisation", get_crv_organisation_code(countryCode))
+        [keeper,contextMessageDetail]
+      end
+    end
+  end
+end

data/lib/crv_api_client/helpers/endpoint.rb

@@ -0,0 +1,46 @@
+module CrvApiClient
+  module Helpers
+    module Endpoint
+
+      private
+      ##
+      # Calculates api endpoint path based on class who includes this module
+      # it adds the string '::Api' before the last '::' match.
+      # Regex splits the class name and modules by the last '::' match
+      # \1 is the string before the last '::' match
+      # \2 contains the last :: match
+      # \3 contains the string after the '::' match.
+      # Returns a string
+      # example::
+      # class CrvApiClient::Animals returns CrvApiClient::Api::Animals
+      # class CrvApiClient::Base::Before::Animals returns CrvApiClient::Base::Before::Api::Animals
+      ##
+      def class_api_endpoint
+        self.class.name.gsub(/(.*)(::)(.*)/, '\1\2Api\2\3\2')
+      end
+
+      ##
+      # Returns the Api Participant Id of the included class.
+      ##
+      def endpoint_participant_id
+        Object.const_get(class_api_endpoint << "ParticipantId")
+      end
+
+      ##
+      # Returns the Api ContextMessageDetail of the included class.
+      ##
+      def endpoint_context_message_detail
+        Object.const_get(class_api_endpoint << "ContextMessageDetail")
+      end
+
+      def endpoint_context_message
+        Object.const_get(class_api_endpoint << "ContextMessage")
+      end
+
+      def endpoint_animal_id
+        Object.const_get(class_api_endpoint << "AnimalId")
+      end
+
+    end
+  end
+end

data/lib/crv_api_client/helpers.rb

@@ -0,0 +1,7 @@
+module CrvApiClient
+  module Helpers
+    autoload :Attributes, "crv_api_client/helpers/attributes"
+    autoload :Crv, "crv_api_client/helpers/crv"
+    autoload :Endpoint, "crv_api_client/helpers/endpoint"
+  end
+end

data/lib/crv_api_client/reproduction.rb

@@ -0,0 +1,87 @@
+module CrvApiClient
+  class Reproduction
+    extend ::CrvApiClient::Helpers::Attributes
+    include ::CrvApiClient::Helpers::Crv
+
+    attr_reader :endpoint_url
+    attr_reader :username
+    attr_reader :password
+    attr_reader_with_type :customer, ::CrvApiClient::Api::Reproduction::ParticipantId
+    attr_reader_with_type :provider, ::CrvApiClient::Api::Reproduction::ParticipantId
+
+    def initialize(endpoint_url= ::CrvApiClient.configuration.endpoint_reproduction,
+                   username: ::CrvApiClient.configuration.username,
+                   password: ::CrvApiClient.configuration.password,
+                   customer: ::CrvApiClient.configuration.customer,
+                   provider: ::CrvApiClient.configuration.provider)
+
+      @endpoint_url = endpoint_url
+      @username = username
+      @password = password
+      self.customer= ::CrvApiClient::Api::Reproduction::ParticipantId.new(customer[:participant_code], customer[:participant_code_type], customer[:country_code])
+      self.provider= ::CrvApiClient::Api::Reproduction::ParticipantId.new(provider[:participant_code], provider[:participant_code_type], provider[:country_code])
+    end
+
+    def list_reproduction_last_parity(crv_id, country_code, context_message_detail: nil,process_code: "", options: {})
+      keeper, context_message_detail = keeper_and_context_message_detail(crv_id,country_code)
+      context = context_message(keeper,
+                                username: @username,
+                                password: @password,
+                                context_message_detail: context_message_detail,
+                                customer: customer,
+                                provider: provider,
+                                process_code: process_code,
+                                animal: nil,
+                                organisation: nil)
+
+
+      animal_request = [ participant_animal_request("TRP","PED") ]
+      animal_request_list = list_participant_animal_request("SHORT", animal_request)
+      requestType = list_reproduction_last_parity_request_type(keeper, animal_request_list)
+      request = CrvApiClient::Api::Reproduction::ListReproductionLastParityRequest.new
+      request.contextMessage = context
+      request.requestMessage = requestType
+
+      result = driver.listReproductionLastParity(request)
+
+      perform_service_message_validation(result.serviceMessage) unless options[:validate] == false
+
+      result
+    end
+
+
+    private
+
+    def participant_animal_request(number_type, number_sub_type)
+      animal_request = CrvApiClient::Api::Reproduction::ParticipantAnimalRequest.new
+      animal_request.numberType = number_type
+      animal_request.numberSubType = number_sub_type
+      animal_request
+    end
+
+    def list_participant_animal_request(list_type, participant_animal_request)
+      animal_request_list = CrvApiClient::Api::Reproduction::ListParticipantAnimalRequest.new
+      animal_request_list.listType = list_type
+      animal_request_list.participantAnimalRequest = participant_animal_request
+      animal_request_list
+    end
+
+    def list_reproduction_last_parity_request_type(keeper, participant_animal_request)
+      requestType = CrvApiClient::Api::Reproduction::ListReproductionLastParityRequestType.new
+      requestType.keeper = keeper
+      requestType.participantAnimalRequest = participant_animal_request
+      requestType
+    end
+
+    def driver
+      @driver ||= begin
+        animal_soap_driver = CrvApiClient::Api::Reproduction::RsReproductionPortType.new(@endpoint_url)
+        animal_soap_driver.options['protocol.http.connect_timeout'] = CrvApiClient.configuration.http_connect_timeout || 220
+        animal_soap_driver.options['protocol.http.receive_timeout'] = CrvApiClient.configuration.http_receive_timeout || 220
+        animal_soap_driver.options['protocol.http.ssl_config.verify_mode'] = nil
+        animal_soap_driver.wiredump_file_base = CrvApiClient.configuration.log_file
+        animal_soap_driver
+      end
+    end
+  end
+end

data/lib/crv_api_client/utils/configuration.rb

@@ -0,0 +1,40 @@
+module CrvApiClient
+  module Utils
+    class Configuration
+
+      attr_accessor :endpoint_reproduction
+      attr_accessor :endpoint_animals
+      attr_accessor :http_connect_timeout
+      attr_accessor :http_receive_timeout
+      attr_accessor :username
+      attr_accessor :password
+      attr_accessor :log_file
+
+      attr_accessor :customer
+      attr_accessor :provider
+
+
+      def customer=(customer={})
+        @customer_participant_code = customer[:participant_code] || ""
+        @customer_participant_code_type = customer[:participant_code_type] || ""
+        @customer_country_code = customer[:country_code] || ""
+        customer
+      end
+
+      def customer
+        {participant_code: @customer_participant_code || "", participant_code_type: @customer_participant_code_type|| "", country_code: @customer_country_code|| ""}
+      end
+
+      def provider=(provider={})
+        @provider_participant_code = provider[:participant_code] || ""
+        @provider_participant_code_type = provider[:participant_code_type] || ""
+        @provider_country_code = provider[:country_code] || ""
+        provider
+      end
+
+      def provider
+        {participant_code: @provider_participant_code|| "", participant_code_type: @provider_participant_code_type|| "", country_code: @provider_country_code|| ""}
+      end
+    end
+  end
+end

data/lib/crv_api_client/utils.rb

@@ -0,0 +1,5 @@
+module CrvApiClient
+  module Utils
+    autoload :Configuration , "crv_api_client/utils/configuration"
+  end
+end

data/lib/crv_api_client/version.rb

@@ -0,0 +1,3 @@
+module CrvApiClient
+  VERSION = "0.1.3"
+end

data/lib/crv_api_client.rb

@@ -0,0 +1,26 @@
+require "crv_api_client/version"
+
+module CrvApiClient
+  class << self
+    attr_writer :configuration
+  end
+
+  def self.configuration
+    @configuration ||= Utils::Configuration.new
+  end
+
+  def self.configure
+    yield(configuration)
+  end
+
+  require 'soap/mapping'
+  require 'xsd/qname'
+  require 'soap/rpc/driver'
+  autoload :Helpers, 'crv_api_client/helpers'
+  autoload :Errors, 'crv_api_client/errors'
+  autoload :Api, 'crv_api_client/api'
+  autoload :Animals, 'crv_api_client/animals'
+  autoload :Reproduction, 'crv_api_client/reproduction'
+  autoload :Utils, 'crv_api_client/utils'
+
+end

data/spec/lib/crv/animals_spec.rb

@@ -0,0 +1,95 @@
+describe CrvApiClient::Animals do
+  let(:endpoint) { "https://localhost/animals" }
+  let(:default_content_type) { 'application/json' }
+
+  let(:animal) {::CrvApiClient::Api::Animals::AnimalId.new("b","c")}
+  let(:config_customer) { {participant_code:"10106605",participant_code_type:"PAR", country_code:"NLD"} }
+  let(:config_provider) { {participant_code:"2323",participant_code_type:"test", country_code:"asd"} }
+  let(:crv_customer) { ::CrvApiClient::Api::Animals::ParticipantId.new("10106605","PAR","NLD")}
+  let(:crv_provider) { ::CrvApiClient::Api::Animals::ParticipantId.new("2323","test","asd")}
+  let(:username) {"Username"}
+  let(:password) {"password"}
+
+  let(:client) { CrvApiClient::Animals.new }
+  let(:configured_client) { ::CrvApiClient::Animals.new(endpoint, username: username, password: password, customer: config_customer, provider: config_provider ) }
+  context 'initialization' do
+
+    it "should initalize the client with given parameters" do
+      expect(configured_client.endpoint_url).to eq(endpoint)
+      expect(configured_client.username).to eq(username)
+      expect(configured_client.password).to eql(password)
+      expect(configured_client.customer).to be_a(::CrvApiClient::Api::Animals::ParticipantId)
+      expect(configured_client.provider).to be_a(::CrvApiClient::Api::Animals::ParticipantId)
+
+    end
+
+    it "should initialize with the configured attributes as default" do
+      CrvApiClient.configure do |conf|
+        conf.endpoint_animals = endpoint
+        conf.username = username
+        conf.password = password
+        conf.customer = config_customer
+      end
+
+      expect(client.endpoint_url).to eq(endpoint)
+      expect(client.username).to eq(username)
+      expect(client.password).to eq(password)
+      expect(client.customer).to be_a(::CrvApiClient::Api::Animals::ParticipantId)
+    end
+  end
+
+  context 'list_animals' do
+    it 'should list animals' do
+      crv_id = 20
+      country_code  = "nl"
+      process_code = "2838"
+      context_message = CrvApiClient::Api::Animals::ContextMessage.new
+      keeper = ::CrvApiClient::Api::Animals::ParticipantId.new(crv_id,"",country_code)
+      context_message_detail = ::CrvApiClient::Api::Animals::ContextMessageDetail.new("a","b")
+      service_message = ::CrvApiClient::Api::Animals::ServiceMessage
+      response = ::CrvApiClient::Api::Animals::ListHerdPedigreeResponse.new(nil,service_message)
+
+
+      expect(configured_client).to receive(:keeper_and_context_message_detail).with(crv_id, country_code).and_return([keeper,context_message_detail])
+      expect(configured_client).to receive(:context_message).with(keeper, username: username, password: password, customer: instance_of(CrvApiClient::Api::Animals::ParticipantId), provider: instance_of(CrvApiClient::Api::Animals::ParticipantId), animal: nil, context_message_detail: context_message_detail,  process_code: process_code, organisation: nil).and_return(context_message)
+      driver = configured_client.send(:driver)
+      expect(driver).to receive(:listHerdPedigree).with(satisfy { |message|
+        expect(message).to be_a(CrvApiClient::Api::Animals::ListHerdPedigreeRequest)
+        expect(message.requestMessage).to be_a(CrvApiClient::Api::Animals::ListHerdPedigreeRequestType)
+        expect(message.requestMessage.keeper).to be(keeper)
+        expect(message.contextMessage).to be(context_message)
+      }).and_return(response)
+      expect(configured_client).to receive(:perform_service_message_validation).with(service_message)
+
+      response = configured_client.list_animals(crv_id,country_code,process_code: process_code)
+
+    end
+
+    it 'should not handle message validations when option is given.' do
+      crv_id = 20
+      country_code  = "nl"
+      process_code = "2838"
+      context_message = CrvApiClient::Api::Animals::ContextMessage.new
+      keeper = ::CrvApiClient::Api::Animals::ParticipantId.new(crv_id,"",country_code)
+      context_message_detail = ::CrvApiClient::Api::Animals::ContextMessageDetail.new("a","b")
+      service_message = ::CrvApiClient::Api::Animals::ServiceMessage
+      response = ::CrvApiClient::Api::Animals::ListHerdPedigreeResponse.new(nil,service_message)
+
+
+      expect(configured_client).to receive(:keeper_and_context_message_detail).with(crv_id, country_code).and_return([keeper,context_message_detail])
+      expect(configured_client).to receive(:context_message).with(keeper, username: username, password: password, customer: instance_of(CrvApiClient::Api::Animals::ParticipantId), provider: instance_of(CrvApiClient::Api::Animals::ParticipantId), animal: nil, context_message_detail: context_message_detail,  process_code: process_code, organisation: nil).and_return(context_message)
+      driver = configured_client.send(:driver)
+      expect(driver).to receive(:listHerdPedigree).with(satisfy { |message|
+        expect(message).to be_a(CrvApiClient::Api::Animals::ListHerdPedigreeRequest)
+        expect(message.requestMessage).to be_a(CrvApiClient::Api::Animals::ListHerdPedigreeRequestType)
+        expect(message.requestMessage.keeper).to be(keeper)
+        expect(message.contextMessage).to be(context_message)
+      }).and_return(response)
+      expect(configured_client).to receive(:perform_service_message_validation).with(service_message).never
+
+      response = configured_client.list_animals(crv_id,country_code,process_code: process_code, options: {validate: false})
+
+    end
+  end
+  
+end

data/spec/lib/crv/api/animals/animals_driver_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe CrvApiClient::Api::Animals::RsAnimalPortType do
+
+  describe "configure" do
+    it "should assign endpoints as default" do
+      animals = "EndpointAnimals"
+
+      CrvApiClient.configure do |config|
+        config.endpoint_animals = animals
+      end
+      driver = CrvApiClient::Api::Animals::RsAnimalPortType.new
+
+      expect(driver.proxy.endpoint_url).to be(animals)
+
+    end
+
+    it "should accept custom endpoints " do
+
+      animals = "MyEndpointAnimals"
+
+      driver = CrvApiClient::Api::Animals::RsAnimalPortType.new animals
+
+      expect(driver.proxy.endpoint_url).to be(animals)
+    end
+
+    it "should load with the default url" do
+
+      CrvApiClient.configure do |config|
+        config.endpoint_animals = nil
+      end
+
+      driver = CrvApiClient::Api::Animals::RsAnimalPortType.new
+
+      expect(driver.proxy.endpoint_url).to be(CrvApiClient::Api::Animals::RsAnimalPortType::DefaultEndpointUrl)
+    end
+  end
+
+end

data/spec/lib/crv/api/reproduction/reproduction_driver_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe CrvApiClient::Api::Reproduction::RsReproductionPortType do
+
+  describe "configure" do
+    it "should assign endpoints as default" do
+      reproduction = "ReproductionEndpoint"
+
+      CrvApiClient.configure do |config|
+        config.endpoint_reproduction = reproduction
+      end
+      driver = CrvApiClient::Api::Reproduction::RsReproductionPortType.new
+
+      expect(driver.proxy.endpoint_url).to be(reproduction)
+
+    end
+
+    it "should accept custom endpoints " do
+
+      reproduction = "MyReproductionEndpoint"
+
+      driver = CrvApiClient::Api::Reproduction::RsReproductionPortType.new reproduction
+
+      expect(driver.proxy.endpoint_url).to be(reproduction)
+    end
+
+    it "should load with the default url" do
+
+      CrvApiClient.configure do |config|
+        config.endpoint_reproduction = nil
+      end
+
+      driver = CrvApiClient::Api::Reproduction::RsReproductionPortType.new
+
+      expect(driver.proxy.endpoint_url).to be(CrvApiClient::Api::Reproduction::RsReproductionPortType::DefaultEndpointUrl)
+    end
+  end
+
+end

data/spec/lib/crv/helpers/attributes_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+describe ::CrvApiClient::Helpers::Attributes  do
+
+  let(:tested_class) { Class.new {
+    extend ::CrvApiClient::Helpers::Attributes
+  }.new }
+  context "attr_reader_with_type" do
+    it "should create a reader that is public" do
+      tested_class.class.attr_reader_with_type :foo , String
+      expect(tested_class).to respond_to(:foo).with(0).argument
+    end
+
+    it "should create a writer that is private" do
+      tested_class.class.attr_reader_with_type :foo , String
+      expect(tested_class.private_methods).to include(:foo=)
+    end
+
+  end
+
+  context "attr_accessor_with_type" do
+    it "should create a reader that is public" do
+      tested_class.class.attr_accessor_with_type :foo , String
+      expect(tested_class).to respond_to(:foo).with(0).argument
+    end
+
+    it "should create a writer that is public" do
+      tested_class.class.attr_accessor_with_type :foo , String
+      expect(tested_class).to respond_to(:foo=).with(1).argument
+    end
+
+  end
+
+  context "general assignment" do
+    it "should throw an error when type does not match the assigned type" do
+      tested_class.class.attr_accessor_with_type :foo , String
+      expect{tested_class.foo = 1}.to raise_error(ArgumentError, /Invalid Type/)
+    end
+
+    it "should accept a matching type" do
+      tested_class.class.attr_accessor_with_type :foo , String
+      expect{tested_class.foo = "some string"}.not_to raise_error
+    end
+
+    it "should return the given argument" do
+      argument = "Some string"
+      tested_class.class.attr_accessor_with_type :foo , String
+      expect{tested_class.foo = argument}.not_to raise_error
+      expect(tested_class.foo).to be(argument)
+    end
+  end
+end