wire4_auth 0.0.3.pre.SNAPSHOT → 1.0.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- checksums.yaml +4 -4
- data/Gemfile +1 -1
- data/Gemfile.lock +21 -2
- data/lib/wire4_auth/auth/oauth_wire4.rb +60 -15
- data/lib/wire4_auth/testing.rb +165 -62
- data/lib/wire4_auth/version.rb +1 -1
- data/wire4_auth.gemspec +3 -1
- metadata +31 -11
    
        checksums.yaml
    CHANGED
    
    | @@ -1,7 +1,7 @@ | |
| 1 1 | 
             
            ---
         | 
| 2 2 | 
             
            SHA256:
         | 
| 3 | 
            -
              metadata.gz:  | 
| 4 | 
            -
              data.tar.gz:  | 
| 3 | 
            +
              metadata.gz: 11e6f09a7250dc166b808ce1848453f257f2bff005c39d02c432b3b7c5fbde4c
         | 
| 4 | 
            +
              data.tar.gz: e245c3817860fb8fae1946af6d9125a35f3bd3e92d9eff6456965ceab5d1777e
         | 
| 5 5 | 
             
            SHA512:
         | 
| 6 | 
            -
              metadata.gz:  | 
| 7 | 
            -
              data.tar.gz:  | 
| 6 | 
            +
              metadata.gz: 9f2c8e57069f3cfa8e8f538cf1b503a259b78faa0fb902b2c38566b02ca45a7495dd04aae9c0523e7a2288e79094751651240a589ad90b029fbbc458722a7a90
         | 
| 7 | 
            +
              data.tar.gz: 2975be6c57a9ade65c5fc82d82ff8a4a38d53bdf8746ddac209ea5392f1f9f129d7cf01b385b08a39382263411c9dc87ac1359d9a8e952db6aba394fd07201a4
         | 
    
        data/Gemfile
    CHANGED
    
    
    
        data/Gemfile.lock
    CHANGED
    
    | @@ -1,14 +1,26 @@ | |
| 1 1 | 
             
            PATH
         | 
| 2 2 | 
             
              remote: .
         | 
| 3 3 | 
             
              specs:
         | 
| 4 | 
            -
                wire4_auth (0.0 | 
| 4 | 
            +
                wire4_auth (1.0.0)
         | 
| 5 5 | 
             
                  oauth2 (~> 1.4, >= 1.4.2)
         | 
| 6 | 
            +
                  wire4_client (~> 1.0.0, >= 1.0.0)
         | 
| 7 | 
            +
             | 
| 8 | 
            +
            PATH
         | 
| 9 | 
            +
              remote: /Users/saintiago/tcpip/git-repositories/speiok/wire4-api-sdk-ruby/sdk-client
         | 
| 10 | 
            +
              specs:
         | 
| 11 | 
            +
                wire4_client (1.0.0)
         | 
| 12 | 
            +
                  json (~> 2.1, >= 2.1.0)
         | 
| 13 | 
            +
                  typhoeus (~> 1.0, >= 1.0.1)
         | 
| 6 14 |  | 
| 7 15 | 
             
            GEM
         | 
| 8 16 | 
             
              remote: https://rubygems.org/
         | 
| 9 17 | 
             
              specs:
         | 
| 18 | 
            +
                ethon (0.12.0)
         | 
| 19 | 
            +
                  ffi (>= 1.3.0)
         | 
| 10 20 | 
             
                faraday (0.17.1)
         | 
| 11 21 | 
             
                  multipart-post (>= 1.2, < 3)
         | 
| 22 | 
            +
                ffi (1.12.1)
         | 
| 23 | 
            +
                json (2.3.0)
         | 
| 12 24 | 
             
                jwt (2.2.1)
         | 
| 13 25 | 
             
                multi_json (1.14.1)
         | 
| 14 26 | 
             
                multi_xml (0.6.0)
         | 
| @@ -19,14 +31,21 @@ GEM | |
| 19 31 | 
             
                  multi_json (~> 1.3)
         | 
| 20 32 | 
             
                  multi_xml (~> 0.5)
         | 
| 21 33 | 
             
                  rack (>= 1.2, < 3)
         | 
| 34 | 
            +
                power_assert (1.1.3)
         | 
| 22 35 | 
             
                rack (2.0.7)
         | 
| 36 | 
            +
                test-unit (3.3.5)
         | 
| 37 | 
            +
                  power_assert
         | 
| 38 | 
            +
                typhoeus (1.3.1)
         | 
| 39 | 
            +
                  ethon (>= 0.9.0)
         | 
| 23 40 |  | 
| 24 41 | 
             
            PLATFORMS
         | 
| 25 42 | 
             
              ruby
         | 
| 26 43 |  | 
| 27 44 | 
             
            DEPENDENCIES
         | 
| 28 45 | 
             
              oauth2 (~> 1.4.2)
         | 
| 46 | 
            +
              test-unit (~> 3.3, >= 3.3.0)
         | 
| 29 47 | 
             
              wire4_auth!
         | 
| 48 | 
            +
              wire4_client (~> 1.0.0)!
         | 
| 30 49 |  | 
| 31 50 | 
             
            BUNDLED WITH
         | 
| 32 | 
            -
               1.17. | 
| 51 | 
            +
               1.17.3
         | 
| @@ -47,15 +47,6 @@ module Wire4Auth | |
| 47 47 | 
             
                  @tokens_cached_app_user = {}
         | 
| 48 48 | 
             
                end
         | 
| 49 49 |  | 
| 50 | 
            -
                def is_expire(expires_at)
         | 
| 51 | 
            -
             | 
| 52 | 
            -
                  time = Time.at(expires_at)
         | 
| 53 | 
            -
                  # Get current time using the time zone
         | 
| 54 | 
            -
                  now = Time.now - 5 * 60 # minus 5 minutes
         | 
| 55 | 
            -
             | 
| 56 | 
            -
                  time > now
         | 
| 57 | 
            -
                end
         | 
| 58 | 
            -
             | 
| 59 50 | 
             
                def obtain_access_token_app(scope = "general")
         | 
| 60 51 |  | 
| 61 52 | 
             
                  if !@token_cached_app.access_token.nil? and !@token_cached_app.access_token.params.nil? and
         | 
| @@ -64,7 +55,7 @@ module Wire4Auth | |
| 64 55 | 
             
                      !@token_cached_app.access_token.expires_at.nil? and @token_cached_app.access_token.expires_at.is_a? Integer and
         | 
| 65 56 | 
             
                      is_expire(@token_cached_app.access_token.expires_at) and !@token_cached_app.access_token.token.nil?
         | 
| 66 57 |  | 
| 67 | 
            -
                    return @token_cached_app.access_token.token
         | 
| 58 | 
            +
                    return format_to_header(@token_cached_app.access_token.token)
         | 
| 68 59 | 
             
                  end
         | 
| 69 60 |  | 
| 70 61 | 
             
                  begin
         | 
| @@ -72,7 +63,7 @@ module Wire4Auth | |
| 72 63 | 
             
                    access_token = client.get_token({:grant_type => "client_credentials", :scope => scope})
         | 
| 73 64 | 
             
                    @token_cached_app.access_token = access_token
         | 
| 74 65 |  | 
| 75 | 
            -
                    return access_token.token
         | 
| 66 | 
            +
                    return format_to_header(access_token.token)
         | 
| 76 67 | 
             
                  rescue OAuth2::Error => e
         | 
| 77 68 | 
             
                    raise Wire4Client::ApiError.new(:code => e.code,
         | 
| 78 69 | 
             
                                       :message => e.description)
         | 
| @@ -88,7 +79,7 @@ module Wire4Auth | |
| 88 79 | 
             
                      !token_cached.access_token.expires_at.nil? and token_cached.access_token.expires_at.is_a? Integer and
         | 
| 89 80 | 
             
                      is_expire(token_cached.access_token.expires_at) and !token_cached.access_token.token.nil?
         | 
| 90 81 |  | 
| 91 | 
            -
                    return token_cached.access_token.token
         | 
| 82 | 
            +
                    return format_to_header(token_cached.access_token.token)
         | 
| 92 83 | 
             
                  end
         | 
| 93 84 |  | 
| 94 85 | 
             
                  begin
         | 
| @@ -105,20 +96,74 @@ module Wire4Auth | |
| 105 96 |  | 
| 106 97 | 
             
                    @tokens_cached_app_user[key_search] = Wire4Auth::CachedToken.new(user_key, secret_key, access_token)
         | 
| 107 98 |  | 
| 108 | 
            -
                    return access_token.token
         | 
| 99 | 
            +
                    return format_to_header(access_token.token)
         | 
| 109 100 | 
             
                  rescue OAuth2::Error => e
         | 
| 110 101 | 
             
                    raise Wire4Client::ApiError.new(:code => e.code,
         | 
| 111 102 | 
             
                                       :message => e.description)
         | 
| 112 103 | 
             
                  end
         | 
| 113 104 | 
             
                end
         | 
| 114 105 |  | 
| 115 | 
            -
                def  | 
| 106 | 
            +
                def regenerate_access_token_app(scope = "general")
         | 
| 107 | 
            +
             | 
| 108 | 
            +
                  begin
         | 
| 109 | 
            +
                    client = OAuth2::Client.new(@client_id, @client_secret, :token_url => @environment.token_url)
         | 
| 110 | 
            +
                    access_token = client.get_token({:grant_type => "client_credentials", :scope => scope})
         | 
| 111 | 
            +
                    @token_cached_app.access_token = access_token
         | 
| 112 | 
            +
             | 
| 113 | 
            +
                    return format_to_header(access_token.token)
         | 
| 114 | 
            +
                  rescue OAuth2::Error => e
         | 
| 115 | 
            +
                    raise Wire4Client::ApiError.new(:code => e.code,
         | 
| 116 | 
            +
                                                    :message => e.description)
         | 
| 117 | 
            +
                  end
         | 
| 118 | 
            +
                end
         | 
| 119 | 
            +
             | 
| 120 | 
            +
                def regenerate_access_token_app_user(user_key, secret_key, scope = "spei_admin")
         | 
| 121 | 
            +
             | 
| 122 | 
            +
                  begin
         | 
| 123 | 
            +
                    client = OAuth2::Client.new(@client_id, @client_secret, :token_url => @environment.token_url)
         | 
| 124 | 
            +
                    access_token = client.get_token({ :grant_type => "password", :scope => scope,
         | 
| 125 | 
            +
                                                      :username => user_key, :password => secret_key })
         | 
| 126 | 
            +
             | 
| 127 | 
            +
                    key_search = user_key + scope
         | 
| 128 | 
            +
                    token_cached = @tokens_cached_app_user[key_search]
         | 
| 129 | 
            +
                    if token_cached.nil? and @tokens_cached_app_user.length + 1 > MAX_APP_USER_SIZE_CACHED
         | 
| 130 | 
            +
                      @tokens_cached_app_user.each_key do |key|
         | 
| 131 | 
            +
                        @tokens_cached_app_user.delete(key)
         | 
| 132 | 
            +
                        break
         | 
| 133 | 
            +
                      end
         | 
| 134 | 
            +
                    end
         | 
| 135 | 
            +
             | 
| 136 | 
            +
                    @tokens_cached_app_user[key_search] = Wire4Auth::CachedToken.new(user_key, secret_key, access_token)
         | 
| 137 | 
            +
             | 
| 138 | 
            +
                    return format_to_header(access_token.token)
         | 
| 139 | 
            +
                  rescue OAuth2::Error => e
         | 
| 140 | 
            +
                    raise Wire4Client::ApiError.new(:code => e.code,
         | 
| 141 | 
            +
                                                    :message => e.description)
         | 
| 142 | 
            +
                  end
         | 
| 143 | 
            +
                end
         | 
| 144 | 
            +
             | 
| 145 | 
            +
                def config_default_api_client
         | 
| 116 146 | 
             
                  # Setup authorization
         | 
| 117 147 | 
             
                  Wire4Client.configure do |config|
         | 
| 118 148 | 
             
                    # Configure OAuth2 access token for authorization
         | 
| 119 | 
            -
                    config.access_token = token
         | 
| 120 149 | 
             
                    config.host = @environment.service_url
         | 
| 121 150 | 
             
                  end
         | 
| 122 151 | 
             
                end
         | 
| 152 | 
            +
             | 
| 153 | 
            +
                private
         | 
| 154 | 
            +
             | 
| 155 | 
            +
                def is_expire(expires_at)
         | 
| 156 | 
            +
             | 
| 157 | 
            +
                  time = Time.at(expires_at)
         | 
| 158 | 
            +
                  # Get current time using the time zone
         | 
| 159 | 
            +
                  now = Time.now - 5 * 60 # minus 5 minutes
         | 
| 160 | 
            +
             | 
| 161 | 
            +
                  time > now
         | 
| 162 | 
            +
                end
         | 
| 163 | 
            +
             | 
| 164 | 
            +
                def format_to_header(token)
         | 
| 165 | 
            +
             | 
| 166 | 
            +
                  "Bearer " + token
         | 
| 167 | 
            +
                end
         | 
| 123 168 | 
             
              end
         | 
| 124 169 | 
             
            end
         | 
    
        data/lib/wire4_auth/testing.rb
    CHANGED
    
    | @@ -22,6 +22,7 @@ require 'wire4_auth/auth/oauth_wire4' | |
| 22 22 | 
             
            require 'wire4_auth/webhook_verification_signature/utils_compute'
         | 
| 23 23 | 
             
            require 'wire4_client'
         | 
| 24 24 |  | 
| 25 | 
            +
            #noinspection RubyTooManyMethodsInspection
         | 
| 25 26 | 
             
            class Wire4ExamplesTest < Test::Unit::TestCase
         | 
| 26 27 |  | 
| 27 28 | 
             
              CLIENT_ID = "FxUWmqYGZuv8O1qjxstvIyJothMa"
         | 
| @@ -43,7 +44,8 @@ class Wire4ExamplesTest < Test::Unit::TestCase | |
| 43 44 |  | 
| 44 45 | 
             
                begin
         | 
| 45 46 | 
             
                  # Obtain an access token use application flow and scope "general" and add to request
         | 
| 46 | 
            -
                  oauth_wire4.config_default_api_client | 
| 47 | 
            +
                  oauth_wire4.config_default_api_client
         | 
| 48 | 
            +
                  authorization = oauth_wire4.obtain_access_token_app('general')
         | 
| 47 49 | 
             
                rescue Wire4Client::ApiError => e
         | 
| 48 50 | 
             
                  puts "Exception to obtain access token #{e}"
         | 
| 49 51 | 
             
                  # Optional manage exception in access token flow
         | 
| @@ -63,7 +65,7 @@ class Wire4ExamplesTest < Test::Unit::TestCase | |
| 63 65 |  | 
| 64 66 | 
             
                begin
         | 
| 65 67 | 
             
                  # Call the API
         | 
| 66 | 
            -
                  response = api_instance.send_contact_using_post_with_http_info(body)
         | 
| 68 | 
            +
                  response = api_instance.send_contact_using_post_with_http_info(authorization, body)
         | 
| 67 69 | 
             
                  p response
         | 
| 68 70 | 
             
                rescue Wire4Client::ApiError => e
         | 
| 69 71 | 
             
                  puts "Exception to obtain access token #{e}"
         | 
| @@ -81,7 +83,8 @@ class Wire4ExamplesTest < Test::Unit::TestCase | |
| 81 83 |  | 
| 82 84 | 
             
                begin
         | 
| 83 85 | 
             
                  # Obtain an access token use application flow and scope "general" and add to request
         | 
| 84 | 
            -
                  oauth_wire4.config_default_api_client | 
| 86 | 
            +
                  oauth_wire4.config_default_api_client
         | 
| 87 | 
            +
                  authorization = oauth_wire4.obtain_access_token_app('general')
         | 
| 85 88 | 
             
                rescue Wire4Client::ApiError => e
         | 
| 86 89 | 
             
                  puts "Exception to obtain access token #{e}"
         | 
| 87 90 | 
             
                  # Optional manage exception in access token flow
         | 
| @@ -104,7 +107,7 @@ class Wire4ExamplesTest < Test::Unit::TestCase | |
| 104 107 |  | 
| 105 108 | 
             
                begin
         | 
| 106 109 | 
             
                  # Call the API
         | 
| 107 | 
            -
                  response = api_instance.obtain_transaction_cep_using_post(cep_data)
         | 
| 110 | 
            +
                  response = api_instance.obtain_transaction_cep_using_post(authorization, cep_data)
         | 
| 108 111 | 
             
                  p response
         | 
| 109 112 | 
             
                rescue Wire4Client::ApiError => e
         | 
| 110 113 | 
             
                  puts "Exception when calling the API: #{e}"
         | 
| @@ -122,7 +125,8 @@ class Wire4ExamplesTest < Test::Unit::TestCase | |
| 122 125 |  | 
| 123 126 | 
             
                begin
         | 
| 124 127 | 
             
                  # Obtain an access token use application flow and scope "general" and add to request
         | 
| 125 | 
            -
                  oauth_wire4.config_default_api_client | 
| 128 | 
            +
                  oauth_wire4.config_default_api_client
         | 
| 129 | 
            +
                  authorization = oauth_wire4.obtain_access_token_app('general')
         | 
| 126 130 | 
             
                rescue Wire4Client::ApiError => e
         | 
| 127 131 | 
             
                  puts "Exception to obtain access token #{e}"
         | 
| 128 132 | 
             
                  # Optional manage exception in access token flow
         | 
| @@ -139,7 +143,7 @@ class Wire4ExamplesTest < Test::Unit::TestCase | |
| 139 143 |  | 
| 140 144 | 
             
                begin
         | 
| 141 145 | 
             
                  # Call the API
         | 
| 142 | 
            -
                  response = api_instance.pre_enrollment_monex_user_using_post(body)
         | 
| 146 | 
            +
                  response = api_instance.pre_enrollment_monex_user_using_post(authorization, body)
         | 
| 143 147 | 
             
                  p response
         | 
| 144 148 | 
             
                rescue Wire4Client::ApiError => e
         | 
| 145 149 | 
             
                  puts "Exception when calling the API: #{e}"
         | 
| @@ -157,7 +161,8 @@ class Wire4ExamplesTest < Test::Unit::TestCase | |
| 157 161 |  | 
| 158 162 | 
             
                begin
         | 
| 159 163 | 
             
                  # Obtain an access token use application flow and scope "general" and add to request
         | 
| 160 | 
            -
                  oauth_wire4.config_default_api_client | 
| 164 | 
            +
                  oauth_wire4.config_default_api_client
         | 
| 165 | 
            +
                  authorization = oauth_wire4.obtain_access_token_app('general')
         | 
| 161 166 | 
             
                rescue Wire4Client::ApiError => e
         | 
| 162 167 | 
             
                  puts "Exception to obtain access token #{e}"
         | 
| 163 168 | 
             
                  # Optional manage exception in access token flow
         | 
| @@ -172,7 +177,7 @@ class Wire4ExamplesTest < Test::Unit::TestCase | |
| 172 177 |  | 
| 173 178 | 
             
                begin
         | 
| 174 179 | 
             
                  # Call the API
         | 
| 175 | 
            -
                  response = api_instance.remove_subscription_pending_status_using_delete_with_http_info(subscription)
         | 
| 180 | 
            +
                  response = api_instance.remove_subscription_pending_status_using_delete_with_http_info(authorization, subscription)
         | 
| 176 181 | 
             
                  p response
         | 
| 177 182 | 
             
                rescue Wire4Client::ApiError => e
         | 
| 178 183 | 
             
                  puts "Exception when calling the API: #{e}"
         | 
| @@ -194,8 +199,9 @@ class Wire4ExamplesTest < Test::Unit::TestCase | |
| 194 199 |  | 
| 195 200 | 
             
                begin
         | 
| 196 201 | 
             
                  # Obtain an access token use application flow and scope "spei_admin" and add to request
         | 
| 197 | 
            -
                  oauth_wire4.config_default_api_client | 
| 198 | 
            -
             | 
| 202 | 
            +
                  oauth_wire4.config_default_api_client
         | 
| 203 | 
            +
                  authorization = oauth_wire4.obtain_access_token_app_user(subscription_to_remove_user_key,
         | 
| 204 | 
            +
                                                                           subscription_to_remove_user_secret, 'spei_admin')
         | 
| 199 205 | 
             
                rescue Wire4Client::ApiError => e
         | 
| 200 206 | 
             
                  puts "Exception to obtain access token #{e}"
         | 
| 201 207 | 
             
                  # Optional manage exception in access token flow
         | 
| @@ -210,7 +216,7 @@ class Wire4ExamplesTest < Test::Unit::TestCase | |
| 210 216 |  | 
| 211 217 | 
             
                begin
         | 
| 212 218 | 
             
                  # Call the API
         | 
| 213 | 
            -
                  response = api_instance.remove_enrollment_user_using_delete_with_http_info(subscription)
         | 
| 219 | 
            +
                  response = api_instance.remove_enrollment_user_using_delete_with_http_info(authorization, subscription)
         | 
| 214 220 | 
             
                  p response
         | 
| 215 221 | 
             
                rescue Wire4Client::ApiError => e
         | 
| 216 222 | 
             
                  puts "Exception when calling the API: #{e}"
         | 
| @@ -228,7 +234,8 @@ class Wire4ExamplesTest < Test::Unit::TestCase | |
| 228 234 |  | 
| 229 235 | 
             
                begin
         | 
| 230 236 | 
             
                  # Obtain an access token use application flow and scope "spei_admin" and add to request
         | 
| 231 | 
            -
                  oauth_wire4.config_default_api_client | 
| 237 | 
            +
                  oauth_wire4.config_default_api_client
         | 
| 238 | 
            +
                  authorization = oauth_wire4.obtain_access_token_app_user(USER_KEY, SECRET_KEY, 'spei_admin')
         | 
| 232 239 | 
             
                rescue Wire4Client::ApiError => e
         | 
| 233 240 | 
             
                  puts "Exception to obtain access token #{e}"
         | 
| 234 241 | 
             
                  # Optional manage exception in access token flow
         | 
| @@ -243,7 +250,7 @@ class Wire4ExamplesTest < Test::Unit::TestCase | |
| 243 250 |  | 
| 244 251 | 
             
                begin
         | 
| 245 252 | 
             
                  # Call the API
         | 
| 246 | 
            -
                  response = api_instance.get_available_relationships_monex_using_get(subscription)
         | 
| 253 | 
            +
                  response = api_instance.get_available_relationships_monex_using_get(authorization, subscription)
         | 
| 247 254 | 
             
                  p response
         | 
| 248 255 | 
             
                rescue Wire4Client::ApiError => e
         | 
| 249 256 | 
             
                  puts "Exception when calling the API: #{e}"
         | 
| @@ -262,7 +269,8 @@ class Wire4ExamplesTest < Test::Unit::TestCase | |
| 262 269 |  | 
| 263 270 | 
             
                begin
         | 
| 264 271 | 
             
                  # Obtain an access token use application flow and scope "spei_admin" and add to request
         | 
| 265 | 
            -
                  oauth_wire4.config_default_api_client | 
| 272 | 
            +
                  oauth_wire4.config_default_api_client
         | 
| 273 | 
            +
                  authorization = oauth_wire4.obtain_access_token_app_user(USER_KEY, SECRET_KEY, 'spei_admin')
         | 
| 266 274 | 
             
                rescue Wire4Client::ApiError => e
         | 
| 267 275 | 
             
                  puts "Exception to obtain access token #{e}"
         | 
| 268 276 | 
             
                  # Optional manage exception in access token flow
         | 
| @@ -295,7 +303,7 @@ class Wire4ExamplesTest < Test::Unit::TestCase | |
| 295 303 |  | 
| 296 304 | 
             
                begin
         | 
| 297 305 | 
             
                  # Call the API
         | 
| 298 | 
            -
                  response = api_instance.pre_register_accounts_using_post(body, subscription)
         | 
| 306 | 
            +
                  response = api_instance.pre_register_accounts_using_post(authorization, body, subscription)
         | 
| 299 307 | 
             
                  p response
         | 
| 300 308 | 
             
                rescue Wire4Client::ApiError => e
         | 
| 301 309 | 
             
                  puts "Exception when calling the API: #{e}"
         | 
| @@ -314,7 +322,8 @@ class Wire4ExamplesTest < Test::Unit::TestCase | |
| 314 322 |  | 
| 315 323 | 
             
                begin
         | 
| 316 324 | 
             
                  # Obtain an access token use application flow and scope "spei_admin" and add to request
         | 
| 317 | 
            -
                  oauth_wire4.config_default_api_client | 
| 325 | 
            +
                  oauth_wire4.config_default_api_client
         | 
| 326 | 
            +
                  authorization = oauth_wire4.obtain_access_token_app_user(USER_KEY, SECRET_KEY, 'spei_admin')
         | 
| 318 327 | 
             
                rescue Wire4Client::ApiError => e
         | 
| 319 328 | 
             
                  puts "Exception to obtain access token #{e}"
         | 
| 320 329 | 
             
                  # Optional manage exception in access token flow
         | 
| @@ -330,7 +339,7 @@ class Wire4ExamplesTest < Test::Unit::TestCase | |
| 330 339 |  | 
| 331 340 | 
             
                begin
         | 
| 332 341 | 
             
                  # Call the API
         | 
| 333 | 
            -
                  response = api_instance.remove_beneficiaries_pending_using_delete_with_http_info(request_id, subscription)
         | 
| 342 | 
            +
                  response = api_instance.remove_beneficiaries_pending_using_delete_with_http_info(authorization, request_id, subscription)
         | 
| 334 343 | 
             
                  p response
         | 
| 335 344 | 
             
                rescue Wire4Client::ApiError => e
         | 
| 336 345 | 
             
                  puts "Exception when calling the API: #{e}"
         | 
| @@ -348,7 +357,8 @@ class Wire4ExamplesTest < Test::Unit::TestCase | |
| 348 357 |  | 
| 349 358 | 
             
                begin
         | 
| 350 359 | 
             
                  # Obtain an access token use application flow and scope "spei_admin" and add to request
         | 
| 351 | 
            -
                  oauth_wire4.config_default_api_client | 
| 360 | 
            +
                  oauth_wire4.config_default_api_client
         | 
| 361 | 
            +
                  authorization = oauth_wire4.obtain_access_token_app_user(USER_KEY, SECRET_KEY, 'spei_admin')
         | 
| 352 362 | 
             
                rescue Wire4Client::ApiError => e
         | 
| 353 363 | 
             
                  puts "Exception to obtain access token #{e}"
         | 
| 354 364 | 
             
                  # Optional manage exception in access token flow
         | 
| @@ -364,7 +374,9 @@ class Wire4ExamplesTest < Test::Unit::TestCase | |
| 364 374 | 
             
                begin
         | 
| 365 375 | 
             
                  # Call the API
         | 
| 366 376 | 
             
                  # response = api_instance.get_beneficiaries_for_account_using_get(subscription, rfc: "RFCE010980AR3")
         | 
| 367 | 
            -
                  response = api_instance.get_beneficiaries_for_account_using_get(subscription)
         | 
| 377 | 
            +
                  # response = api_instance.get_beneficiaries_for_account_using_get(subscription, account: "RFCE010980AR3")
         | 
| 378 | 
            +
                  # response = api_instance.get_beneficiaries_for_account_using_get(subscription, rfc: "RFCE010980AR3, account: "RFCE010980AR3")
         | 
| 379 | 
            +
                  response = api_instance.get_beneficiaries_for_account_using_get(authorization, subscription)
         | 
| 368 380 | 
             
                  p response
         | 
| 369 381 | 
             
                rescue Wire4Client::ApiError => e
         | 
| 370 382 | 
             
                  puts "Exception when calling the API: #{e}"
         | 
| @@ -383,7 +395,8 @@ class Wire4ExamplesTest < Test::Unit::TestCase | |
| 383 395 |  | 
| 384 396 | 
             
                begin
         | 
| 385 397 | 
             
                  # Obtain an access token use application flow and scope "spei_admin" and add to request
         | 
| 386 | 
            -
                  oauth_wire4.config_default_api_client | 
| 398 | 
            +
                  oauth_wire4.config_default_api_client
         | 
| 399 | 
            +
                  authorization = oauth_wire4.obtain_access_token_app_user(USER_KEY, SECRET_KEY, 'spei_admin')
         | 
| 387 400 | 
             
                rescue Wire4Client::ApiError => e
         | 
| 388 401 | 
             
                  puts "Exception to obtain access token #{e}"
         | 
| 389 402 | 
             
                  # Optional manage exception in access token flow
         | 
| @@ -403,7 +416,7 @@ class Wire4ExamplesTest < Test::Unit::TestCase | |
| 403 416 |  | 
| 404 417 | 
             
                begin
         | 
| 405 418 | 
             
                  # Call the API
         | 
| 406 | 
            -
                  response = api_instance.update_amount_limit_account_using_put_with_http_info(account, body, subscription)
         | 
| 419 | 
            +
                  response = api_instance.update_amount_limit_account_using_put_with_http_info(authorization, account, body, subscription)
         | 
| 407 420 | 
             
                  p response
         | 
| 408 421 | 
             
                rescue Wire4Client::ApiError => e
         | 
| 409 422 | 
             
                  puts "Exception when calling the API: #{e}"
         | 
| @@ -420,7 +433,8 @@ class Wire4ExamplesTest < Test::Unit::TestCase | |
| 420 433 |  | 
| 421 434 | 
             
                begin
         | 
| 422 435 | 
             
                  # Obtain an access token use application flow and scope "spei_admin" and add to request
         | 
| 423 | 
            -
                  oauth_wire4.config_default_api_client | 
| 436 | 
            +
                  oauth_wire4.config_default_api_client
         | 
| 437 | 
            +
                  authorization = oauth_wire4.obtain_access_token_app_user(USER_KEY, SECRET_KEY, 'spei_admin')
         | 
| 424 438 | 
             
                rescue Wire4Client::ApiError => e
         | 
| 425 439 | 
             
                  puts "Exception to obtain access token #{e}"
         | 
| 426 440 | 
             
                  # Optional manage exception in access token flow
         | 
| @@ -436,7 +450,7 @@ class Wire4ExamplesTest < Test::Unit::TestCase | |
| 436 450 |  | 
| 437 451 | 
             
                begin
         | 
| 438 452 | 
             
                  # Call the API
         | 
| 439 | 
            -
                  response = api_instance.delete_account_using_delete_with_http_info(account, subscription)
         | 
| 453 | 
            +
                  response = api_instance.delete_account_using_delete_with_http_info(authorization, account, subscription)
         | 
| 440 454 | 
             
                  p response
         | 
| 441 455 | 
             
                rescue Wire4Client::ApiError => e
         | 
| 442 456 | 
             
                  puts "Exception when calling the API: #{e}"
         | 
| @@ -446,7 +460,7 @@ class Wire4ExamplesTest < Test::Unit::TestCase | |
| 446 460 | 
             
              end
         | 
| 447 461 |  | 
| 448 462 | 
             
              def test_obtain_institutions
         | 
| 449 | 
            -
                 | 
| 463 | 
            +
                omit('Reason')
         | 
| 450 464 | 
             
                # Create the authenticator to obtain access token
         | 
| 451 465 | 
             
                # The token URL and Service URL are defined for this environment enum value.
         | 
| 452 466 | 
             
                # e.g. for Sandbox environment: Wire4Auth::EnvironmentEnum::SANDBOX
         | 
| @@ -454,7 +468,8 @@ class Wire4ExamplesTest < Test::Unit::TestCase | |
| 454 468 |  | 
| 455 469 | 
             
                begin
         | 
| 456 470 | 
             
                  # Obtain an access token use application flow and scope "general" and add to request
         | 
| 457 | 
            -
                  oauth_wire4.config_default_api_client | 
| 471 | 
            +
                  oauth_wire4.config_default_api_client
         | 
| 472 | 
            +
                  authorization = oauth_wire4.obtain_access_token_app('general')
         | 
| 458 473 | 
             
                rescue Wire4Client::ApiError => e
         | 
| 459 474 | 
             
                  puts "Exception to obtain access token #{e}"
         | 
| 460 475 | 
             
                  # Optional manage exception in access token flow
         | 
| @@ -466,7 +481,7 @@ class Wire4ExamplesTest < Test::Unit::TestCase | |
| 466 481 |  | 
| 467 482 | 
             
                begin
         | 
| 468 483 | 
             
                  # Call the API
         | 
| 469 | 
            -
                  response = api_instance.get_all_institutions_using_get
         | 
| 484 | 
            +
                  response = api_instance.get_all_institutions_using_get(authorization)
         | 
| 470 485 | 
             
                  p response
         | 
| 471 486 | 
             
                rescue Wire4Client::ApiError => e
         | 
| 472 487 | 
             
                  puts "Exception when calling the API: #{e}"
         | 
| @@ -484,7 +499,8 @@ class Wire4ExamplesTest < Test::Unit::TestCase | |
| 484 499 |  | 
| 485 500 | 
             
                begin
         | 
| 486 501 | 
             
                  # Obtain an access token use application flow and scope "spei_admin" and add to request
         | 
| 487 | 
            -
                  oauth_wire4.config_default_api_client | 
| 502 | 
            +
                  oauth_wire4.config_default_api_client
         | 
| 503 | 
            +
                  authorization = oauth_wire4.obtain_access_token_app_user(USER_KEY, SECRET_KEY, 'spei_admin')
         | 
| 488 504 | 
             
                rescue Wire4Client::ApiError => e
         | 
| 489 505 | 
             
                  puts "Exception to obtain access token #{e}"
         | 
| 490 506 | 
             
                  # Optional manage exception in access token flow
         | 
| @@ -499,7 +515,7 @@ class Wire4ExamplesTest < Test::Unit::TestCase | |
| 499 515 |  | 
| 500 516 | 
             
                begin
         | 
| 501 517 | 
             
                  # Call the API
         | 
| 502 | 
            -
                  response = api_instance.get_balance_using_get(subscription)
         | 
| 518 | 
            +
                  response = api_instance.get_balance_using_get(authorization, subscription)
         | 
| 503 519 | 
             
                  p response
         | 
| 504 520 | 
             
                rescue Wire4Client::ApiError => e
         | 
| 505 521 | 
             
                  puts "Exception when calling the API: #{e}"
         | 
| @@ -518,7 +534,8 @@ class Wire4ExamplesTest < Test::Unit::TestCase | |
| 518 534 |  | 
| 519 535 | 
             
                begin
         | 
| 520 536 | 
             
                  # Obtain an access token use application flow and scope "spid_admin" and add to request
         | 
| 521 | 
            -
                  oauth_wire4.config_default_api_client | 
| 537 | 
            +
                  oauth_wire4.config_default_api_client
         | 
| 538 | 
            +
                  authorization = oauth_wire4.obtain_access_token_app_user(USER_KEY, SECRET_KEY, 'spid_admin')
         | 
| 522 539 | 
             
                rescue Wire4Client::ApiError => e
         | 
| 523 540 | 
             
                  puts "Exception to obtain access token #{e}"
         | 
| 524 541 | 
             
                  # Optional manage exception in access token flow
         | 
| @@ -533,7 +550,7 @@ class Wire4ExamplesTest < Test::Unit::TestCase | |
| 533 550 |  | 
| 534 551 | 
             
                begin
         | 
| 535 552 | 
             
                  # Call the API
         | 
| 536 | 
            -
                  response = api_instance.get_spid_classifications_using_get(subscription)
         | 
| 553 | 
            +
                  response = api_instance.get_spid_classifications_using_get(authorization, subscription)
         | 
| 537 554 | 
             
                  p response
         | 
| 538 555 | 
             
                rescue Wire4Client::ApiError => e
         | 
| 539 556 | 
             
                  puts "Exception when calling the API: #{e}"
         | 
| @@ -552,7 +569,8 @@ class Wire4ExamplesTest < Test::Unit::TestCase | |
| 552 569 |  | 
| 553 570 | 
             
                begin
         | 
| 554 571 | 
             
                  # Obtain an access token use application flow and scope "spid_admin" and add to request
         | 
| 555 | 
            -
                  oauth_wire4.config_default_api_client | 
| 572 | 
            +
                  oauth_wire4.config_default_api_client
         | 
| 573 | 
            +
                  authorization = oauth_wire4.obtain_access_token_app_user(USER_KEY, SECRET_KEY, 'spid_admin')
         | 
| 556 574 | 
             
                rescue Wire4Client::ApiError => e
         | 
| 557 575 | 
             
                  puts "Exception to obtain access token #{e}"
         | 
| 558 576 | 
             
                  # Optional manage exception in access token flow
         | 
| @@ -579,7 +597,44 @@ class Wire4ExamplesTest < Test::Unit::TestCase | |
| 579 597 |  | 
| 580 598 | 
             
                begin
         | 
| 581 599 | 
             
                  # Call the API
         | 
| 582 | 
            -
                  response = api_instance.pre_register_accounts_using_post1(body, subscription)
         | 
| 600 | 
            +
                  response = api_instance.pre_register_accounts_using_post1(authorization, body, subscription)
         | 
| 601 | 
            +
                  p response
         | 
| 602 | 
            +
                rescue Wire4Client::ApiError => e
         | 
| 603 | 
            +
                  puts "Exception when calling the API: #{e}"
         | 
| 604 | 
            +
                  # Optional manage exception in call API
         | 
| 605 | 
            +
                  return
         | 
| 606 | 
            +
                end
         | 
| 607 | 
            +
              end
         | 
| 608 | 
            +
             | 
| 609 | 
            +
              def test_obtain_beneficiaries_spid
         | 
| 610 | 
            +
                omit('Reason')
         | 
| 611 | 
            +
                # Create the authenticator to obtain access token
         | 
| 612 | 
            +
                # The token URL and Service URL are defined for this environment enum value.
         | 
| 613 | 
            +
                # e.g. for Sandbox environment: Wire4Auth::EnvironmentEnum::SANDBOX
         | 
| 614 | 
            +
                oauth_wire4 = Wire4Auth::OAuthWire4.new(CLIENT_ID, CLIENT_SECRET, Wire4Auth::EnvironmentEnum::SANDBOX)
         | 
| 615 | 
            +
             | 
| 616 | 
            +
                begin
         | 
| 617 | 
            +
                  # Obtain an access token use application flow and scope "spei_admin" and add to request
         | 
| 618 | 
            +
                  oauth_wire4.config_default_api_client
         | 
| 619 | 
            +
                  authorization = oauth_wire4.obtain_access_token_app_user(USER_KEY, SECRET_KEY, 'spid_admin')
         | 
| 620 | 
            +
                rescue Wire4Client::ApiError => e
         | 
| 621 | 
            +
                  puts "Exception to obtain access token #{e}"
         | 
| 622 | 
            +
                  # Optional manage exception in access token flow
         | 
| 623 | 
            +
                  return
         | 
| 624 | 
            +
                end
         | 
| 625 | 
            +
             | 
| 626 | 
            +
                # create an instance of the API class
         | 
| 627 | 
            +
                api_instance = Wire4Client::CuentasDeBeneficiariosSPIDApi.new
         | 
| 628 | 
            +
             | 
| 629 | 
            +
                # build body with info (check references for more info: types, required fields, etc.)
         | 
| 630 | 
            +
                subscription = SUBSCRIPTION
         | 
| 631 | 
            +
             | 
| 632 | 
            +
                begin
         | 
| 633 | 
            +
                  # Call the API
         | 
| 634 | 
            +
                  # response = api_instance.get_beneficiaries_for_account_using_get(subscription, rfc: "RFCE010980AR3")
         | 
| 635 | 
            +
                  # response = api_instance.get_beneficiaries_for_account_using_get(subscription, account: "RFCE010980AR3")
         | 
| 636 | 
            +
                  # response = api_instance.get_beneficiaries_for_account_using_get(subscription, rfc: "RFCE010980AR3, account: "RFCE010980AR3")
         | 
| 637 | 
            +
                  response = api_instance.get_spid_beneficiaries_for_account(authorization, subscription)
         | 
| 583 638 | 
             
                  p response
         | 
| 584 639 | 
             
                rescue Wire4Client::ApiError => e
         | 
| 585 640 | 
             
                  puts "Exception when calling the API: #{e}"
         | 
| @@ -597,7 +652,8 @@ class Wire4ExamplesTest < Test::Unit::TestCase | |
| 597 652 |  | 
| 598 653 | 
             
                begin
         | 
| 599 654 | 
             
                  # Obtain an access token use application flow and scope "spei_admin" and add to request
         | 
| 600 | 
            -
                  oauth_wire4.config_default_api_client | 
| 655 | 
            +
                  oauth_wire4.config_default_api_client
         | 
| 656 | 
            +
                  authorization = oauth_wire4.obtain_access_token_app_user(USER_KEY, SECRET_KEY, 'spei_admin')
         | 
| 601 657 | 
             
                rescue Wire4Client::ApiError => e
         | 
| 602 658 | 
             
                  puts "Exception to obtain access token #{e}"
         | 
| 603 659 | 
             
                  # Optional manage exception in access token flow
         | 
| @@ -612,7 +668,7 @@ class Wire4ExamplesTest < Test::Unit::TestCase | |
| 612 668 |  | 
| 613 669 | 
             
                begin
         | 
| 614 670 | 
             
                  # Call the API
         | 
| 615 | 
            -
                  response = api_instance.get_depositants_using_get(subscription)
         | 
| 671 | 
            +
                  response = api_instance.get_depositants_using_get(authorization, subscription)
         | 
| 616 672 | 
             
                  p response
         | 
| 617 673 | 
             
                rescue Wire4Client::ApiError => e
         | 
| 618 674 | 
             
                  puts "Exception when calling the API: #{e}"
         | 
| @@ -630,7 +686,8 @@ class Wire4ExamplesTest < Test::Unit::TestCase | |
| 630 686 |  | 
| 631 687 | 
             
                begin
         | 
| 632 688 | 
             
                  # Obtain an access token use application flow and scope "spei_admin" and add to request
         | 
| 633 | 
            -
                  oauth_wire4.config_default_api_client | 
| 689 | 
            +
                  oauth_wire4.config_default_api_client
         | 
| 690 | 
            +
                  authorization = oauth_wire4.obtain_access_token_app_user(USER_KEY, SECRET_KEY, 'spei_admin')
         | 
| 634 691 | 
             
                rescue Wire4Client::ApiError => e
         | 
| 635 692 | 
             
                  puts "Exception to obtain access token #{e}"
         | 
| 636 693 | 
             
                  # Optional manage exception in access token flow
         | 
| @@ -650,7 +707,7 @@ class Wire4ExamplesTest < Test::Unit::TestCase | |
| 650 707 |  | 
| 651 708 | 
             
                begin
         | 
| 652 709 | 
             
                  # Call the API
         | 
| 653 | 
            -
                  response = api_instance.register_depositants_using_post(body, subscription)
         | 
| 710 | 
            +
                  response = api_instance.register_depositants_using_post(authorization, body, subscription)
         | 
| 654 711 | 
             
                  p response
         | 
| 655 712 | 
             
                rescue Wire4Client::ApiError => e
         | 
| 656 713 | 
             
                  puts "Exception when calling the API: #{e}"
         | 
| @@ -669,7 +726,8 @@ class Wire4ExamplesTest < Test::Unit::TestCase | |
| 669 726 |  | 
| 670 727 | 
             
                begin
         | 
| 671 728 | 
             
                  # Obtain an access token use application flow and scope "spei_admin" and add to request
         | 
| 672 | 
            -
                  oauth_wire4.config_default_api_client | 
| 729 | 
            +
                  oauth_wire4.config_default_api_client
         | 
| 730 | 
            +
                  authorization = oauth_wire4.obtain_access_token_app_user(USER_KEY, SECRET_KEY, 'spei_admin')
         | 
| 673 731 | 
             
                rescue Wire4Client::ApiError => e
         | 
| 674 732 | 
             
                  puts "Exception to obtain access token #{e}"
         | 
| 675 733 | 
             
                  # Optional manage exception in access token flow
         | 
| @@ -684,7 +742,7 @@ class Wire4ExamplesTest < Test::Unit::TestCase | |
| 684 742 |  | 
| 685 743 | 
             
                begin
         | 
| 686 744 | 
             
                  # Call the API
         | 
| 687 | 
            -
                  response = api_instance.incoming_spei_transactions_report_using_get(subscription)
         | 
| 745 | 
            +
                  response = api_instance.incoming_spei_transactions_report_using_get(authorization, subscription)
         | 
| 688 746 | 
             
                  p response
         | 
| 689 747 | 
             
                rescue Wire4Client::ApiError => e
         | 
| 690 748 | 
             
                  puts "Exception when calling the API: #{e}"
         | 
| @@ -703,7 +761,8 @@ class Wire4ExamplesTest < Test::Unit::TestCase | |
| 703 761 |  | 
| 704 762 | 
             
                begin
         | 
| 705 763 | 
             
                  # Obtain an access token use application flow and scope "spei_admin" and add to request
         | 
| 706 | 
            -
                  oauth_wire4.config_default_api_client | 
| 764 | 
            +
                  oauth_wire4.config_default_api_client
         | 
| 765 | 
            +
                  authorization = oauth_wire4.obtain_access_token_app_user(USER_KEY, SECRET_KEY, 'spei_admin')
         | 
| 707 766 | 
             
                rescue Wire4Client::ApiError => e
         | 
| 708 767 | 
             
                  puts "Exception to obtain access token #{e}"
         | 
| 709 768 | 
             
                  # Optional manage exception in access token flow
         | 
| @@ -718,7 +777,7 @@ class Wire4ExamplesTest < Test::Unit::TestCase | |
| 718 777 |  | 
| 719 778 | 
             
                begin
         | 
| 720 779 | 
             
                  # Call the API
         | 
| 721 | 
            -
                  response = api_instance.outgoing_spei_transactions_report_using_get(subscription)
         | 
| 780 | 
            +
                  response = api_instance.outgoing_spei_transactions_report_using_get(authorization, subscription)
         | 
| 722 781 | 
             
                  p response
         | 
| 723 782 | 
             
                rescue Wire4Client::ApiError => e
         | 
| 724 783 | 
             
                  puts "Exception when calling the API: #{e}"
         | 
| @@ -727,6 +786,42 @@ class Wire4ExamplesTest < Test::Unit::TestCase | |
| 727 786 | 
             
                end
         | 
| 728 787 | 
             
              end
         | 
| 729 788 |  | 
| 789 | 
            +
              #noinspection RubyInstanceMethodNamingConvention
         | 
| 790 | 
            +
              def test_out_comming_spei_request_id_transactions_report_using_get
         | 
| 791 | 
            +
                omit('Reason')
         | 
| 792 | 
            +
                # Create the authenticator to obtain access token
         | 
| 793 | 
            +
                # The token URL and Service URL are defined for this environment enum value.
         | 
| 794 | 
            +
                # e.g. for Sandbox environment: Wire4Auth::EnvironmentEnum::SANDBOX
         | 
| 795 | 
            +
                oauth_wire4 = Wire4Auth::OAuthWire4.new(CLIENT_ID, CLIENT_SECRET, Wire4Auth::EnvironmentEnum::SANDBOX)
         | 
| 796 | 
            +
             | 
| 797 | 
            +
                begin
         | 
| 798 | 
            +
                  # Obtain an access token use application flow and scope "spei_admin" and add to request
         | 
| 799 | 
            +
                  oauth_wire4.config_default_api_client
         | 
| 800 | 
            +
                  authorization = oauth_wire4.obtain_access_token_app_user(USER_KEY, SECRET_KEY, 'spei_admin')
         | 
| 801 | 
            +
                rescue Wire4Client::ApiError => e
         | 
| 802 | 
            +
                  puts "Exception to obtain access token #{e}"
         | 
| 803 | 
            +
                  # Optional manage exception in access token flow
         | 
| 804 | 
            +
                  return
         | 
| 805 | 
            +
                end
         | 
| 806 | 
            +
             | 
| 807 | 
            +
                # create an instance of the API class
         | 
| 808 | 
            +
                api_instance = Wire4Client::TransferenciasSPEIApi.new
         | 
| 809 | 
            +
             | 
| 810 | 
            +
                # build body with info (check references for more info: types, required fields, etc.)
         | 
| 811 | 
            +
                subscription = SUBSCRIPTION
         | 
| 812 | 
            +
                request_id = '6a9efe39-a795-4e09-8f7f-197e647a0f8b'
         | 
| 813 | 
            +
             | 
| 814 | 
            +
                begin
         | 
| 815 | 
            +
                  # Call the API
         | 
| 816 | 
            +
                  response = api_instance.out_comming_spei_request_id_transactions_report_using_get(authorization, request_id, subscription)
         | 
| 817 | 
            +
                  p response
         | 
| 818 | 
            +
                rescue Wire4Client::ApiError => e
         | 
| 819 | 
            +
                  puts "Exception when calling TransferenciasSPEIApi->out_comming_spei_request_id_transactions_report_using_get: #{e}"
         | 
| 820 | 
            +
                  # Optional manage exception in call API
         | 
| 821 | 
            +
                  return
         | 
| 822 | 
            +
                end
         | 
| 823 | 
            +
              end
         | 
| 824 | 
            +
             | 
| 730 825 | 
             
              #noinspection RubyInstanceMethodNamingConvention
         | 
| 731 826 | 
             
              def test_register_outgoing_SPEI_transaction
         | 
| 732 827 | 
             
                omit('Reason')
         | 
| @@ -737,7 +832,8 @@ class Wire4ExamplesTest < Test::Unit::TestCase | |
| 737 832 |  | 
| 738 833 | 
             
                begin
         | 
| 739 834 | 
             
                  # Obtain an access token use application flow and scope "spei_admin" and add to request
         | 
| 740 | 
            -
                  oauth_wire4.config_default_api_client | 
| 835 | 
            +
                  oauth_wire4.config_default_api_client
         | 
| 836 | 
            +
                  authorization = oauth_wire4.obtain_access_token_app_user(USER_KEY, SECRET_KEY, 'spei_admin')
         | 
| 741 837 | 
             
                rescue Wire4Client::ApiError => e
         | 
| 742 838 | 
             
                  puts "Exception to obtain access token #{e}"
         | 
| 743 839 | 
             
                  # Optional manage exception in access token flow
         | 
| @@ -764,7 +860,7 @@ class Wire4ExamplesTest < Test::Unit::TestCase | |
| 764 860 |  | 
| 765 861 | 
             
                begin
         | 
| 766 862 | 
             
                  # Call the API
         | 
| 767 | 
            -
                  response = api_instance.register_outgoing_spei_transaction_using_post(subscription, body)
         | 
| 863 | 
            +
                  response = api_instance.register_outgoing_spei_transaction_using_post(authorization, subscription, body)
         | 
| 768 864 | 
             
                  p response
         | 
| 769 865 | 
             
                rescue Wire4Client::ApiError => e
         | 
| 770 866 | 
             
                  puts "Exception when calling the API: #{e}"
         | 
| @@ -775,7 +871,7 @@ class Wire4ExamplesTest < Test::Unit::TestCase | |
| 775 871 |  | 
| 776 872 | 
             
              #noinspection RubyInstanceMethodNamingConvention
         | 
| 777 873 | 
             
              def test_delete_outgoing_pending_SPEI_transaction
         | 
| 778 | 
            -
                 | 
| 874 | 
            +
                omit('Reason')
         | 
| 779 875 | 
             
                # Create the authenticator to obtain access token
         | 
| 780 876 | 
             
                # The token URL and Service URL are defined for this environment enum value.
         | 
| 781 877 | 
             
                # e.g. for Sandbox environment: Wire4Auth::EnvironmentEnum::SANDBOX
         | 
| @@ -783,7 +879,8 @@ class Wire4ExamplesTest < Test::Unit::TestCase | |
| 783 879 |  | 
| 784 880 | 
             
                begin
         | 
| 785 881 | 
             
                  # Obtain an access token use application flow and scope "spei_admin" and add to request
         | 
| 786 | 
            -
                  oauth_wire4.config_default_api_client | 
| 882 | 
            +
                  oauth_wire4.config_default_api_client
         | 
| 883 | 
            +
                  authorization = oauth_wire4.obtain_access_token_app_user(USER_KEY, SECRET_KEY, 'spei_admin')
         | 
| 787 884 | 
             
                rescue Wire4Client::ApiError => e
         | 
| 788 885 | 
             
                  puts "Exception to obtain access token #{e}"
         | 
| 789 886 | 
             
                  # Optional manage exception in access token flow
         | 
| @@ -799,7 +896,7 @@ class Wire4ExamplesTest < Test::Unit::TestCase | |
| 799 896 |  | 
| 800 897 | 
             
                begin
         | 
| 801 898 | 
             
                  # Call the API
         | 
| 802 | 
            -
                  response = api_instance.drop_transactions_pending_using_delete_with_http_info(request_id, subscription)
         | 
| 899 | 
            +
                  response = api_instance.drop_transactions_pending_using_delete_with_http_info(authorization, request_id, subscription)
         | 
| 803 900 | 
             
                  p response
         | 
| 804 901 | 
             
                rescue Wire4Client::ApiError => e
         | 
| 805 902 | 
             
                  puts "Exception when calling the API: #{e}"
         | 
| @@ -818,7 +915,8 @@ class Wire4ExamplesTest < Test::Unit::TestCase | |
| 818 915 |  | 
| 819 916 | 
             
                begin
         | 
| 820 917 | 
             
                  # Obtain an access token use application flow and scope "spid_admin" and add to request
         | 
| 821 | 
            -
                  oauth_wire4.config_default_api_client | 
| 918 | 
            +
                  oauth_wire4.config_default_api_client
         | 
| 919 | 
            +
                  authorization = oauth_wire4.obtain_access_token_app_user(USER_KEY, SECRET_KEY, 'spid_admin')
         | 
| 822 920 | 
             
                rescue Wire4Client::ApiError => e
         | 
| 823 921 | 
             
                  puts "Exception to obtain access token #{e}"
         | 
| 824 922 | 
             
                  # Optional manage exception in access token flow
         | 
| @@ -844,7 +942,7 @@ class Wire4ExamplesTest < Test::Unit::TestCase | |
| 844 942 |  | 
| 845 943 | 
             
                begin
         | 
| 846 944 | 
             
                  # Call the API
         | 
| 847 | 
            -
                  response = api_instance.register_outgoing_spid_transaction_using_post(subscription, body)
         | 
| 945 | 
            +
                  response = api_instance.register_outgoing_spid_transaction_using_post(authorization, subscription, body)
         | 
| 848 946 | 
             
                  p response
         | 
| 849 947 | 
             
                rescue Wire4Client::ApiError => e
         | 
| 850 948 | 
             
                  puts "Exception when calling the API: #{e}"
         | 
| @@ -854,7 +952,7 @@ class Wire4ExamplesTest < Test::Unit::TestCase | |
| 854 952 | 
             
              end
         | 
| 855 953 |  | 
| 856 954 | 
             
              def test_register_web_hook
         | 
| 857 | 
            -
                 | 
| 955 | 
            +
                omit('Reason')
         | 
| 858 956 | 
             
                # Create the authenticator to obtain access token
         | 
| 859 957 | 
             
                # The token URL and Service URL are defined for this environment enum value.
         | 
| 860 958 | 
             
                # e.g. for Sandbox environment: Wire4Auth::EnvironmentEnum::SANDBOX
         | 
| @@ -862,7 +960,8 @@ class Wire4ExamplesTest < Test::Unit::TestCase | |
| 862 960 |  | 
| 863 961 | 
             
                begin
         | 
| 864 962 | 
             
                  # Obtain an access token use application flow and scope "general" and add to request
         | 
| 865 | 
            -
                  oauth_wire4.config_default_api_client | 
| 963 | 
            +
                  oauth_wire4.config_default_api_client
         | 
| 964 | 
            +
                  authorization = oauth_wire4.obtain_access_token_app('general')
         | 
| 866 965 | 
             
                rescue Wire4Client::ApiError => e
         | 
| 867 966 | 
             
                  puts "Exception to obtain access token #{e}"
         | 
| 868 967 | 
             
                  # Optional manage exception in access token flow
         | 
| @@ -880,7 +979,7 @@ class Wire4ExamplesTest < Test::Unit::TestCase | |
| 880 979 |  | 
| 881 980 | 
             
                begin
         | 
| 882 981 | 
             
                  # Call the API
         | 
| 883 | 
            -
                  response = api_instance.register_webhook(body)
         | 
| 982 | 
            +
                  response = api_instance.register_webhook(authorization, body)
         | 
| 884 983 | 
             
                  p response
         | 
| 885 984 | 
             
                rescue Wire4Client::ApiError => e
         | 
| 886 985 | 
             
                  puts "Exception when calling the API: #{e}"
         | 
| @@ -898,7 +997,8 @@ class Wire4ExamplesTest < Test::Unit::TestCase | |
| 898 997 |  | 
| 899 998 | 
             
                begin
         | 
| 900 999 | 
             
                  # Obtain an access token use application flow and scope "general" and add to request
         | 
| 901 | 
            -
                  oauth_wire4.config_default_api_client | 
| 1000 | 
            +
                  oauth_wire4.config_default_api_client
         | 
| 1001 | 
            +
                  authorization = oauth_wire4.obtain_access_token_app('general')
         | 
| 902 1002 | 
             
                rescue Wire4Client::ApiError => e
         | 
| 903 1003 | 
             
                  puts "Exception to obtain access token #{e}"
         | 
| 904 1004 | 
             
                  # Optional manage exception in access token flow
         | 
| @@ -910,7 +1010,7 @@ class Wire4ExamplesTest < Test::Unit::TestCase | |
| 910 1010 |  | 
| 911 1011 | 
             
                begin
         | 
| 912 1012 | 
             
                  # Call the API
         | 
| 913 | 
            -
                  response = api_instance.get_webhooks
         | 
| 1013 | 
            +
                  response = api_instance.get_webhooks(authorization)
         | 
| 914 1014 | 
             
                  p response
         | 
| 915 1015 | 
             
                rescue Wire4Client::ApiError => e
         | 
| 916 1016 | 
             
                  puts "Exception when calling the API: #{e}"
         | 
| @@ -928,7 +1028,8 @@ class Wire4ExamplesTest < Test::Unit::TestCase | |
| 928 1028 |  | 
| 929 1029 | 
             
                begin
         | 
| 930 1030 | 
             
                  # Obtain an access token use application flow and scope "general" and add to request
         | 
| 931 | 
            -
                  oauth_wire4.config_default_api_client | 
| 1031 | 
            +
                  oauth_wire4.config_default_api_client
         | 
| 1032 | 
            +
                  authorization = oauth_wire4.obtain_access_token_app('general')
         | 
| 932 1033 | 
             
                rescue Wire4Client::ApiError => e
         | 
| 933 1034 | 
             
                  puts "Exception to obtain access token #{e}"
         | 
| 934 1035 | 
             
                  # Optional manage exception in access token flow
         | 
| @@ -940,7 +1041,7 @@ class Wire4ExamplesTest < Test::Unit::TestCase | |
| 940 1041 |  | 
| 941 1042 | 
             
                begin
         | 
| 942 1043 | 
             
                  # Call the API
         | 
| 943 | 
            -
                  response = api_instance.get_webhook("wh_3fe3e5f4849f4cabb147804fd55c86fc")
         | 
| 1044 | 
            +
                  response = api_instance.get_webhook(authorization, "wh_3fe3e5f4849f4cabb147804fd55c86fc")
         | 
| 944 1045 | 
             
                  p response
         | 
| 945 1046 | 
             
                rescue Wire4Client::ApiError => e
         | 
| 946 1047 | 
             
                  puts "Exception when calling the API: #{e}"
         | 
| @@ -961,7 +1062,8 @@ class Wire4ExamplesTest < Test::Unit::TestCase | |
| 961 1062 |  | 
| 962 1063 | 
             
                begin
         | 
| 963 1064 | 
             
                  # Obtain an access token use application flow and scope "general" and add to request
         | 
| 964 | 
            -
                  oauth_wire4.config_default_api_client | 
| 1065 | 
            +
                  oauth_wire4.config_default_api_client
         | 
| 1066 | 
            +
                  authorization = oauth_wire4.obtain_access_token_app('general')
         | 
| 965 1067 | 
             
                rescue Wire4Client::ApiError => e
         | 
| 966 1068 | 
             
                  puts "Exception to obtain access token #{e}"
         | 
| 967 1069 | 
             
                  # Optional manage exception in access token flow
         | 
| @@ -973,7 +1075,7 @@ class Wire4ExamplesTest < Test::Unit::TestCase | |
| 973 1075 |  | 
| 974 1076 | 
             
                begin
         | 
| 975 1077 | 
             
                  # Call the API
         | 
| 976 | 
            -
                  response = api_instance.billings_report_using_get(period: "2019-10")
         | 
| 1078 | 
            +
                  response = api_instance.billings_report_using_get(authorization, period: "2019-10")
         | 
| 977 1079 | 
             
                  p response
         | 
| 978 1080 | 
             
                rescue Wire4Client::ApiError => e
         | 
| 979 1081 | 
             
                  puts "Exception when calling the API: #{e}"
         | 
| @@ -988,13 +1090,14 @@ class Wire4ExamplesTest < Test::Unit::TestCase | |
| 988 1090 | 
             
                # The token URL and Service URL are defined for this environment enum value.
         | 
| 989 1091 | 
             
                # e.g. for Sandbox environment: Wire4Auth::EnvironmentEnum::SANDBOX
         | 
| 990 1092 |  | 
| 991 | 
            -
                 | 
| 992 | 
            -
                oauth_wire4 = Wire4Auth::OAuthWire4.new("kIinyEIYWUIF3pflFxhRdKft2_ga",
         | 
| 993 | 
            -
             | 
| 1093 | 
            +
                oauth_wire4 = Wire4Auth::OAuthWire4.new(CLIENT_ID, CLIENT_SECRET, Wire4Auth::EnvironmentEnum::SANDBOX)
         | 
| 1094 | 
            +
                #oauth_wire4 = Wire4Auth::OAuthWire4.new("kIinyEIYWUIF3pflFxhRdKft2_ga",
         | 
| 1095 | 
            +
                #                                        "gca6FwUE_9Dk23UhWoM81pZkNgEa", Wire4Auth::EnvironmentEnum::DEVELOPMENT)
         | 
| 994 1096 |  | 
| 995 1097 | 
             
                begin
         | 
| 996 1098 | 
             
                  # Obtain an access token use application flow and scope "general" and add to request
         | 
| 997 | 
            -
                  oauth_wire4.config_default_api_client | 
| 1099 | 
            +
                  oauth_wire4.config_default_api_client
         | 
| 1100 | 
            +
                  authorization = oauth_wire4.obtain_access_token_app('general')
         | 
| 998 1101 | 
             
                rescue Wire4Client::ApiError => e
         | 
| 999 1102 | 
             
                  puts "Exception to obtain access token #{e}"
         | 
| 1000 1103 | 
             
                  # Optional manage exception in access token flow
         | 
| @@ -1006,7 +1109,7 @@ class Wire4ExamplesTest < Test::Unit::TestCase | |
| 1006 1109 |  | 
| 1007 1110 | 
             
                begin
         | 
| 1008 1111 | 
             
                  # Call the API
         | 
| 1009 | 
            -
                  response = api_instance.billings_report_by_id_using_get("834BA74A-BBBB-43C4-8400-A4528153C2BD")
         | 
| 1112 | 
            +
                  response = api_instance.billings_report_by_id_using_get(authorization, "834BA74A-BBBB-43C4-8400-A4528153C2BD")
         | 
| 1010 1113 | 
             
                  p response
         | 
| 1011 1114 | 
             
                rescue Wire4Client::ApiError => e
         | 
| 1012 1115 | 
             
                  puts "Exception when calling the API: #{e}"
         | 
| @@ -1017,9 +1120,9 @@ class Wire4ExamplesTest < Test::Unit::TestCase | |
| 1017 1120 |  | 
| 1018 1121 | 
             
              def test_check_web_hook_sign
         | 
| 1019 1122 |  | 
| 1123 | 
            +
                omit('Reason')
         | 
| 1020 1124 | 
             
                puts `cd .. && cd .. && find *`.split("\n").uniq.sort.select { |f| !f.empty? }
         | 
| 1021 1125 |  | 
| 1022 | 
            -
                omit('Reason')
         | 
| 1023 1126 | 
             
                payload = "{ \"responseCode\":0, \n" + \
         | 
| 1024 1127 | 
             
                          "  \"message\":\"Ya existe este beneficiario de pago a ctas nacionales en el contrato\",\n" + \
         | 
| 1025 1128 | 
             
                          "  \"statusCode\":\"ERROR\",\n" + \
         | 
    
        data/lib/wire4_auth/version.rb
    CHANGED
    
    
    
        data/wire4_auth.gemspec
    CHANGED
    
    | @@ -32,7 +32,9 @@ Gem::Specification.new do |s| | |
| 32 32 | 
             
              s.required_ruby_version = ">= 1.9"
         | 
| 33 33 |  | 
| 34 34 | 
             
              s.add_runtime_dependency 'oauth2', '~> 1.4', '>= 1.4.2'
         | 
| 35 | 
            -
              s.add_runtime_dependency 'wire4_client', '~> 0.0 | 
| 35 | 
            +
              s.add_runtime_dependency 'wire4_client', '~> 1.0.0', '>= 1.0.0'
         | 
| 36 | 
            +
             | 
| 37 | 
            +
              s.add_development_dependency 'test-unit', '~> 3.3', '>= 3.3.0'
         | 
| 36 38 |  | 
| 37 39 | 
             
              s.files         = `find *`.split("\n").uniq.sort.select { |f| !f.empty? }
         | 
| 38 40 | 
             
              s.executables   = []
         | 
    
        metadata
    CHANGED
    
    | @@ -1,14 +1,14 @@ | |
| 1 1 | 
             
            --- !ruby/object:Gem::Specification
         | 
| 2 2 | 
             
            name: wire4_auth
         | 
| 3 3 | 
             
            version: !ruby/object:Gem::Version
         | 
| 4 | 
            -
              version: 0.0 | 
| 4 | 
            +
              version: 1.0.0
         | 
| 5 5 | 
             
            platform: ruby
         | 
| 6 6 | 
             
            authors:
         | 
| 7 7 | 
             
            - Wire4
         | 
| 8 8 | 
             
            autorequire: 
         | 
| 9 9 | 
             
            bindir: bin
         | 
| 10 10 | 
             
            cert_chain: []
         | 
| 11 | 
            -
            date:  | 
| 11 | 
            +
            date: 2020-01-30 00:00:00.000000000 Z
         | 
| 12 12 | 
             
            dependencies:
         | 
| 13 13 | 
             
            - !ruby/object:Gem::Dependency
         | 
| 14 14 | 
             
              name: oauth2
         | 
| @@ -34,22 +34,42 @@ dependencies: | |
| 34 34 | 
             
              name: wire4_client
         | 
| 35 35 | 
             
              requirement: !ruby/object:Gem::Requirement
         | 
| 36 36 | 
             
                requirements:
         | 
| 37 | 
            -
                - - "~>"
         | 
| 38 | 
            -
                  - !ruby/object:Gem::Version
         | 
| 39 | 
            -
                    version: 0.0.1.pre.SNAPSHOT
         | 
| 40 37 | 
             
                - - ">="
         | 
| 41 38 | 
             
                  - !ruby/object:Gem::Version
         | 
| 42 | 
            -
                    version: 0.0 | 
| 39 | 
            +
                    version: 1.0.0
         | 
| 40 | 
            +
                - - "~>"
         | 
| 41 | 
            +
                  - !ruby/object:Gem::Version
         | 
| 42 | 
            +
                    version: 1.0.0
         | 
| 43 43 | 
             
              type: :runtime
         | 
| 44 44 | 
             
              prerelease: false
         | 
| 45 45 | 
             
              version_requirements: !ruby/object:Gem::Requirement
         | 
| 46 46 | 
             
                requirements:
         | 
| 47 | 
            +
                - - ">="
         | 
| 48 | 
            +
                  - !ruby/object:Gem::Version
         | 
| 49 | 
            +
                    version: 1.0.0
         | 
| 47 50 | 
             
                - - "~>"
         | 
| 48 51 | 
             
                  - !ruby/object:Gem::Version
         | 
| 49 | 
            -
                    version: 0.0 | 
| 52 | 
            +
                    version: 1.0.0
         | 
| 53 | 
            +
            - !ruby/object:Gem::Dependency
         | 
| 54 | 
            +
              name: test-unit
         | 
| 55 | 
            +
              requirement: !ruby/object:Gem::Requirement
         | 
| 56 | 
            +
                requirements:
         | 
| 50 57 | 
             
                - - ">="
         | 
| 51 58 | 
             
                  - !ruby/object:Gem::Version
         | 
| 52 | 
            -
                    version:  | 
| 59 | 
            +
                    version: 3.3.0
         | 
| 60 | 
            +
                - - "~>"
         | 
| 61 | 
            +
                  - !ruby/object:Gem::Version
         | 
| 62 | 
            +
                    version: '3.3'
         | 
| 63 | 
            +
              type: :development
         | 
| 64 | 
            +
              prerelease: false
         | 
| 65 | 
            +
              version_requirements: !ruby/object:Gem::Requirement
         | 
| 66 | 
            +
                requirements:
         | 
| 67 | 
            +
                - - ">="
         | 
| 68 | 
            +
                  - !ruby/object:Gem::Version
         | 
| 69 | 
            +
                    version: 3.3.0
         | 
| 70 | 
            +
                - - "~>"
         | 
| 71 | 
            +
                  - !ruby/object:Gem::Version
         | 
| 72 | 
            +
                    version: '3.3'
         | 
| 53 73 | 
             
            description: Herramienta para autenticacion de la API de Wire4
         | 
| 54 74 | 
             
            email:
         | 
| 55 75 | 
             
            - ''
         | 
| @@ -82,11 +102,11 @@ required_ruby_version: !ruby/object:Gem::Requirement | |
| 82 102 | 
             
                  version: '1.9'
         | 
| 83 103 | 
             
            required_rubygems_version: !ruby/object:Gem::Requirement
         | 
| 84 104 | 
             
              requirements:
         | 
| 85 | 
            -
              - - " | 
| 105 | 
            +
              - - ">="
         | 
| 86 106 | 
             
                - !ruby/object:Gem::Version
         | 
| 87 | 
            -
                  version:  | 
| 107 | 
            +
                  version: '0'
         | 
| 88 108 | 
             
            requirements: []
         | 
| 89 | 
            -
            rubygems_version: 3. | 
| 109 | 
            +
            rubygems_version: 3.0.6
         | 
| 90 110 | 
             
            signing_key: 
         | 
| 91 111 | 
             
            specification_version: 4
         | 
| 92 112 | 
             
            summary: Wire4Auth Ruby Gem
         |