From 5c14833e04a4ca6746cfbf7c8fb18104cc13935d Mon Sep 17 00:00:00 2001 From: Paul Cothenet Date: Thu, 15 Jul 2021 22:49:50 +0200 Subject: [PATCH 1/6] Add eth endpoint --- lib/patch_ruby/api/estimates_api.rb | 69 ++++- .../create_ethereum_estimate_request.rb | 253 ++++++++++++++++++ 2 files changed, 320 insertions(+), 2 deletions(-) create mode 100644 lib/patch_ruby/models/create_ethereum_estimate_request.rb diff --git a/lib/patch_ruby/api/estimates_api.rb b/lib/patch_ruby/api/estimates_api.rb index 829ca44..1c81b11 100644 --- a/lib/patch_ruby/api/estimates_api.rb +++ b/lib/patch_ruby/api/estimates_api.rb @@ -16,6 +16,7 @@ module Patch class EstimatesApi OPERATIONS = [ :create_bitcoin_estimate, + :create_ethereum_estimate, :create_flight_estimate, :create_mass_estimate, :create_shipping_estimate, @@ -30,7 +31,7 @@ def initialize(api_client = ApiClient.default) @api_client = api_client end # Create a bitcoin estimate given a timestamp and transaction value - # Creates a bitcoin estimate for the amount of CO2 to be compensated. An order in the `draft` state may be created based on the parameters, linked to the estimate. + # Creates a bitcoin estimate for the amount of CO2 to be compensated. An order in the `draft` state may be created based on the parameters, linked to the estimate. # @param create_bitcoin_estimate_request [CreateBitcoinEstimateRequest] # @param [Hash] opts the optional parameters # @return [EstimateResponse] @@ -40,7 +41,7 @@ def create_bitcoin_estimate(create_bitcoin_estimate_request, opts = {}) end # Create a bitcoin estimate given a timestamp and transaction value - # Creates a bitcoin estimate for the amount of CO2 to be compensated. An order in the `draft` state may be created based on the parameters, linked to the estimate. + # Creates a bitcoin estimate for the amount of CO2 to be compensated. An order in the `draft` state may be created based on the parameters, linked to the estimate. # @param create_bitcoin_estimate_request [CreateBitcoinEstimateRequest] # @param [Hash] opts the optional parameters # @return [Array<(EstimateResponse, Integer, Hash)>] EstimateResponse data, response status code and response headers @@ -93,6 +94,70 @@ def create_bitcoin_estimate_with_http_info(create_bitcoin_estimate_request, opts return data, status_code, headers end + # Create an ethereum estimate given a timestamp and gas used + # Creates an ethereum estimate for the amount of CO2 to be compensated. An order in the `draft` state may be created based on the parameters, linked to the estimate. + # @param create_ethereum_estimate_request [CreateEthereumEstimateRequest] + # @param [Hash] opts the optional parameters + # @return [EstimateResponse] + def create_ethereum_estimate(create_ethereum_estimate_request, opts = {}) + data, _status_code, _headers = create_ethereum_estimate_with_http_info(create_ethereum_estimate_request, opts) + data + end + + # Create an ethereum estimate given a timestamp and gas used + # Creates an ethereum estimate for the amount of CO2 to be compensated. An order in the `draft` state may be created based on the parameters, linked to the estimate. + # @param create_ethereum_estimate_request [CreateEthereumEstimateRequest] + # @param [Hash] opts the optional parameters + # @return [Array<(EstimateResponse, Integer, Hash)>] EstimateResponse data, response status code and response headers + def create_ethereum_estimate_with_http_info(create_ethereum_estimate_request, opts = {}) + if @api_client.config.debugging + @api_client.config.logger.debug 'Calling API: EstimatesApi.create_ethereum_estimate ...' + end + # verify the required parameter 'create_ethereum_estimate_request' is set + if @api_client.config.client_side_validation && create_ethereum_estimate_request.nil? + fail ArgumentError, "Missing the required parameter 'create_ethereum_estimate_request' when calling EstimatesApi.create_ethereum_estimate" + end + # resource path + local_var_path = '/v1/estimates/crypto/eth' + + # query parameters + query_params = opts[:query_params] || {} + + # header parameters + header_params = opts[:header_params] || {} + # HTTP header 'Accept' (if needed) + header_params['Accept'] = @api_client.select_header_accept(['application/json']) + # HTTP header 'Content-Type' + header_params['Content-Type'] = @api_client.select_header_content_type(['application/json']) + + # form parameters + form_params = opts[:form_params] || {} + + # http body (model) + post_body = opts[:body] || @api_client.object_to_http_body(create_ethereum_estimate_request) + + # return_type + return_type = opts[:return_type] || 'EstimateResponse' + + # auth_names + auth_names = opts[:auth_names] || ['bearer_auth'] + + new_options = opts.merge( + :header_params => header_params, + :query_params => query_params, + :form_params => form_params, + :body => post_body, + :auth_names => auth_names, + :return_type => return_type + ) + + data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options) + if @api_client.config.debugging + @api_client.config.logger.debug "API called: EstimatesApi#create_ethereum_estimate\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}" + end + return data, status_code, headers + end + # Create a flight estimate given the distance traveled in meters # Creates a flight estimate for the amount of CO2 to be compensated. An order in the `draft` state may be created based on the parameters, linked to the estimate. # @param create_flight_estimate_request [CreateFlightEstimateRequest] diff --git a/lib/patch_ruby/models/create_ethereum_estimate_request.rb b/lib/patch_ruby/models/create_ethereum_estimate_request.rb new file mode 100644 index 0000000..3521122 --- /dev/null +++ b/lib/patch_ruby/models/create_ethereum_estimate_request.rb @@ -0,0 +1,253 @@ +=begin +#Patch API V1 + +#The core API used to integrate with Patch's service + +The version of the OpenAPI document: v1 +Contact: developers@usepatch.com +Generated by: https://openapi-generator.tech +OpenAPI Generator version: 4.3.1 + +=end + +require 'date' + +module Patch + class CreateEthereumEstimateRequest + attr_accessor :timestamp + + attr_accessor :gas_used + + attr_accessor :project_id + + attr_accessor :create_order + + # Attribute mapping from ruby-style variable name to JSON key. + def self.attribute_map + { + :'timestamp' => :'timestamp', + :'gas_used' => :'gas_used', + :'project_id' => :'project_id', + :'create_order' => :'create_order' + } + end + + # Attribute type mapping. + def self.openapi_types + { + :'timestamp' => :'String', + :'gas_used' => :'Integer', + :'project_id' => :'String', + :'create_order' => :'Boolean' + } + end + + # Set with nullable attributes. + def self.openapi_nullable + nullable_properties = Set.new + + nullable_properties.add("timestamp") + + nullable_properties.add("gas_used") + + nullable_properties.add("project_id") + + nullable_properties.add("create_order") + + nullable_properties + end + + # Allows models with corresponding API classes to delegate API operations to those API classes + # Exposes Model.operation_id which delegates to ModelsApi.new.operation_id + # Eg. Order.create_order delegates to OrdersApi.new.create_order + def self.method_missing(message, *args, &block) + if Object.const_defined?('Patch::CreateEthereumEstimateRequestsApi::OPERATIONS') && Patch::CreateEthereumEstimateRequestsApi::OPERATIONS.include?(message) + Patch::CreateEthereumEstimateRequestsApi.new.send(message, *args) + else + super + end + 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 `Patch::CreateEthereumEstimateRequest` 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 `Patch::CreateEthereumEstimateRequest`. 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?(:'timestamp') + self.timestamp = attributes[:'timestamp'] + end + + if attributes.key?(:'gas_used') + self.gas_used = attributes[:'gas_used'] + end + + if attributes.key?(:'project_id') + self.project_id = attributes[:'project_id'] + end + + if attributes.key?(:'create_order') + self.create_order = attributes[:'create_order'] + 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 + 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? + 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 && + timestamp == o.timestamp && + gas_used == o.gas_used && + project_id == o.project_id && + create_order == o.create_order + 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 + [timestamp, gas_used, project_id, create_order].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) + new.build_from_hash(attributes) + end + + # Builds the object from hash + # @param [Hash] attributes Model attributes in the form of hash + # @return [Object] Returns the model itself + def build_from_hash(attributes) + return nil unless attributes.is_a?(Hash) + self.class.openapi_types.each_pair do |key, type| + if 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[self.class.attribute_map[key]].is_a?(Array) + self.send("#{key}=", attributes[self.class.attribute_map[key]].map { |v| _deserialize($1, v) }) + end + elsif !attributes[self.class.attribute_map[key]].nil? + self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]])) + end # or else data not found in attributes(hash), not an issue as the data can be optional + end + + self + end + + # Deserializes the data based on type + # @param string type Data type + # @param string value Value to be deserialized + # @return [Object] Deserialized data + def _deserialize(type, value) + case type.to_sym + when :DateTime + DateTime.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 + Patch.const_get(type).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 From 7f8ea24da39e6dc364353ab3a0dfd73cdce95c84 Mon Sep 17 00:00:00 2001 From: Paul Cothenet Date: Thu, 15 Jul 2021 23:31:26 +0200 Subject: [PATCH 2/6] Add ETH estimates --- CHANGELOG.md | 5 +++++ Gemfile.lock | 2 +- lib/patch_ruby/version.rb | 2 +- spec/integration/estimates_spec.rb | 20 ++++++++++++++++++++ 4 files changed, 27 insertions(+), 2 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 3d9c26f..cb20119 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -5,6 +5,11 @@ All notable changes to this project will be documented in this file. The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). +## [1.7.1] - 2021-07-16 + +### Added + +- Add support for Ethereum estimates ## [1.7.0] - 2021-07-14 ### Changed diff --git a/Gemfile.lock b/Gemfile.lock index 7b0e690..bfc2ce6 100644 --- a/Gemfile.lock +++ b/Gemfile.lock @@ -1,7 +1,7 @@ PATH remote: . specs: - patch_ruby (1.7.0) + patch_ruby (1.7.1) json (~> 2.1, >= 2.1.0) typhoeus (~> 1.0, >= 1.0.1) diff --git a/lib/patch_ruby/version.rb b/lib/patch_ruby/version.rb index f7a3ad6..cd9ccb4 100644 --- a/lib/patch_ruby/version.rb +++ b/lib/patch_ruby/version.rb @@ -11,5 +11,5 @@ =end module Patch - VERSION = '1.7.0' + VERSION = '1.7.1' end diff --git a/spec/integration/estimates_spec.rb b/spec/integration/estimates_spec.rb index 7923bdb..bbdbb26 100644 --- a/spec/integration/estimates_spec.rb +++ b/spec/integration/estimates_spec.rb @@ -99,4 +99,24 @@ expect(bitcoin_estimate.data.type).to eq 'bitcoin' expect(bitcoin_estimate.data.mass_g).to be < bitcoin_estimate_2.data.mass_g end + + it 'supports creating ethereum estimates with a gas amount' do + ethereum_estimate = Patch::Estimate.create_ethereum_estimate( + gas_used: 100 + ) + + ethereum_estimate_2 = Patch::Estimate.create_ethereum_estimate( + gas_used: 1000 + ) + + expect(ethereum_estimate.data.type).to eq 'ethereum' + expect(ethereum_estimate.data.mass_g).to be < ethereum_estimate_2.data.mass_g + end + + it 'supports creating ethereum estimates with partial information' do + ethereum_estimate = Patch::Estimate.create_ethereum_estimate({ create_order: false }) + + expect(ethereum_estimate.data.type).to eq 'ethereum' + expect(ethereum_estimate.data.mass_g).to be >= 2_000 + end end From 27305591152b2aa24b9f7fa90326dceea7db5f2a Mon Sep 17 00:00:00 2001 From: Paul Cothenet Date: Thu, 15 Jul 2021 23:38:30 +0200 Subject: [PATCH 3/6] Add require --- lib/patch_ruby.rb | 1 + 1 file changed, 1 insertion(+) diff --git a/lib/patch_ruby.rb b/lib/patch_ruby.rb index 39e1157..520e35a 100644 --- a/lib/patch_ruby.rb +++ b/lib/patch_ruby.rb @@ -19,6 +19,7 @@ # Models require 'patch_ruby/models/allocation' require 'patch_ruby/models/create_bitcoin_estimate_request' +require 'patch_ruby/models/create_ethereum_estimate_request' require 'patch_ruby/models/create_mass_estimate_request' require 'patch_ruby/models/create_order_request' require 'patch_ruby/models/create_preference_request' From a25957c3e8ab9cadfda6841aaf4eafc129dfcae6 Mon Sep 17 00:00:00 2001 From: Paul Cothenet Date: Thu, 15 Jul 2021 23:46:59 +0200 Subject: [PATCH 4/6] Update CHANGELOG.md --- CHANGELOG.md | 1 + 1 file changed, 1 insertion(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index cb20119..d56a4f1 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -10,6 +10,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 ### Added - Add support for Ethereum estimates + ## [1.7.0] - 2021-07-14 ### Changed From 432cf714eca38918947ef59c31124a102c69efd7 Mon Sep 17 00:00:00 2001 From: Paul Cothenet Date: Mon, 19 Jul 2021 22:28:14 +0200 Subject: [PATCH 5/6] Bump version --- CHANGELOG.md | 2 +- lib/patch_ruby/version.rb | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index cb20119..fb0fe65 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -5,7 +5,7 @@ All notable changes to this project will be documented in this file. The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). -## [1.7.1] - 2021-07-16 +## [1.8.0] - 2021-07-20 ### Added diff --git a/lib/patch_ruby/version.rb b/lib/patch_ruby/version.rb index cd9ccb4..b68ae7e 100644 --- a/lib/patch_ruby/version.rb +++ b/lib/patch_ruby/version.rb @@ -11,5 +11,5 @@ =end module Patch - VERSION = '1.7.1' + VERSION = '1.8.0' end From 180f6b7186a432e9b44d88d347a16882d11707e1 Mon Sep 17 00:00:00 2001 From: Paul Cothenet Date: Mon, 19 Jul 2021 22:36:16 +0200 Subject: [PATCH 6/6] Add spec for timestamp --- Gemfile.lock | 2 +- spec/integration/estimates_spec.rb | 13 +++++++++++++ 2 files changed, 14 insertions(+), 1 deletion(-) diff --git a/Gemfile.lock b/Gemfile.lock index bfc2ce6..dc279d7 100644 --- a/Gemfile.lock +++ b/Gemfile.lock @@ -1,7 +1,7 @@ PATH remote: . specs: - patch_ruby (1.7.1) + patch_ruby (1.8.0) json (~> 2.1, >= 2.1.0) typhoeus (~> 1.0, >= 1.0.1) diff --git a/spec/integration/estimates_spec.rb b/spec/integration/estimates_spec.rb index bbdbb26..49e3c70 100644 --- a/spec/integration/estimates_spec.rb +++ b/spec/integration/estimates_spec.rb @@ -100,6 +100,19 @@ expect(bitcoin_estimate.data.mass_g).to be < bitcoin_estimate_2.data.mass_g end + it 'supports creating bitcoin estimates with a timestamp' do + bitcoin_estimate_1 = Patch::Estimate.create_bitcoin_estimate( + timestamp: '2021-06-01T20:31:18.403Z' + ) + + bitcoin_estimate_2 = Patch::Estimate.create_bitcoin_estimate( + timestamp: '2021-07-01T20:31:18.403Z' + ) + + expect(bitcoin_estimate_1.data.type).to eq 'bitcoin' + expect(bitcoin_estimate_1.data.mass_g).to be > bitcoin_estimate_2.data.mass_g # Bitcoin was emitting less in July 2021 than in June + end + it 'supports creating ethereum estimates with a gas amount' do ethereum_estimate = Patch::Estimate.create_ethereum_estimate( gas_used: 100