From 42444713729ac6cbf6ff613ca05d785b5edafcf2 Mon Sep 17 00:00:00 2001 From: dvacca-onfido <134616519+dvacca-onfido@users.noreply.github.com> Date: Thu, 13 Jun 2024 13:42:00 +0000 Subject: [PATCH 1/2] Upgrade after onfido-openapi-spec change 38a8740 --- .release.json | 9 + README.md | 22 +- lib/onfido.rb | 4 + .../facial_similarity_motion_properties.rb | 215 ++++++++++++++++++ .../models/facial_similarity_motion_report.rb | 17 +- ..._similarity_photo_fully_auto_properties.rb | 215 ++++++++++++++++++ ...cial_similarity_photo_fully_auto_report.rb | 17 +- .../facial_similarity_photo_properties.rb | 215 ++++++++++++++++++ .../models/facial_similarity_photo_report.rb | 17 +- .../facial_similarity_video_properties.rb | 215 ++++++++++++++++++ .../models/facial_similarity_video_report.rb | 17 +- 11 files changed, 944 insertions(+), 19 deletions(-) create mode 100644 .release.json create mode 100644 lib/onfido/models/facial_similarity_motion_properties.rb create mode 100644 lib/onfido/models/facial_similarity_photo_fully_auto_properties.rb create mode 100644 lib/onfido/models/facial_similarity_photo_properties.rb create mode 100644 lib/onfido/models/facial_similarity_video_properties.rb diff --git a/.release.json b/.release.json new file mode 100644 index 0000000..7d86609 --- /dev/null +++ b/.release.json @@ -0,0 +1,9 @@ +{ + "source": { + "repo_url": "https://github.com/onfido/onfido-openapi-spec", + "short_sha": "38a8740", + "long_sha": "38a87401552386cb0b17aae28385c5e2f4af7bfc", + "version": "" + }, + "release": "v3.0.0" +} diff --git a/README.md b/README.md index bc3a9d4..4834ef5 100644 --- a/README.md +++ b/README.md @@ -86,7 +86,7 @@ Webhook events payload needs to be verified before it can be accessed. Library a ## Contributing -This library is automatically generated using [OpenAPI Generator](https://openapi-generator.tech) - version: 7.6.0; therefore all the contributions, except tests files, should target [Onfido OpenAPI specification repository](https://github.com/onfido/onfido-openapi-spec/tree/master) instead of this repository. +This library is automatically generated using [OpenAPI Generator](https://openapi-generator.tech) (version: 7.6.0); therefore all the contributions, except tests files, should target [Onfido OpenAPI specification repository](https://github.com/onfido/onfido-openapi-spec/tree/master) instead of this repository. For contributions to the tests instead, please follow the steps below: @@ -97,11 +97,27 @@ For contributions to the tests instead, please follow the steps below: 5. Push to the branch (`git push origin my-new-feature`) 6. Create a new Pull Request +## Versioning policy + +[Semantic Versioning](https://semver.org) policy is used for library versioning, following guidelines and limitations below: + +- MAJOR versions (x.0.0) might: + - target a new API version + - include non-backward compatible change +- MINOR versions (0.x.0) might: + - add a new functionality, non-mandatory parameter or property + - deprecate an old functionality + - include non-backward compatible change to a functionality which is: + - labelled as alpha or beta + - completely broken and not usable +- PATCH version (0.0.x) might: + - fix a bug + - include backward compatible changes only + ## More documentation More documentation and code examples can be found at . ## Support -Should you encounter any technical issues during integration, please contact Onfido's Customer Support team -via the [Customer Experience Portal](https://public.support.onfido.com/) which also includes support documentation. +Should you encounter any technical issues during integration, please contact Onfido's Customer Support team via the [Customer Experience Portal](https://public.support.onfido.com/) which also includes support documentation. diff --git a/lib/onfido.rb b/lib/onfido.rb index 038983a..34765cc 100644 --- a/lib/onfido.rb +++ b/lib/onfido.rb @@ -127,6 +127,7 @@ require 'onfido/models/facial_similarity_motion_breakdown_visual_authenticity' require 'onfido/models/facial_similarity_motion_breakdown_visual_authenticity_breakdown' require 'onfido/models/facial_similarity_motion_breakdown_visual_authenticity_breakdown_spoofing_detection' +require 'onfido/models/facial_similarity_motion_properties' require 'onfido/models/facial_similarity_motion_report' require 'onfido/models/facial_similarity_photo_breakdown' require 'onfido/models/facial_similarity_photo_breakdown_face_comparison' @@ -145,7 +146,9 @@ require 'onfido/models/facial_similarity_photo_fully_auto_breakdown_image_integrity' require 'onfido/models/facial_similarity_photo_fully_auto_breakdown_image_integrity_breakdown' require 'onfido/models/facial_similarity_photo_fully_auto_breakdown_image_integrity_breakdown_source_integrity' +require 'onfido/models/facial_similarity_photo_fully_auto_properties' require 'onfido/models/facial_similarity_photo_fully_auto_report' +require 'onfido/models/facial_similarity_photo_properties' require 'onfido/models/facial_similarity_photo_report' require 'onfido/models/facial_similarity_video_breakdown' require 'onfido/models/facial_similarity_video_breakdown_face_comparison' @@ -157,6 +160,7 @@ require 'onfido/models/facial_similarity_video_breakdown_visual_authenticity_breakdown' require 'onfido/models/facial_similarity_video_breakdown_visual_authenticity_breakdown_liveness_detected' require 'onfido/models/facial_similarity_video_breakdown_visual_authenticity_breakdown_spoofing_detection' +require 'onfido/models/facial_similarity_video_properties' require 'onfido/models/facial_similarity_video_report' require 'onfido/models/id_number' require 'onfido/models/id_photo' diff --git a/lib/onfido/models/facial_similarity_motion_properties.rb b/lib/onfido/models/facial_similarity_motion_properties.rb new file mode 100644 index 0000000..613cd38 --- /dev/null +++ b/lib/onfido/models/facial_similarity_motion_properties.rb @@ -0,0 +1,215 @@ +=begin +#Onfido API v3.6 + +#The Onfido API (v3.6) + +The version of the OpenAPI document: v3.6 + +Generated by: https://openapi-generator.tech +Generator version: 7.6.0 + +=end + +require 'date' +require 'time' + +module Onfido + class FacialSimilarityMotionProperties + # A floating point number between 0 and 1. The closer the score is to 0, the more likely it is to be a spoof (i.e. videos of digital screens, masks or print-outs). Conversely, the closer it is to 1, the less likely it is to be a spoof. + attr_accessor :score + + # Attribute mapping from ruby-style variable name to JSON key. + def self.attribute_map + { + :'score' => :'score' + } + end + + # Returns all the JSON keys this model knows about + def self.acceptable_attributes + attribute_map.values + end + + # Attribute type mapping. + def self.openapi_types + { + :'score' => :'Float' + } + end + + # List of attributes with nullable: true + def self.openapi_nullable + Set.new([ + ]) + end + + # Initializes the object + # @param [Hash] attributes Model attributes in the form of hash + def initialize(attributes = {}) + if (!attributes.is_a?(Hash)) + fail ArgumentError, "The input argument (attributes) must be a hash in `Onfido::FacialSimilarityMotionProperties` initialize method" + end + + # check to see if the attribute exists and convert string to symbol for hash key + attributes = attributes.each_with_object({}) { |(k, v), h| + if (!self.class.attribute_map.key?(k.to_sym)) + fail ArgumentError, "`#{k}` is not a valid attribute in `Onfido::FacialSimilarityMotionProperties`. Please check the name to make sure it's valid. List of attributes: " + self.class.attribute_map.keys.inspect + end + h[k.to_sym] = v + } + + if attributes.key?(:'score') + self.score = attributes[:'score'] + end + end + + # Show invalid properties with the reasons. Usually used together with valid? + # @return Array for valid properties with the reasons + def list_invalid_properties + warn '[DEPRECATED] the `list_invalid_properties` method is obsolete' + invalid_properties = Array.new + invalid_properties + end + + # Check to see if the all the properties in the model are valid + # @return true if the model is valid + def valid? + warn '[DEPRECATED] the `valid?` method is obsolete' + true + end + + # Checks equality by comparing each attribute. + # @param [Object] Object to be compared + def ==(o) + return true if self.equal?(o) + self.class == o.class && + score == o.score + end + + # @see the `==` method + # @param [Object] Object to be compared + def eql?(o) + self == o + end + + # Calculates hash code according to all attributes. + # @return [Integer] Hash code + def hash + [score].hash + end + + # Builds the object from hash + # @param [Hash] attributes Model attributes in the form of hash + # @return [Object] Returns the model itself + def self.build_from_hash(attributes) + return nil unless attributes.is_a?(Hash) + attributes = attributes.transform_keys(&:to_sym) + transformed_hash = {} + openapi_types.each_pair do |key, type| + if attributes.key?(attribute_map[key]) && attributes[attribute_map[key]].nil? + transformed_hash["#{key}"] = nil + elsif type =~ /\AArray<(.*)>/i + # check to ensure the input is an array given that the attribute + # is documented as an array but the input is not + if attributes[attribute_map[key]].is_a?(Array) + transformed_hash["#{key}"] = attributes[attribute_map[key]].map { |v| _deserialize($1, v) } + end + elsif !attributes[attribute_map[key]].nil? + transformed_hash["#{key}"] = _deserialize(type, attributes[attribute_map[key]]) + end + end + new(transformed_hash) + end + + # Deserializes the data based on type + # @param string type Data type + # @param string value Value to be deserialized + # @return [Object] Deserialized data + def self._deserialize(type, value) + case type.to_sym + when :Time + Time.parse(value) + when :Date + Date.parse(value) + when :String + value.to_s + when :Integer + value.to_i + when :Float + value.to_f + when :Boolean + if value.to_s =~ /\A(true|t|yes|y|1)\z/i + true + else + false + end + when :Object + # generic object (usually a Hash), return directly + value + when /\AArray<(?.+)>\z/ + inner_type = Regexp.last_match[:inner_type] + value.map { |v| _deserialize(inner_type, v) } + when /\AHash<(?.+?), (?.+)>\z/ + k_type = Regexp.last_match[:k_type] + v_type = Regexp.last_match[:v_type] + {}.tap do |hash| + value.each do |k, v| + hash[_deserialize(k_type, k)] = _deserialize(v_type, v) + end + end + else # model + # models (e.g. Pet) or oneOf + klass = Onfido.const_get(type) + klass.respond_to?(:openapi_any_of) || klass.respond_to?(:openapi_one_of) ? klass.build(value) : klass.build_from_hash(value) + end + end + + # Returns the string representation of the object + # @return [String] String presentation of the object + def to_s + to_hash.to_s + end + + # to_body is an alias to to_hash (backward compatibility) + # @return [Hash] Returns the object in the form of hash + def to_body + to_hash + end + + # Returns the object in the form of hash + # @return [Hash] Returns the object in the form of hash + def to_hash + hash = {} + self.class.attribute_map.each_pair do |attr, param| + value = self.send(attr) + if value.nil? + is_nullable = self.class.openapi_nullable.include?(attr) + next if !is_nullable || (is_nullable && !instance_variable_defined?(:"@#{attr}")) + end + + hash[param] = _to_hash(value) + end + hash + end + + # Outputs non-array value in the form of hash + # For object, use to_hash. Otherwise, just return the value + # @param [Object] value Any valid value + # @return [Hash] Returns the value in the form of hash + def _to_hash(value) + if value.is_a?(Array) + value.compact.map { |v| _to_hash(v) } + elsif value.is_a?(Hash) + {}.tap do |hash| + value.each { |k, v| hash[k] = _to_hash(v) } + end + elsif value.respond_to? :to_hash + value.to_hash + else + value + end + end + + end + +end diff --git a/lib/onfido/models/facial_similarity_motion_report.rb b/lib/onfido/models/facial_similarity_motion_report.rb index d4e6166..1ef5ae1 100644 --- a/lib/onfido/models/facial_similarity_motion_report.rb +++ b/lib/onfido/models/facial_similarity_motion_report.rb @@ -40,6 +40,8 @@ class FacialSimilarityMotionReport attr_accessor :breakdown + attr_accessor :properties + class EnumAttributeValidator attr_reader :datatype attr_reader :allowable_values @@ -74,7 +76,8 @@ def self.attribute_map :'check_id' => :'check_id', :'documents' => :'documents', :'name' => :'name', - :'breakdown' => :'breakdown' + :'breakdown' => :'breakdown', + :'properties' => :'properties' } end @@ -95,7 +98,8 @@ def self.openapi_types :'check_id' => :'String', :'documents' => :'Array', :'name' => :'ReportName', - :'breakdown' => :'FacialSimilarityMotionBreakdown' + :'breakdown' => :'FacialSimilarityMotionBreakdown', + :'properties' => :'FacialSimilarityMotionProperties' } end @@ -172,6 +176,10 @@ def initialize(attributes = {}) if attributes.key?(:'breakdown') self.breakdown = attributes[:'breakdown'] end + + if attributes.key?(:'properties') + self.properties = attributes[:'properties'] + end end # Show invalid properties with the reasons. Usually used together with valid? @@ -213,7 +221,8 @@ def ==(o) check_id == o.check_id && documents == o.documents && name == o.name && - breakdown == o.breakdown + breakdown == o.breakdown && + properties == o.properties end # @see the `==` method @@ -225,7 +234,7 @@ def eql?(o) # Calculates hash code according to all attributes. # @return [Integer] Hash code def hash - [id, created_at, href, status, result, sub_result, check_id, documents, name, breakdown].hash + [id, created_at, href, status, result, sub_result, check_id, documents, name, breakdown, properties].hash end # Builds the object from hash diff --git a/lib/onfido/models/facial_similarity_photo_fully_auto_properties.rb b/lib/onfido/models/facial_similarity_photo_fully_auto_properties.rb new file mode 100644 index 0000000..3c3b2d3 --- /dev/null +++ b/lib/onfido/models/facial_similarity_photo_fully_auto_properties.rb @@ -0,0 +1,215 @@ +=begin +#Onfido API v3.6 + +#The Onfido API (v3.6) + +The version of the OpenAPI document: v3.6 + +Generated by: https://openapi-generator.tech +Generator version: 7.6.0 + +=end + +require 'date' +require 'time' + +module Onfido + class FacialSimilarityPhotoFullyAutoProperties + # A floating point number between 0 and 1. The closer the score is to 0, the more likely it is to be a spoof (i.e. photos of printed photos, or photos of digital screens). Conversely, the closer it is to 1, the less likely it is to be a spoof. + attr_accessor :score + + # Attribute mapping from ruby-style variable name to JSON key. + def self.attribute_map + { + :'score' => :'score' + } + end + + # Returns all the JSON keys this model knows about + def self.acceptable_attributes + attribute_map.values + end + + # Attribute type mapping. + def self.openapi_types + { + :'score' => :'Float' + } + end + + # List of attributes with nullable: true + def self.openapi_nullable + Set.new([ + ]) + end + + # Initializes the object + # @param [Hash] attributes Model attributes in the form of hash + def initialize(attributes = {}) + if (!attributes.is_a?(Hash)) + fail ArgumentError, "The input argument (attributes) must be a hash in `Onfido::FacialSimilarityPhotoFullyAutoProperties` initialize method" + end + + # check to see if the attribute exists and convert string to symbol for hash key + attributes = attributes.each_with_object({}) { |(k, v), h| + if (!self.class.attribute_map.key?(k.to_sym)) + fail ArgumentError, "`#{k}` is not a valid attribute in `Onfido::FacialSimilarityPhotoFullyAutoProperties`. Please check the name to make sure it's valid. List of attributes: " + self.class.attribute_map.keys.inspect + end + h[k.to_sym] = v + } + + if attributes.key?(:'score') + self.score = attributes[:'score'] + end + end + + # Show invalid properties with the reasons. Usually used together with valid? + # @return Array for valid properties with the reasons + def list_invalid_properties + warn '[DEPRECATED] the `list_invalid_properties` method is obsolete' + invalid_properties = Array.new + invalid_properties + end + + # Check to see if the all the properties in the model are valid + # @return true if the model is valid + def valid? + warn '[DEPRECATED] the `valid?` method is obsolete' + true + end + + # Checks equality by comparing each attribute. + # @param [Object] Object to be compared + def ==(o) + return true if self.equal?(o) + self.class == o.class && + score == o.score + end + + # @see the `==` method + # @param [Object] Object to be compared + def eql?(o) + self == o + end + + # Calculates hash code according to all attributes. + # @return [Integer] Hash code + def hash + [score].hash + end + + # Builds the object from hash + # @param [Hash] attributes Model attributes in the form of hash + # @return [Object] Returns the model itself + def self.build_from_hash(attributes) + return nil unless attributes.is_a?(Hash) + attributes = attributes.transform_keys(&:to_sym) + transformed_hash = {} + openapi_types.each_pair do |key, type| + if attributes.key?(attribute_map[key]) && attributes[attribute_map[key]].nil? + transformed_hash["#{key}"] = nil + elsif type =~ /\AArray<(.*)>/i + # check to ensure the input is an array given that the attribute + # is documented as an array but the input is not + if attributes[attribute_map[key]].is_a?(Array) + transformed_hash["#{key}"] = attributes[attribute_map[key]].map { |v| _deserialize($1, v) } + end + elsif !attributes[attribute_map[key]].nil? + transformed_hash["#{key}"] = _deserialize(type, attributes[attribute_map[key]]) + end + end + new(transformed_hash) + end + + # Deserializes the data based on type + # @param string type Data type + # @param string value Value to be deserialized + # @return [Object] Deserialized data + def self._deserialize(type, value) + case type.to_sym + when :Time + Time.parse(value) + when :Date + Date.parse(value) + when :String + value.to_s + when :Integer + value.to_i + when :Float + value.to_f + when :Boolean + if value.to_s =~ /\A(true|t|yes|y|1)\z/i + true + else + false + end + when :Object + # generic object (usually a Hash), return directly + value + when /\AArray<(?.+)>\z/ + inner_type = Regexp.last_match[:inner_type] + value.map { |v| _deserialize(inner_type, v) } + when /\AHash<(?.+?), (?.+)>\z/ + k_type = Regexp.last_match[:k_type] + v_type = Regexp.last_match[:v_type] + {}.tap do |hash| + value.each do |k, v| + hash[_deserialize(k_type, k)] = _deserialize(v_type, v) + end + end + else # model + # models (e.g. Pet) or oneOf + klass = Onfido.const_get(type) + klass.respond_to?(:openapi_any_of) || klass.respond_to?(:openapi_one_of) ? klass.build(value) : klass.build_from_hash(value) + end + end + + # Returns the string representation of the object + # @return [String] String presentation of the object + def to_s + to_hash.to_s + end + + # to_body is an alias to to_hash (backward compatibility) + # @return [Hash] Returns the object in the form of hash + def to_body + to_hash + end + + # Returns the object in the form of hash + # @return [Hash] Returns the object in the form of hash + def to_hash + hash = {} + self.class.attribute_map.each_pair do |attr, param| + value = self.send(attr) + if value.nil? + is_nullable = self.class.openapi_nullable.include?(attr) + next if !is_nullable || (is_nullable && !instance_variable_defined?(:"@#{attr}")) + end + + hash[param] = _to_hash(value) + end + hash + end + + # Outputs non-array value in the form of hash + # For object, use to_hash. Otherwise, just return the value + # @param [Object] value Any valid value + # @return [Hash] Returns the value in the form of hash + def _to_hash(value) + if value.is_a?(Array) + value.compact.map { |v| _to_hash(v) } + elsif value.is_a?(Hash) + {}.tap do |hash| + value.each { |k, v| hash[k] = _to_hash(v) } + end + elsif value.respond_to? :to_hash + value.to_hash + else + value + end + end + + end + +end diff --git a/lib/onfido/models/facial_similarity_photo_fully_auto_report.rb b/lib/onfido/models/facial_similarity_photo_fully_auto_report.rb index a285c03..831694c 100644 --- a/lib/onfido/models/facial_similarity_photo_fully_auto_report.rb +++ b/lib/onfido/models/facial_similarity_photo_fully_auto_report.rb @@ -40,6 +40,8 @@ class FacialSimilarityPhotoFullyAutoReport attr_accessor :breakdown + attr_accessor :properties + class EnumAttributeValidator attr_reader :datatype attr_reader :allowable_values @@ -74,7 +76,8 @@ def self.attribute_map :'check_id' => :'check_id', :'documents' => :'documents', :'name' => :'name', - :'breakdown' => :'breakdown' + :'breakdown' => :'breakdown', + :'properties' => :'properties' } end @@ -95,7 +98,8 @@ def self.openapi_types :'check_id' => :'String', :'documents' => :'Array', :'name' => :'ReportName', - :'breakdown' => :'FacialSimilarityPhotoFullyAutoBreakdown' + :'breakdown' => :'FacialSimilarityPhotoFullyAutoBreakdown', + :'properties' => :'FacialSimilarityPhotoFullyAutoProperties' } end @@ -172,6 +176,10 @@ def initialize(attributes = {}) if attributes.key?(:'breakdown') self.breakdown = attributes[:'breakdown'] end + + if attributes.key?(:'properties') + self.properties = attributes[:'properties'] + end end # Show invalid properties with the reasons. Usually used together with valid? @@ -213,7 +221,8 @@ def ==(o) check_id == o.check_id && documents == o.documents && name == o.name && - breakdown == o.breakdown + breakdown == o.breakdown && + properties == o.properties end # @see the `==` method @@ -225,7 +234,7 @@ def eql?(o) # Calculates hash code according to all attributes. # @return [Integer] Hash code def hash - [id, created_at, href, status, result, sub_result, check_id, documents, name, breakdown].hash + [id, created_at, href, status, result, sub_result, check_id, documents, name, breakdown, properties].hash end # Builds the object from hash diff --git a/lib/onfido/models/facial_similarity_photo_properties.rb b/lib/onfido/models/facial_similarity_photo_properties.rb new file mode 100644 index 0000000..292f98d --- /dev/null +++ b/lib/onfido/models/facial_similarity_photo_properties.rb @@ -0,0 +1,215 @@ +=begin +#Onfido API v3.6 + +#The Onfido API (v3.6) + +The version of the OpenAPI document: v3.6 + +Generated by: https://openapi-generator.tech +Generator version: 7.6.0 + +=end + +require 'date' +require 'time' + +module Onfido + class FacialSimilarityPhotoProperties + # A floating point number between 0 and 1. The closer the score is to 0, the more likely it is to be a spoof (i.e. photos of printed photos, or photos of digital screens). Conversely, the closer it is to 1, the less likely it is to be a spoof. + attr_accessor :score + + # Attribute mapping from ruby-style variable name to JSON key. + def self.attribute_map + { + :'score' => :'score' + } + end + + # Returns all the JSON keys this model knows about + def self.acceptable_attributes + attribute_map.values + end + + # Attribute type mapping. + def self.openapi_types + { + :'score' => :'Float' + } + end + + # List of attributes with nullable: true + def self.openapi_nullable + Set.new([ + ]) + end + + # Initializes the object + # @param [Hash] attributes Model attributes in the form of hash + def initialize(attributes = {}) + if (!attributes.is_a?(Hash)) + fail ArgumentError, "The input argument (attributes) must be a hash in `Onfido::FacialSimilarityPhotoProperties` initialize method" + end + + # check to see if the attribute exists and convert string to symbol for hash key + attributes = attributes.each_with_object({}) { |(k, v), h| + if (!self.class.attribute_map.key?(k.to_sym)) + fail ArgumentError, "`#{k}` is not a valid attribute in `Onfido::FacialSimilarityPhotoProperties`. Please check the name to make sure it's valid. List of attributes: " + self.class.attribute_map.keys.inspect + end + h[k.to_sym] = v + } + + if attributes.key?(:'score') + self.score = attributes[:'score'] + end + end + + # Show invalid properties with the reasons. Usually used together with valid? + # @return Array for valid properties with the reasons + def list_invalid_properties + warn '[DEPRECATED] the `list_invalid_properties` method is obsolete' + invalid_properties = Array.new + invalid_properties + end + + # Check to see if the all the properties in the model are valid + # @return true if the model is valid + def valid? + warn '[DEPRECATED] the `valid?` method is obsolete' + true + end + + # Checks equality by comparing each attribute. + # @param [Object] Object to be compared + def ==(o) + return true if self.equal?(o) + self.class == o.class && + score == o.score + end + + # @see the `==` method + # @param [Object] Object to be compared + def eql?(o) + self == o + end + + # Calculates hash code according to all attributes. + # @return [Integer] Hash code + def hash + [score].hash + end + + # Builds the object from hash + # @param [Hash] attributes Model attributes in the form of hash + # @return [Object] Returns the model itself + def self.build_from_hash(attributes) + return nil unless attributes.is_a?(Hash) + attributes = attributes.transform_keys(&:to_sym) + transformed_hash = {} + openapi_types.each_pair do |key, type| + if attributes.key?(attribute_map[key]) && attributes[attribute_map[key]].nil? + transformed_hash["#{key}"] = nil + elsif type =~ /\AArray<(.*)>/i + # check to ensure the input is an array given that the attribute + # is documented as an array but the input is not + if attributes[attribute_map[key]].is_a?(Array) + transformed_hash["#{key}"] = attributes[attribute_map[key]].map { |v| _deserialize($1, v) } + end + elsif !attributes[attribute_map[key]].nil? + transformed_hash["#{key}"] = _deserialize(type, attributes[attribute_map[key]]) + end + end + new(transformed_hash) + end + + # Deserializes the data based on type + # @param string type Data type + # @param string value Value to be deserialized + # @return [Object] Deserialized data + def self._deserialize(type, value) + case type.to_sym + when :Time + Time.parse(value) + when :Date + Date.parse(value) + when :String + value.to_s + when :Integer + value.to_i + when :Float + value.to_f + when :Boolean + if value.to_s =~ /\A(true|t|yes|y|1)\z/i + true + else + false + end + when :Object + # generic object (usually a Hash), return directly + value + when /\AArray<(?.+)>\z/ + inner_type = Regexp.last_match[:inner_type] + value.map { |v| _deserialize(inner_type, v) } + when /\AHash<(?.+?), (?.+)>\z/ + k_type = Regexp.last_match[:k_type] + v_type = Regexp.last_match[:v_type] + {}.tap do |hash| + value.each do |k, v| + hash[_deserialize(k_type, k)] = _deserialize(v_type, v) + end + end + else # model + # models (e.g. Pet) or oneOf + klass = Onfido.const_get(type) + klass.respond_to?(:openapi_any_of) || klass.respond_to?(:openapi_one_of) ? klass.build(value) : klass.build_from_hash(value) + end + end + + # Returns the string representation of the object + # @return [String] String presentation of the object + def to_s + to_hash.to_s + end + + # to_body is an alias to to_hash (backward compatibility) + # @return [Hash] Returns the object in the form of hash + def to_body + to_hash + end + + # Returns the object in the form of hash + # @return [Hash] Returns the object in the form of hash + def to_hash + hash = {} + self.class.attribute_map.each_pair do |attr, param| + value = self.send(attr) + if value.nil? + is_nullable = self.class.openapi_nullable.include?(attr) + next if !is_nullable || (is_nullable && !instance_variable_defined?(:"@#{attr}")) + end + + hash[param] = _to_hash(value) + end + hash + end + + # Outputs non-array value in the form of hash + # For object, use to_hash. Otherwise, just return the value + # @param [Object] value Any valid value + # @return [Hash] Returns the value in the form of hash + def _to_hash(value) + if value.is_a?(Array) + value.compact.map { |v| _to_hash(v) } + elsif value.is_a?(Hash) + {}.tap do |hash| + value.each { |k, v| hash[k] = _to_hash(v) } + end + elsif value.respond_to? :to_hash + value.to_hash + else + value + end + end + + end + +end diff --git a/lib/onfido/models/facial_similarity_photo_report.rb b/lib/onfido/models/facial_similarity_photo_report.rb index 3555970..c74643d 100644 --- a/lib/onfido/models/facial_similarity_photo_report.rb +++ b/lib/onfido/models/facial_similarity_photo_report.rb @@ -40,6 +40,8 @@ class FacialSimilarityPhotoReport attr_accessor :breakdown + attr_accessor :properties + class EnumAttributeValidator attr_reader :datatype attr_reader :allowable_values @@ -74,7 +76,8 @@ def self.attribute_map :'check_id' => :'check_id', :'documents' => :'documents', :'name' => :'name', - :'breakdown' => :'breakdown' + :'breakdown' => :'breakdown', + :'properties' => :'properties' } end @@ -95,7 +98,8 @@ def self.openapi_types :'check_id' => :'String', :'documents' => :'Array', :'name' => :'ReportName', - :'breakdown' => :'FacialSimilarityPhotoBreakdown' + :'breakdown' => :'FacialSimilarityPhotoBreakdown', + :'properties' => :'FacialSimilarityPhotoProperties' } end @@ -172,6 +176,10 @@ def initialize(attributes = {}) if attributes.key?(:'breakdown') self.breakdown = attributes[:'breakdown'] end + + if attributes.key?(:'properties') + self.properties = attributes[:'properties'] + end end # Show invalid properties with the reasons. Usually used together with valid? @@ -213,7 +221,8 @@ def ==(o) check_id == o.check_id && documents == o.documents && name == o.name && - breakdown == o.breakdown + breakdown == o.breakdown && + properties == o.properties end # @see the `==` method @@ -225,7 +234,7 @@ def eql?(o) # Calculates hash code according to all attributes. # @return [Integer] Hash code def hash - [id, created_at, href, status, result, sub_result, check_id, documents, name, breakdown].hash + [id, created_at, href, status, result, sub_result, check_id, documents, name, breakdown, properties].hash end # Builds the object from hash diff --git a/lib/onfido/models/facial_similarity_video_properties.rb b/lib/onfido/models/facial_similarity_video_properties.rb new file mode 100644 index 0000000..80a0afa --- /dev/null +++ b/lib/onfido/models/facial_similarity_video_properties.rb @@ -0,0 +1,215 @@ +=begin +#Onfido API v3.6 + +#The Onfido API (v3.6) + +The version of the OpenAPI document: v3.6 + +Generated by: https://openapi-generator.tech +Generator version: 7.6.0 + +=end + +require 'date' +require 'time' + +module Onfido + class FacialSimilarityVideoProperties + # A floating point number between 0 and 1. The closer the score is to 0, the more likely it is to be a spoof (i.e. videos of digital screens, masks or print-outs). Conversely, the closer it is to 1, the less likely it is to be a spoof. + attr_accessor :score + + # Attribute mapping from ruby-style variable name to JSON key. + def self.attribute_map + { + :'score' => :'score' + } + end + + # Returns all the JSON keys this model knows about + def self.acceptable_attributes + attribute_map.values + end + + # Attribute type mapping. + def self.openapi_types + { + :'score' => :'Float' + } + end + + # List of attributes with nullable: true + def self.openapi_nullable + Set.new([ + ]) + end + + # Initializes the object + # @param [Hash] attributes Model attributes in the form of hash + def initialize(attributes = {}) + if (!attributes.is_a?(Hash)) + fail ArgumentError, "The input argument (attributes) must be a hash in `Onfido::FacialSimilarityVideoProperties` initialize method" + end + + # check to see if the attribute exists and convert string to symbol for hash key + attributes = attributes.each_with_object({}) { |(k, v), h| + if (!self.class.attribute_map.key?(k.to_sym)) + fail ArgumentError, "`#{k}` is not a valid attribute in `Onfido::FacialSimilarityVideoProperties`. Please check the name to make sure it's valid. List of attributes: " + self.class.attribute_map.keys.inspect + end + h[k.to_sym] = v + } + + if attributes.key?(:'score') + self.score = attributes[:'score'] + end + end + + # Show invalid properties with the reasons. Usually used together with valid? + # @return Array for valid properties with the reasons + def list_invalid_properties + warn '[DEPRECATED] the `list_invalid_properties` method is obsolete' + invalid_properties = Array.new + invalid_properties + end + + # Check to see if the all the properties in the model are valid + # @return true if the model is valid + def valid? + warn '[DEPRECATED] the `valid?` method is obsolete' + true + end + + # Checks equality by comparing each attribute. + # @param [Object] Object to be compared + def ==(o) + return true if self.equal?(o) + self.class == o.class && + score == o.score + end + + # @see the `==` method + # @param [Object] Object to be compared + def eql?(o) + self == o + end + + # Calculates hash code according to all attributes. + # @return [Integer] Hash code + def hash + [score].hash + end + + # Builds the object from hash + # @param [Hash] attributes Model attributes in the form of hash + # @return [Object] Returns the model itself + def self.build_from_hash(attributes) + return nil unless attributes.is_a?(Hash) + attributes = attributes.transform_keys(&:to_sym) + transformed_hash = {} + openapi_types.each_pair do |key, type| + if attributes.key?(attribute_map[key]) && attributes[attribute_map[key]].nil? + transformed_hash["#{key}"] = nil + elsif type =~ /\AArray<(.*)>/i + # check to ensure the input is an array given that the attribute + # is documented as an array but the input is not + if attributes[attribute_map[key]].is_a?(Array) + transformed_hash["#{key}"] = attributes[attribute_map[key]].map { |v| _deserialize($1, v) } + end + elsif !attributes[attribute_map[key]].nil? + transformed_hash["#{key}"] = _deserialize(type, attributes[attribute_map[key]]) + end + end + new(transformed_hash) + end + + # Deserializes the data based on type + # @param string type Data type + # @param string value Value to be deserialized + # @return [Object] Deserialized data + def self._deserialize(type, value) + case type.to_sym + when :Time + Time.parse(value) + when :Date + Date.parse(value) + when :String + value.to_s + when :Integer + value.to_i + when :Float + value.to_f + when :Boolean + if value.to_s =~ /\A(true|t|yes|y|1)\z/i + true + else + false + end + when :Object + # generic object (usually a Hash), return directly + value + when /\AArray<(?.+)>\z/ + inner_type = Regexp.last_match[:inner_type] + value.map { |v| _deserialize(inner_type, v) } + when /\AHash<(?.+?), (?.+)>\z/ + k_type = Regexp.last_match[:k_type] + v_type = Regexp.last_match[:v_type] + {}.tap do |hash| + value.each do |k, v| + hash[_deserialize(k_type, k)] = _deserialize(v_type, v) + end + end + else # model + # models (e.g. Pet) or oneOf + klass = Onfido.const_get(type) + klass.respond_to?(:openapi_any_of) || klass.respond_to?(:openapi_one_of) ? klass.build(value) : klass.build_from_hash(value) + end + end + + # Returns the string representation of the object + # @return [String] String presentation of the object + def to_s + to_hash.to_s + end + + # to_body is an alias to to_hash (backward compatibility) + # @return [Hash] Returns the object in the form of hash + def to_body + to_hash + end + + # Returns the object in the form of hash + # @return [Hash] Returns the object in the form of hash + def to_hash + hash = {} + self.class.attribute_map.each_pair do |attr, param| + value = self.send(attr) + if value.nil? + is_nullable = self.class.openapi_nullable.include?(attr) + next if !is_nullable || (is_nullable && !instance_variable_defined?(:"@#{attr}")) + end + + hash[param] = _to_hash(value) + end + hash + end + + # Outputs non-array value in the form of hash + # For object, use to_hash. Otherwise, just return the value + # @param [Object] value Any valid value + # @return [Hash] Returns the value in the form of hash + def _to_hash(value) + if value.is_a?(Array) + value.compact.map { |v| _to_hash(v) } + elsif value.is_a?(Hash) + {}.tap do |hash| + value.each { |k, v| hash[k] = _to_hash(v) } + end + elsif value.respond_to? :to_hash + value.to_hash + else + value + end + end + + end + +end diff --git a/lib/onfido/models/facial_similarity_video_report.rb b/lib/onfido/models/facial_similarity_video_report.rb index a35d9a5..733c6a6 100644 --- a/lib/onfido/models/facial_similarity_video_report.rb +++ b/lib/onfido/models/facial_similarity_video_report.rb @@ -40,6 +40,8 @@ class FacialSimilarityVideoReport attr_accessor :breakdown + attr_accessor :properties + class EnumAttributeValidator attr_reader :datatype attr_reader :allowable_values @@ -74,7 +76,8 @@ def self.attribute_map :'check_id' => :'check_id', :'documents' => :'documents', :'name' => :'name', - :'breakdown' => :'breakdown' + :'breakdown' => :'breakdown', + :'properties' => :'properties' } end @@ -95,7 +98,8 @@ def self.openapi_types :'check_id' => :'String', :'documents' => :'Array', :'name' => :'ReportName', - :'breakdown' => :'FacialSimilarityVideoBreakdown' + :'breakdown' => :'FacialSimilarityVideoBreakdown', + :'properties' => :'FacialSimilarityVideoProperties' } end @@ -172,6 +176,10 @@ def initialize(attributes = {}) if attributes.key?(:'breakdown') self.breakdown = attributes[:'breakdown'] end + + if attributes.key?(:'properties') + self.properties = attributes[:'properties'] + end end # Show invalid properties with the reasons. Usually used together with valid? @@ -213,7 +221,8 @@ def ==(o) check_id == o.check_id && documents == o.documents && name == o.name && - breakdown == o.breakdown + breakdown == o.breakdown && + properties == o.properties end # @see the `==` method @@ -225,7 +234,7 @@ def eql?(o) # Calculates hash code according to all attributes. # @return [Integer] Hash code def hash - [id, created_at, href, status, result, sub_result, check_id, documents, name, breakdown].hash + [id, created_at, href, status, result, sub_result, check_id, documents, name, breakdown, properties].hash end # Builds the object from hash From f6a945b3594b77ff3e221567ce14147dcb7b97e4 Mon Sep 17 00:00:00 2001 From: Davide Vacca Date: Thu, 13 Jun 2024 18:32:43 +0200 Subject: [PATCH 2/2] Fix CHANGELOG and improve CI --- .github/workflows/ruby.yml | 34 ++++++++++++++++++++++++++++++++-- CHANGELOG.md | 5 ----- 2 files changed, 32 insertions(+), 7 deletions(-) diff --git a/.github/workflows/ruby.yml b/.github/workflows/ruby.yml index b537e6b..fb8b81e 100644 --- a/.github/workflows/ruby.yml +++ b/.github/workflows/ruby.yml @@ -28,8 +28,7 @@ jobs: bundler-cache: true - name: Run integration tests if: ${{ matrix.ruby-version == '3.2' && - github.repository_owner == 'onfido' && - github.actor != 'dependabot[bot]' }} + github.repository_owner == 'onfido' }} run: bundle exec rspec spec env: ONFIDO_API_TOKEN: ${{ secrets.ONFIDO_API_TOKEN }} @@ -42,9 +41,12 @@ jobs: publish: runs-on: ubuntu-latest needs: integration-tests + environment: delivery if: github.event_name == 'release' steps: - uses: actions/checkout@v4 + with: + token: ${{ secrets.GH_ACTION_ACCESS_TOKEN }} - name: Set up Ruby 2.7 uses: ruby/setup-ruby@v1 with: @@ -60,3 +62,31 @@ jobs: gem push *.gem env: GEM_HOST_API_KEY: "${{secrets.RUBYGEMS_AUTH_TOKEN}}" + - name: Update CHANGELOG.md + run: | + TMP_FILE=$(mktemp) + + RELEASE_VERSION=$(jq -r '.release' .release.json) + RELEASE_DATE=`date +'%dth %B %Y' | sed -E 's/^0//;s/^([2,3]?)1th/\11st/;s/^([2]?)2th/\12nd/;s/^([2]?)3th/\13rd/'` + + SPEC_COMMIT_SHA=$(jq -r '.source.short_sha' .release.json) + SPEC_COMMIT_URL=$(jq -r '.source.repo_url + "/commit/" + .source.long_sha' .release.json) + SPEC_RELEASE_VERSION=$(jq -r '.source.version' .release.json) + SPEC_RELEASE_URL=$(jq -r '.source.repo_url + "/releases/tag/" + .source.version' .release.json) + + echo -e "# Changelog\n\n## $RELEASE_VERSION $RELEASE_DATE\n\n" >| $TMP_FILE + echo -en "${{ github.event.release.body }}\nBased on Onfido OpenAPI spec " >> $TMP_FILE + + if [ -z $SPEC_RELEASE_VERSION ]; then + echo "up to commit [$SPEC_COMMIT_SHA](${SPEC_COMMIT_URL})." >> $TMP_FILE + else + echo "version [$SPEC_RELEASE_VERSION](${SPEC_RELEASE_URL})." >> $TMP_FILE + fi + + grep -v "^# Changelog" CHANGELOG.md >> $TMP_FILE + mv $TMP_FILE CHANGELOG.md + + git config user.name "GitHub Actions Bot" + git config user.email "<>" + git commit -m "Update CHANGELOG.md after library release" CHANGELOG.md + git push diff --git a/CHANGELOG.md b/CHANGELOG.md index d1ba6ec..fc71879 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,10 +1,5 @@ # Changelog -## v3.0.0 14th Jun 2024 - -- Make library auto-generated and based on [Onfido OpenAPI spec](https://github.com/onfido/onfido-openapi-spec) -- Refresh library up to commit: [169dd4d](https://github.com/onfido/onfido-openapi-spec/commit/169dd4d6598dab5d9822c9b87e7f0f16b3aef5dc) - ## v2.9.0 24 November 2023 - Added `signed_evidence_file` method for WorkflowRuns