keycloak 2.3.2 → 2.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 978fc047e4ff958ad16097d09cc9b85ec821bf2313cb231301171d2cbbef7ab5
-  data.tar.gz: 9bdf8d17a3ce8e440f9474df0e56ddfe549ae147b3d4bdfd7f07741afd472788
+  metadata.gz: d419a683b8c5acc4e90870947280ad4953e44ffe3a91fc231afc9ed8665226d1
+  data.tar.gz: 523aa9997cbacb76ef37a2617b685cc9a919219b2511cd79bd38da0114ca1ccb
 SHA512:
-  metadata.gz: dfe47b7aff82b92797ff5182648a09dd1828d3107df2b75f05dd19b446fa4548b2f922f63a275ad1624b1e1ccc861c9b6cdd516ca5a83ebfabfb5d745feb1ade
-  data.tar.gz: fd6a948686df8474b6dcca4ae4515557e468715a7abb923ee2f9d21624b74c19649f3ca317168303b2bc7d854b8e1a3a1c16130d7ba378cc1806af1f23aae933
+  metadata.gz: a5776f216a4ef94247922c5b4837785ab71bb6611fe0bf6cc9f86f30847ae140f6d10634e969e7e3c682d1c87598077a54c387ae6a7f52dbd5582e3d2c17775e
+  data.tar.gz: 93d76cc19f4d93efe21bf7697a4f345818f22faaead39ad8376bca6d953dd173781b04877e8f2b32485673195aefeb710cd7a986ce655bf26a754915e75b6247

data/.gitignore

@@ -1 +1,2 @@
 keycloak-*.gem
+.rspec_status

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    keycloak (2.3.2)
+    keycloak (2.4.0)
       json
       jwt
       rest-client
@@ -10,15 +10,15 @@ GEM
   remote: https://rubygems.org/
   specs:
     diff-lcs (1.3)
-    domain_name (0.5.20170404)
+    domain_name (0.5.20180417)
       unf (>= 0.0.5, < 1.0.0)
     http-cookie (1.0.3)
       domain_name (~> 0.5)
     json (2.1.0)
     jwt (2.1.0)
-    mime-types (3.1)
+    mime-types (3.2.2)
       mime-types-data (~> 3.2015)
-    mime-types-data (3.2016.0521)
+    mime-types-data (3.2018.0812)
     netrc (0.11.0)
     rake (10.5.0)
     rest-client (2.0.2)
@@ -40,7 +40,7 @@ GEM
     rspec-support (3.7.1)
     unf (0.1.4)
       unf_ext
-    unf_ext (0.0.7.4)
+    unf_ext (0.0.7.5)
 
 PLATFORMS
   ruby
@@ -52,4 +52,4 @@ DEPENDENCIES
   rspec (~> 3.0)
 
 BUNDLED WITH
-   1.16.1
+   1.16.2

data/README.md

@@ -8,6 +8,8 @@ Its development was based on version 3.2 of Keycloak, whose documentation can be
 
 Publication of gem: https://rubygems.org/gems/keycloak
 
+Exemple: https://github.com/imagov/example-gem-keycloak
+
 ## Installation
 
 Add this line in your application's <b>gemfile</b>:
@@ -33,7 +35,7 @@ To add the configuration file:
 
 Since you already have a Keycloak environment configured and the gem already installed, the next step is to define how the application will authenticate. Keycloak works with key authentication protocols, such as OpenID Connect, Oauth 2.0 and SAML 2.0, integrating system access through Single-Sign On, and can also provide access to <b>LDAP</b> or <b>Active Directory</b> users.
 
-When you register a realm and also a Client in your Keycloak environment, you can download the Client installation file into the root folder of the application so that gem gets the information it needs to interact with Keycloak. To download this, simply access your Client's registry, click the <b>Installation</b> tab, select <b>Keycloak OIDC JSON</b> in the <b>Format option</b> field and click <b>Download</b>. If your application does not only work with a specific client (application server for APIs, for example), then you can tell what is the realm that gem will interact in the `keycloak.rb` configuration file.
+When you register a realm and also a Client in your Keycloak environment, you can download the Client installation file into the `config` folder of the application so that gem gets the information it needs to interact with Keycloak. To download this, simply access your Client's registry, click the <b>Installation</b> tab, select <b>Keycloak OIDC JSON</b> in the <b>Format option</b> field and click <b>Download</b>. If your application does not only work with a specific client (application server for APIs, for example), then you can tell what is the realm that gem will interact in the `keycloak.rb` configuration file.
 
 Gem has a main module called <b>Keycloak</b>. Within this module there are three other modules: <b>Client</b>, <b>Admin</b> and <b>Internal</b>.
 
@@ -41,6 +43,12 @@ Gem has a main module called <b>Keycloak</b>. Within this module there are three
 
 The Keycloak module has some attributes and its definitions are fundamental for the perfect functioning of the gem in the application.
 
+```ruby
+Keycloak.installation_file = 'path/to/file.json'
+```
+
+Allows you to set the location of installation file if you have one. If not set, it will default to `keycloak.json` in the `config` folder of your repository. In any case, it will use installation file only if it's present.
+
 ```ruby
 Keycloak.realm
 ```
@@ -122,7 +130,7 @@ The `Keycloak::Client` module has the methods that represent the <b>endpoint</b>
 We will detail each of these methods:
 
 ```ruby
-Keycloak::Client.get_token(user, password)
+Keycloak::Client.get_token(user, password, client_id = '', secret = '')
 ```
 
 If you choose to authenticate users using the screen of your own application, then use this method. Simply invoke it in the method of login in the `controller` defined with the session controller of your application, passing as parameter the <b>user</b> and the <b>password</b> informed by the user. If the authentication is valid, then a JSON containing the `access_token` and the `refresh_token` is returned.
@@ -136,21 +144,35 @@ To authenticate the users of your application using a template configured in Key
 
 
 ```ruby
-Keycloak::Client.get_token_by_code(code, redirect_uri)
+Keycloak::Client.get_token_by_code(code, redirect_uri, client_id = '', secret = '')
 ```
 
 When using the `Keycloak::Client.url_login_redirect` method to get a `code`, pass it as a parameter in this method so that Keycloak returns a token, thus logging the user in the application. The second parameter (`redirect_uri`) must be passed so that when a token is made available, Keycloak redirects to the url informed.
 
 
 ```ruby
-Keycloak::Client.get_token_by_refresh_token(refresh_token = '')
+Keycloak::Client.get_token_by_exchange(issuer, issuer_token, client_id = '', secret = '')
+```
+
+To get a token through a token previously obtained from a trusted provider (OpenID standard), such as Facebook, Gooble, Twitter, or even another realm configured in the keycloak, simply invoke this method, passing in the `issuer` parameter the provider alias configured in the realm, and in the `issuer_token` parameter the token obtained by that provider. This will return a token authenticated by your realm.
+
+
+```ruby
+Keycloak::Client.get_userinfo_issuer(access_token = '', userinfo_endpoint = '')
+```
+
+This method returns the user information of a provider (`issuer` of the `get_token_by_exchange` method represented by the `access_token` passed as parameter. If the `access_token` parameter is not informed, then the gem will get this information in the cookie.
+
+
+```ruby
+Keycloak::Client.get_token_by_refresh_token(refresh_token = '', client_id = '', secret = '')
 ```
 
 When the user is already logged in and your application internally tracks the token expiration time provided by Keycloak, then this method can be used to renew that token if it is still valid. To do this, simply pass the `refresh_token` as a parameter. If you do not inform `refresh_token`, gem will use the `refresh_token` stored in the cookie.
 
 
 ```ruby
-Keycloak::Client.get_token_introspection(token = '')
+Keycloak::Client.get_token_introspection(token = '', client_id = '', secret = '', token_introspection_endpoint = '')
 ```
 
 This method returns the information from the `token` session passed as parameter. Among the information returned, the most important is the `active` field, since it informs whether the token session passed in the parameter is active or not. This will help your application control whether the logged-in user session has expired or not. If no token is passed as a parameter, gem will use the last `access_token` stored in the application's cookie.
@@ -164,14 +186,14 @@ There are some Keycloak services like <b>password reset</b>, <b>user registratio
 
 
 ```ruby
-Keycloak::Client.logout(redirect_uri = '', refresh_token = '')
+Keycloak::Client.logout(redirect_uri = '', refresh_token = '', client_id = '', secret = '', end_session_endpoint = '')
 ```
 
 When used before the expiration of the logged on user's session, this method terminates the session. If the `redirect_uri` parameter is fed, then Keycloak will redirect your application to the url informed after logout. The second parameter is `refresh_token`, obtained at the time of authentication or session update. If the latter is not informed, then the gem will use the `refresh_token` of the cookie
 
 
 ```ruby
-Keycloak::Client.get_userinfo(access_token = '')
+Keycloak::Client.get_userinfo(access_token = '', userinfo_endpoint = '')
 ```
 
 This method returns synthetic information from the user represented by the `access_token` passed as a parameter, such as `sub` - which is the authenticated user id -, `preferred_username` - which is the authenticated user name - and `email` - which is the user's email address. If the `access_token` parameter is not informed, then the gem will get this information in the cookie.
@@ -185,14 +207,14 @@ Returns the <b>url</b> for access to the realm user registry of the installation
 
 
 ```ruby
-Keycloak::Client.has_role?(user_role, access_token = '')
+Keycloak::Client.has_role?(user_role, access_token = '', client_id = '', secret = '', token_introspection_endpoint = '')
 ```
 
 The `has_role?` method decodes the JWT `access_token` and verifies that the user who owns the token has the <b>role</b> informed in the `user_role` parameter. If `access_token` is not informed then gem will use the `access_token` of the cookie.
 
 
 ```ruby
-Keycloak::Client.user_signed_in?(access_token = '')
+Keycloak::Client.user_signed_in?(access_token = '', client_id = '', secret = '', token_introspection_endpoint = '')
 ```
 
 This method checks whether the `access_token` passed in the parameter is still active. To check whether the user is active or not, the gem invokes the `get_token_introspection` method internally. If `access_token` is not informed then gem will use the `access_token` of the cookie.
@@ -376,8 +398,8 @@ The following are the <b>Generics Methods</b>:
 Keycloak::Admin.generic_get(service, query_parameters = nil, access_token = nil)
 ```
 
-`generic_get` permite que você faça requisições de serviços `GET` do <b>Keycloak</b>. A parte da URI que identifica o serviço deve ser passada no parâmetro `service`, já com os parâmetros de rota (como o `{client}`, por exemplo) devidamente substituídos. No parâmetro `query_parameters` você poderá passar um `hash` contendo os <b>Queries Parameters</b> da requisição.<br>
-Exemplo:
+`generic_get` allows you to make <b>Keycloak</b> `GET` service requests. The part of the URI that identifies the service must be passed in the `service` parameter, already with the route parameters (such as `{client}`, for example) properly replaced. In the `query_parameters` parameter you can pass a `hash` containing the <b>Queries Parameters</b> of the request.<br>
+Example:
 ```ruby
     Keycloak::Admin.generic_get("users/", {email: 'admin@test.com'}, "eyJhbGciOiJSUzI1NiIsInR5cCIgOiAiSldU...")
 ```
@@ -387,107 +409,105 @@ Exemplo:
 Keycloak::Admin.generic_post(service, query_parameters, body_parameter, access_token = nil)
 ```
 
-`generic_post` permite que você faça requisições de serviços `POST` do <b>Keycloak</b>. A parte da URI que identifica o serviço deve ser passada no parâmetro `service`, já com os parâmetros de rota (como o `{client}`, por exemplo) devidamente substituídos. No parâmetro `query_parameters` você poderá passar um `hash` contendo os <b>Query Parameters</b> da requisição. No parâmetro `body_parameter` você poderá passar um `hash` contendo os <b>Body Parameters</b> da requisição.<br>
-Exemplo:
+`generic_post` allows you to make <b>Keycloak</b> `POST` service requests. The part of the URI that identifies the service must be passed in the `service` parameter, already with the route parameters (such as `{client}`, for example) properly replaced. In the `query_parameters` parameter you can pass a `hash` containing the <b>Query Parameters</b> of the request. In the `body_parameter` parameter you can pass a `hash` containing the <b>Body Parameters</b> of the request.<br>
+Example:
 ```ruby
     Keycloak::Admin.generic_post("users/", nil, { username: "admin", email: "admin@test.com", enabled: true }, "eyJhbGciOiJSUzI1NiIsInR5cCIgOiAiSldU...")
 ```
 
-
 ```ruby
 Keycloak::Admin.generic_put(service, query_parameters, body_parameter, access_token = nil)
 ```
 
-`generic_put` permite que você faça requisições de serviços `PUT` do <b>Keycloak</b>. A parte da URI que identifica o serviço deve ser passada no parâmetro `service`, já com os parâmetros de rota (como o `{client}`, por exemplo) devidamente substituídos. No parâmetro `query_parameters` você poderá passar um `hash` contendo os <b>Query Parameters</b> da requisição. No parâmetro `body_parameter` você poderá passar um `hash` contendo os <b>Body Parameters</b> da requisição.
+`generic_put` allows you to make <b>Keycloak</b> `PUT` service requests. The part of the URI that identifies the service must be passed in the `service` parameter, already with the route parameters (such as `{client}`, for example) properly replaced. In the `query_parameters` parameter you can pass a `hash` containing the <b>Query Parameters</b> of the request. In the `body_parameter` parameter you can pass a `hash` containing the <b>Body Parameters</b> of the request.
 
 
 ```ruby
 Keycloak::Admin.generic_delete(service, query_parameters = nil, body_parameter = nil, access_token = nil)
 ```
 
-`generic_delete` permite que você faça requisições de serviços `DELETE` do <b>Keycloak</b>. A parte da URI que identifica o serviço deve ser passada no parâmetro `service`, já com os parâmetros de rota (como o `{client}`, por exemplo) devidamente substituídos. No parâmetro `query_parameters` você poderá passar um `hash` contendo os <b>Query Parameters</b> da requisição. No parâmetro `body_parameter` você poderá passar um `hash` contendo os <b>Body Parameters</b> da requisição.
-
+`generic_delete` allows you to make <b>Keycloak</b> `DELETE` service requests. The part of the URI that identifies the service must be passed in the `service` parameter, already with the route parameters (such as `{client}`, for example) properly replaced. In the `query_parameters` parameter you can pass a `hash` containing the <b>Query Parameters</b> of the request. In the `body_parameter` parameter you can pass a `hash` containing the <b>Body Parameters</b> of the request.
 
 
 ### Keycloak::Internal
 
-O módulo `Keycloak::internal`disponibiliza métodos criados para facilitar a interação entre a aplicação e o <b>Keycloak</b>. Partindo das informações encontradas no arquivo de instalação `keycloak.json`, todos os métodos invocados serão autenticados automaticamente, utilizando as credências da aplicação (`grant_type = client_credentials`), dependendo assim dos <b>roles</b> atribuídos a mesma para que o retorno da requisição seja autorizado.
+The `Keycloak::internal` module provides methods designed to facilitate interaction between the application and <b>Keycloak</b>. From the information found in the `keycloak.json` installation file, all invoked methods will be authenticated automatically, using the application credentials (`grant_type = client_credentials`), depending on the assigned roles assigned to it. request is authorized.
 
 
 ```ruby
-Keycloak::Internal.get_users(query_parameters = nil)
+Keycloak::Internal.get_users(query_parameters = nil, client_id = '', secret = '')
 ```
 
-`get_users` invoca o método `Keycloak::Admin.get_users` que, por sua vez, retorna uma lista de usuários, filtrada de acordo com o hash de parâmetros passado em `query_parameters`.
+`get_users` invokes the `Keycloak::Admin.get_users` method that returns a list of users, filtered according to the parameters hash passed in `query_parameters`.
 
 
 ```ruby
-Keycloak::Internal.change_password(user_id, redirect_uri = '')
+Keycloak::Internal.change_password(user_id, redirect_uri = '', client_id = '', secret = '')
 ```
 
-`change_password` invocará a API `PUT /admin/realms/{realm}/users/{id}/execute-actions-email` do Keycloak requisitando a action `UPDATE_PASSWORD`. Isso fará com que o Keycloak dispare um e-mail para o usuário representado pelo parâmetro `user_id`. O parâmetro `redirect_uri` é opcional. Se não for preenchido, então não haverá nenhum link para clicar após a ação de reset de senha ter sido concluída.
+`change_password` will invoke the Keycloak `PUT /admin/realms/{realm}/users/{id}/execute-actions-email` API requesting the `UPDATE_PASSWORD` action. This will cause Keycloak to trigger an email to the user represented by the `user_id` parameter. The `redirect_uri` parameter is optional. If it is not filled, then there will be no link to click after the password reset action has been completed.
 
 
 ```ruby
-Keycloak::Internal.get_user_info(user_login, whole_word = false)
+Keycloak::Internal.get_user_info(user_login, whole_word = false, client_id = '', secret = ''))
 ```
 
-`get_user_info`, baseado no parâmetro `user_login`, que poderá recepcionar o `username` ou o `email` do usuário, retornará uma lista (array) de [UserRepresentation](http://www.keycloak.org/docs-api/3.2/rest-api/index.html#_userrepresentation) no caso em que o parâmetro `whole_word` for `false`, ou retornará um [UserRepresentation](http://www.keycloak.org/docs-api/3.2/rest-api/index.html#_userrepresentation) quando o parâmetro `whole_word` for `true`. O parâmetro `whole_word` indica se o método deverá considerar usuários que tenham no `username` ou `email` parte da expressão passada no parâmetro `user_login` - para os casos de `whole_word = false` -, ou que tenha exatamente a expressão passada nesse parâmetro - para os casos de `whole_word = true`.
+`get_user_info`, based on the `user_login` parameter, which will be able to receive the `username` or the `email` of the user, will return an array of [UserRepresentation](http://www.keycloak.org/docs-api/3.2/rest-api/index.html#_userrepresentation) in the case where the `whole_word` parameter is `false`, or it will return a [UserRepresentation](http://www.keycloak.org/docs-api/3.2/rest-api/index.html#_userrepresentation) when the `whole_word` parameter is `true`. The `whole_word` parameter indicates whether the method should consider users that have `username` or `email` part of the expression passed in the `user_login` parameter - for the cases of `whole_word = false` - or that has exactly the last expression in this parameter - for the cases of `whole_word = true`.
 
 
 ```ruby
-Keycloak::Internal.forgot_password(user_login, redirect_uri = '')
+Keycloak::Internal.forgot_password(user_login, redirect_uri = '', client_id = '', secret = '')
 ```
 
-`forgot_password` invocará o método `Keycloak::Internal.change_password` após invocar o método `Keycloak::Internal.get_user_info` - passando no parâmetro `user_login` do método descrito o parâmetro `user_login`deste tópico e passando `true` no parâmetro `whole_word` -. A utilização deste método é indicado para os casos de aplicações permitam o reset da senha dos usuários sem que o mesmo esteja logado.
+`forgot_password` will invoke the `Keycloak::Internal.change_password` method after invoking the `Keycloak::Internal.get_user_info` method - passing in the `user_login` parameter of the described method the `user_login` parameter of this topic and passing `true` in the parameter `whole_word`. The use of this method is indicated for the cases of applications allow the reset of the password of the users without it is logged in.
 
 
 ```ruby
-Keycloak::Internal.exists_name_or_email(value, user_id = '')
+Keycloak::Internal.exists_name_or_email(value, user_id = '', client_id = '', secret = '')
 ```
 
-`exists_name_or_email` verifica se no reino já existe algum usuário com `username` ou o `email` passado no parâmetro `value`. O parâmetro `user_id` serve para passar o `ID` de um usuário nos casos em que deseja-se alterar o `username` ou o `email` do mesmo, para que assim sejam considerados na verificação do `username` e do `email` usuários diferentes do usuário com o `ID` informado em `user_id`.
+`exists_name_or_email` checks whether a user with `username` or `email` already exists in the `value` parameter in the realm. The `user_id` parameter is used to pass the `ID` of a user in cases where it is desired to change the `username` or `email` of the same, so that they are considered in the `username` and `email verification` different users of the user with the `ID` informed in `user_id`.
 
 
 ```ruby
-Keycloak::Internal.get_logged_user_info
+Keycloak::Internal.get_logged_user_info(client_id = '', secret = '')
 ```
 
-`get_logged_user_info` retorna o [UserRepresentation](http://www.keycloak.org/docs-api/3.2/rest-api/index.html#_userrepresentation) do usuário logado na aplicação.
+`get_logged_user_info` returns the [UserRepresentation](http://www.keycloak.org/docs-api/3.2/rest-api/index.html#_userrepresentation) of the user logged into the application.
 
 
 ```ruby
 # GET /admin/realms/{realm}/users
-Keycloak::Internal.logged_federation_user?
+Keycloak::Internal.logged_federation_user?(client_id = '', secret = '')
 ```
 
-`logged_federation_user?` incova o método `Keycloak::Internal.get_logged_user_info` e verifica se o mesmo é um <b>Federation User</b> (um usuário do AD por exemplo).
+`logged_federation_user?` method invokes the `Keycloak::Internal.get_logged_user_info` method and checks to see if it is an <b>Federation User</b> (an LDAP user for example).
 
 
 ```ruby
 # GET /admin/realms/{realm}/users
-Keycloak::Internal.create_starter_user(username, password, email, client_roles_names, proc = nil)
+Keycloak::Internal.create_starter_user(username, password, email, client_roles_names, proc = nil, client_id = '', secret = '')
 ```
 
-`create_starter_user` é indicado para aplicações que permitam a criação de novos usuários sem que um usuário esteja logado ou até mesmo para criar novos usuários a partir do `rake db:seed`. Nos parâmetros `username`, `password` e `email` devem ser passados o nome do usuário, a senha do usuário, e o e-mail do usuário, respectivamente. No parâmetro `client_roles_names`deve ser passado uma lista (array) com o nome dos `roles` do Client que serão atribuídos ao usuário. O parâmetro `proc` trata-se de um método <b>lambda</b> que disponibilizará como parâmetro a [UserRepresentation](http://www.keycloak.org/docs-api/3.2/rest-api/index.html#_userrepresentation) do usuário criado para que sejam definidas ações por parte da aplicação. Este método terá como retorno o mesmo retorno do método do parâmetro `proc` se o mesmo for definido, caso contrário retornará a [UserRepresentation](http://www.keycloak.org/docs-api/3.2/rest-api/index.html#_userrepresentation) do usuário criado.
+`create_starter_user` is suitable for applications that allow the creation of new users without a user being logged in or even to create new users from `rake db: seed`. In the `username`, `password` and `email` parameters, the user name, password, and email, respectively, must be passed. In the `client_roles_names` parameter, a list (array) with the name of the `roles` of the Client that will be assigned to the user must be passed. The `proc` parameter is a <b>lambda</b> method that will make available the [UserRepresentation](http://www.keycloak.org/docs-api/3.2/rest-api/index.html#_userrepresentation) of the created user as a parameter, so that actions should be defined by the application. This method returns the same return of the `proc` parameter method if it is set, otherwise it will return to [UserRepresentation](http://www.keycloak.org/docs-api/3.2/rest-api/index.html#_userrepresentation) of the created user.
 
 
 ```ruby
-Keycloak::Internal.get_client_roles
+Keycloak::Internal.get_client_roles(client_id = '', secret = '')
 ```
 
-`get_client_roles` retornará uma lista (array) de [RoleRepresentation](http://www.keycloak.org/docs-api/3.2/rest-api/index.html#_rolerepresentation) do Client indicado pelo arquivo de instalação `keycloak.json`.
+`get_client_roles` will return an array of [RoleRepresentation](http://www.keycloak.org/docs-api/3.2/rest-api/index.html#_rolerepresentation) from the Client indicated in the `client_id` parameter or, in the absence of this, by the client of the `keycloak.json` installation file.
 
 
 ```ruby
-Keycloak::Internal.get_client_user_roles(user_id)
+Keycloak::Internal.get_client_user_roles(user_id, client_id = '', secret = '')
 ```
 
-`get_client_user_roles` invocará o método `Keycloak::Admin.get_effective_client_level_role_composite_user` considerando o Client indicado pelo arquivo de instalação `keycloak.json` e o usuário representado pelo parâmetro `user_id`.
+`get_client_user_roles` will invoke the `Keycloak::Admin.get_effective_client_level_role_composite_user` method by considering the Client indicated in the `client_id` parameter or, if not, by the client of the `keycloak.json` installation file and the user represented by the `user_id` parameter.
 
 
 ```ruby
-Keycloak::Internal.has_role?(user_id, user_role)
+Keycloak::Internal.has_role?(user_id, user_role, client_id = '', secret = '')
 ```
 
-`has_role?` informará se o usuário representado pelo parâmetro `user_id` possui o <b>role</b> com o nome representado pelo parâmetro `user_role`.
+`has_role?` informing the user represented by the `user_id` parameter has <b>role</b> with the name represented by the `user_role` parameter.

data/README.pt-BR.md

@@ -5,6 +5,8 @@ O seu desenvolvimento foi baseado na versão 3.2 do Keycloak, cuja documentaçã
 
 Publicação da gem: https://rubygems.org/gems/keycloak
 
+Exemplo: https://github.com/imagov/example-gem-keycloak
+
 ## Instalação
 
 Adicione esta linha no <b>Gemfile</b> de sua aplicação:
@@ -29,7 +31,7 @@ Para adicionar o arquivo de configuração:
 
 Considerando que você já possua um ambiente do Keycloak configurado e a gem já instalada, o próximo passo é definir como será a autenticação da aplicação. O Keycloak trabalha com os principais protocolos de autenticação, tais como o OpenID Connect, Oauth 2.0 e SAML 2.0, integrando acesso a sistemas via Single-Sign On, podendo inclusive disponibilizar acessos a usuários LDAP ou Active Directory.
 
-Ao cadastrar um Reino e também um Client no seu ambiente Keycloak, você poderá fazer o download do arquivo de instalação do Client para dentro da pasta raiz da aplicação, para que a gem obtenha as informações necessárias para interagir com o Keycloak. Para fazer esse download, basta acessar o cadastro de seu Client, clicar na aba <b>Installation</b>, selecionar <b>Keycloak OIDC JSON</b> no campo <b>Format option</b> e clicar em <b>Download</b>. Caso a sua aplicação não trabalhe apenas com um client específico (aplicação servidora de APIs, por exemplo), então você poderá informar o reino que a gem irá interagir no arquivo de configuração `keycloak.rb`.
+Ao cadastrar um Reino e também um Client no seu ambiente Keycloak, você poderá fazer o download do arquivo de instalação do Client para dentro da pasta `config` da aplicação, para que a gem obtenha as informações necessárias para interagir com o Keycloak. Para fazer esse download, basta acessar o cadastro de seu Client, clicar na aba <b>Installation</b>, selecionar <b>Keycloak OIDC JSON</b> no campo <b>Format option</b> e clicar em <b>Download</b>. Caso a sua aplicação não trabalhe apenas com um client específico (aplicação servidora de APIs, por exemplo), então você poderá informar o reino que a gem irá interagir no arquivo de configuração `keycloak.rb`.
 
 A gem possui um módulo principal chamado <b>Keycloak</b>. Dentro desse módulo há três outros módulos: <b>Client</b>, <b>Admin</b> e <b>Internal</b>.
 
@@ -37,6 +39,12 @@ A gem possui um módulo principal chamado <b>Keycloak</b>. Dentro desse módulo
 
 O módulo Keycloak possui alguns atributos e suas definições são fundamentais para o perfeito funcionamento da gem na aplicação.
 
+```ruby
+Keycloak.installation_file = 'path/to/file.json'
+```
+
+Permite você determinar o local do arquivo de instalação do Keycloak, caso você esteja utilizando um. Se não for informado, o caminho default será `config/Keycloak.json`.
+
 ```ruby
 Keycloak.realm
 ```
@@ -116,7 +124,7 @@ Vamos ao detalhamento de cada um desses métodos:
 
 
 ```ruby
-Keycloak::Client.get_token(user, password)
+Keycloak::Client.get_token(user, password, client_id = '', secret = '')
 ```
 
 Caso você opte por efetuar a autenticação dos usuários utilizando a tela da sua própria aplicação, então utilize esse método. Basta invocá-lo no método de login no `controller` definido com o controlador de sessão de sua aplicação, passando como parâmetro o <b>usuário</b> e a <b>senha</b> informados pelo usuário. Caso a autenticação seja válida, então será retornado um JSON contendo entre as informações principais o `access_token` e o `refresh_token`.
@@ -130,35 +138,35 @@ Para efetuar a autenticação dos usuários de sua aplicação utilizando um tem
 
 
 ```ruby
-Keycloak::Client.get_token_by_code(code, redirect_uri)
+Keycloak::Client.get_token_by_code(code, redirect_uri, client_id = '', secret = '')
 ```
 
 Ao utilizar o método `Keycloak::Client.url_login_redirect` para obter um `code`, passe-o como parâmetro neste método para que o Keycloak retorne um token, efetuando assim o login do usuário na aplicação. O segundo parâmetro (`redirect_uri`) deve ser passado para que, ao disponibilizar um token, o Keycloak redirecione para a url informada.
 
 
 ```ruby
-Keycloak::Client.get_token_by_exchange(issuer, issuer_token)
+Keycloak::Client.get_token_by_exchange(issuer, issuer_token, client_id = '', secret = '')
 ```
 
 Para obter um token através de um token obtido anteriormente de um provedor confiável (padrão OpenID), como Facebook, Gooble, Twitter, ou até mesmo outro reino configurado no keycloak, basta invocar este método, passando no parâmetro `issuer` o alias do provedor configurado no reino, e, no parâmetro `issuer_token` o token obtido por esse provedor. Com isso, será retornado um token autenticado pelo teu reino.
 
 
 ```ruby
-Keycloak::Client.get_userinfo_issuer(access_token = '')
+Keycloak::Client.get_userinfo_issuer(access_token = '', userinfo_endpoint = '')
 ```
 
 Esse método retorna as informações do usuário de um provevedor (`issuer` do método `get_token_by_exchange`) representado pelo `access_token` passado como parâmetro. Caso o parâmetro `access_token` não seja informado, então a gem obterá essa informação no cookie.
 
 
 ```ruby
-Keycloak::Client.get_token_by_refresh_token(refresh_token = '')
+Keycloak::Client.get_token_by_refresh_token(refresh_token = '', client_id = '', secret = '')
 ```
 
 Quando o usuário já estiver logado e a sua aplicação acompanhar internamente o tempo de expiração do token fornecido pelo Keycloak, então esse método poderá ser utilizado para a renovação desse token, caso o mesmo ainda seja válido. Para isso, basta passar como parãmetro o `refresh_token`. Caso não seja informado o `refresh_token`, a gem utilizará o `refresh_token` armazenado no cookie.
 
 
 ```ruby
-Keycloak::Client.get_token_introspection(token = '')
+Keycloak::Client.get_token_introspection(token = '', client_id = '', secret = '', token_introspection_endpoint = '')
 ```
 
 Esse método retorna a as informações da sessão do `token` passado como parâmetro. Entre as informações retornadas, a mais importante é o campo `active`, pois ele informa se a sessão do token passado no parâmetro é ativo ou não. Isso auxiliará a sua aplicação a controlar se a sessão do usuário logado expirou ou não. Caso nenhum token seja passado como parâmetro, a gem utilizará o último `access_token` armazenado no cookie da aplicação.
@@ -172,14 +180,14 @@ Há alguns serviços do Keycloak como <b>reset de senha</b>, <b>cadastro de usu
 
 
 ```ruby
-Keycloak::Client.logout(redirect_uri = '', refresh_token = '')
+Keycloak::Client.logout(redirect_uri = '', refresh_token = '', client_id = '', secret = '', end_session_endpoint = '')
 ```
 
 Quando utilizado antes da expiração da sessão do usuário logado, esse método encerra a sessão. Se o parâmetro `redirect_uri` for alimentado, então o Keycloak redirecionará a sua aplicação para a url informada após a efetuação do logout. O segundo parâmetro é o `refresh_token` obtido no momento da autenticação ou da atualização da sessão. Caso este último não seja informado, então a gem utilizará o `refresh_token` do cookie.
 
 
 ```ruby
-Keycloak::Client.get_userinfo(access_token = '')
+Keycloak::Client.get_userinfo(access_token = '', userinfo_endpoint = '')
 ```
 
 Esse método retorna informações sintéticas do usuário representado pelo `access_token` passado como parâmetro, tais como `sub` - que é o Id do usuário autenticado -, `preferred_username` - que é o nome do usuário autenticado - e `email` - que é o e-mail do usuário. Caso o parâmetro `access_token` não seja informado, então a gem obterá essa informação no cookie.
@@ -193,14 +201,14 @@ Retorna a <b>url</b> para acesso ao cadastro de usuários do Reino do arquivo de
 
 
 ```ruby
-Keycloak::Client.has_role?(user_role, access_token = '')
+Keycloak::Client.has_role?(user_role, access_token = '', client_id = '', secret = '', token_introspection_endpoint = '')
 ```
 
 O método `has_role?` decodifica o JWT `access_token` e verifica se o usuário dono do token possui o <b>role</b> informado no parâmetro `user_role`. Caso o `access_token` não seja informado, então a gem utilizará o `access_token` do cookie.
 
 
 ```ruby
-Keycloak::Client.user_signed_in?(access_token = '')
+Keycloak::Client.user_signed_in?(access_token = '', client_id = '', secret = '', token_introspection_endpoint = '')
 ```
 
 Esse método verifica se o `access_token` passado no parâmetro ainda está ativo. Para verificar se o usuário está ativo ou não, internamente a gem invoca o método `get_token_introspection`. Caso o `access_token` não seja informado, então a gem utilizará o `access_token` do cookie.
@@ -422,46 +430,46 @@ Keycloak::Admin.generic_delete(service, query_parameters = nil, body_parameter =
 
 ### Keycloak::Internal
 
-O módulo `Keycloak::internal`disponibiliza métodos criados para facilitar a interação entre a aplicação e o <b>Keycloak</b>. Partindo das informações encontradas no arquivo de instalação `keycloak.json`, todos os métodos invocados serão autenticados automaticamente, utilizando as credências da aplicação (`grant_type = client_credentials`), dependendo assim dos <b>roles</b> atribuídos a mesma para que o retorno da requisição seja autorizado.
+O módulo `Keycloak::internal` disponibiliza métodos criados para facilitar a interação entre a aplicação e o <b>Keycloak</b>. Partindo das informações encontradas no arquivo de instalação `keycloak.json`, todos os métodos invocados serão autenticados automaticamente, utilizando as credências da aplicação (`grant_type = client_credentials`), dependendo assim dos <b>roles</b> atribuídos a mesma para que o retorno da requisição seja autorizado.
 
 
 ```ruby
-Keycloak::Internal.get_users(query_parameters = nil)
+Keycloak::Internal.get_users(query_parameters = nil, client_id = '', secret = '')
 ```
 
 `get_users` invoca o método `Keycloak::Admin.get_users` que, por sua vez, retorna uma lista de usuários, filtrada de acordo com o hash de parâmetros passado em `query_parameters`.
 
 
 ```ruby
-Keycloak::Internal.change_password(user_id, redirect_uri = '')
+Keycloak::Internal.change_password(user_id, redirect_uri = '', client_id = '', secret = '')
 ```
 
 `change_password` invocará a API `PUT /admin/realms/{realm}/users/{id}/execute-actions-email` do Keycloak requisitando a action `UPDATE_PASSWORD`. Isso fará com que o Keycloak dispare um e-mail para o usuário representado pelo parâmetro `user_id`. O parâmetro `redirect_uri` é opcional. Se não for preenchido, então não haverá nenhum link para clicar após a ação de reset de senha ter sido concluída.
 
 
 ```ruby
-Keycloak::Internal.get_user_info(user_login, whole_word = false)
+Keycloak::Internal.get_user_info(user_login, whole_word = false, client_id = '', secret = ''))
 ```
 
 `get_user_info`, baseado no parâmetro `user_login`, que poderá recepcionar o `username` ou o `email` do usuário, retornará uma lista (array) de [UserRepresentation](http://www.keycloak.org/docs-api/3.2/rest-api/index.html#_userrepresentation) no caso em que o parâmetro `whole_word` for `false`, ou retornará um [UserRepresentation](http://www.keycloak.org/docs-api/3.2/rest-api/index.html#_userrepresentation) quando o parâmetro `whole_word` for `true`. O parâmetro `whole_word` indica se o método deverá considerar usuários que tenham no `username` ou `email` parte da expressão passada no parâmetro `user_login` - para os casos de `whole_word = false` -, ou que tenha exatamente a expressão passada nesse parâmetro - para os casos de `whole_word = true`.
 
 
 ```ruby
-Keycloak::Internal.forgot_password(user_login, redirect_uri = '')
+Keycloak::Internal.forgot_password(user_login, redirect_uri = '', client_id = '', secret = '')
 ```
 
-`forgot_password` invocará o método `Keycloak::Internal.change_password` após invocar o método `Keycloak::Internal.get_user_info` - passando no parâmetro `user_login` do método descrito o parâmetro `user_login`deste tópico e passando `true` no parâmetro `whole_word` -. A utilização deste método é indicado para os casos de aplicações permitam o reset da senha dos usuários sem que o mesmo esteja logado.
+`forgot_password` invocará o método `Keycloak::Internal.change_password` após invocar o método `Keycloak::Internal.get_user_info` - passando no parâmetro `user_login` do método descrito o parâmetro `user_login`deste tópico e passando `true` no parâmetro `whole_word`. A utilização deste método é indicado para os casos de aplicações permitam o reset da senha dos usuários sem que o mesmo esteja logado.
 
 
 ```ruby
-Keycloak::Internal.exists_name_or_email(value, user_id = '')
+Keycloak::Internal.exists_name_or_email(value, user_id = '', client_id = '', secret = '')
 ```
 
 `exists_name_or_email` verifica se no reino já existe algum usuário com `username` ou o `email` passado no parâmetro `value`. O parâmetro `user_id` serve para passar o `ID` de um usuário nos casos em que deseja-se alterar o `username` ou o `email` do mesmo, para que assim sejam considerados na verificação do `username` e do `email` usuários diferentes do usuário com o `ID` informado em `user_id`.
 
 
 ```ruby
-Keycloak::Internal.get_logged_user_info
+Keycloak::Internal.get_logged_user_info(client_id = '', secret = '')
 ```
 
 `get_logged_user_info` retorna o [UserRepresentation](http://www.keycloak.org/docs-api/3.2/rest-api/index.html#_userrepresentation) do usuário logado na aplicação.
@@ -469,36 +477,36 @@ Keycloak::Internal.get_logged_user_info
 
 ```ruby
 # GET /admin/realms/{realm}/users
-Keycloak::Internal.logged_federation_user?
+Keycloak::Internal.logged_federation_user?(client_id = '', secret = '')
 ```
 
-`logged_federation_user?` incova o método `Keycloak::Internal.get_logged_user_info` e verifica se o mesmo é um <b>Federation User</b> (um usuário do AD por exemplo).
+`logged_federation_user?` incova o método `Keycloak::Internal.get_logged_user_info` e verifica se o mesmo é um <b>Federation User</b> (um usuário do LDAP por exemplo).
 
 
 ```ruby
 # GET /admin/realms/{realm}/users
-Keycloak::Internal.create_starter_user(username, password, email, client_roles_names, proc = nil)
+Keycloak::Internal.create_starter_user(username, password, email, client_roles_names, proc = nil, client_id = '', secret = '')
 ```
 
-`create_starter_user` é indicado para aplicações que permitam a criação de novos usuários sem que um usuário esteja logado ou até mesmo para criar novos usuários a partir do `rake db:seed`. Nos parâmetros `username`, `password` e `email` devem ser passados o nome do usuário, a senha do usuário, e o e-mail do usuário, respectivamente. No parâmetro `client_roles_names`deve ser passado uma lista (array) com o nome dos `roles` do Client que serão atribuídos ao usuário. O parâmetro `proc` trata-se de um método <b>lambda</b> que disponibilizará como parâmetro a [UserRepresentation](http://www.keycloak.org/docs-api/3.2/rest-api/index.html#_userrepresentation) do usuário criado para que sejam definidas ações por parte da aplicação. Este método terá como retorno o mesmo retorno do método do parâmetro `proc` se o mesmo for definido, caso contrário retornará a [UserRepresentation](http://www.keycloak.org/docs-api/3.2/rest-api/index.html#_userrepresentation) do usuário criado.
+`create_starter_user` é indicado para aplicações que permitam a criação de novos usuários sem que um usuário esteja logado ou até mesmo para criar novos usuários a partir do `rake db:seed`. Nos parâmetros `username`, `password` e `email` devem ser passados o nome, a senha, e o e-mail do usuário, respectivamente. No parâmetro `client_roles_names`deve ser passado uma lista (array) com o nome dos `roles` do Client que serão atribuídos ao usuário. O parâmetro `proc` trata-se de um método <b>lambda</b> que disponibilizará como parâmetro a [UserRepresentation](http://www.keycloak.org/docs-api/3.2/rest-api/index.html#_userrepresentation) do usuário criado para que sejam definidas ações por parte da aplicação. Esse método terá como retorno o mesmo retorno do método do parâmetro `proc` se o mesmo for definido, caso contrário retornará a [UserRepresentation](http://www.keycloak.org/docs-api/3.2/rest-api/index.html#_userrepresentation) do usuário criado.
 
 
 ```ruby
-Keycloak::Internal.get_client_roles
+Keycloak::Internal.get_client_roles(client_id = '', secret = '')
 ```
 
-`get_client_roles` retornará uma lista (array) de [RoleRepresentation](http://www.keycloak.org/docs-api/3.2/rest-api/index.html#_rolerepresentation) do Client indicado pelo arquivo de instalação `keycloak.json`.
+`get_client_roles` retornará uma lista (array) de [RoleRepresentation](http://www.keycloak.org/docs-api/3.2/rest-api/index.html#_rolerepresentation) do Client indicado no parâmetro `client_id` ou, na falta desse, pelo Client do arquivo de instalação `keycloak.json`.
 
 
 ```ruby
-Keycloak::Internal.get_client_user_roles(user_id)
+Keycloak::Internal.get_client_user_roles(user_id, client_id = '', secret = '')
 ```
 
-`get_client_user_roles` invocará o método `Keycloak::Admin.get_effective_client_level_role_composite_user` considerando o Client indicado pelo arquivo de instalação `keycloak.json` e o usuário representado pelo parâmetro `user_id`.
+`get_client_user_roles` invocará o método `Keycloak::Admin.get_effective_client_level_role_composite_user` considerando o Client indicado no parâmetro `client_id` ou, na falta desse, pelo Client do arquivo de instalação `keycloak.json` e o usuário representado pelo parâmetro `user_id`.
 
 
 ```ruby
-Keycloak::Internal.has_role?(user_id, user_role)
+Keycloak::Internal.has_role?(user_id, user_role, client_id = '', secret = '')
 ```
 
 `has_role?` informará se o usuário representado pelo parâmetro `user_id` possui o <b>role</b> com o nome representado pelo parâmetro `user_role`.

data/lib/keycloak.rb

@@ -6,33 +6,47 @@ require 'base64'
 require 'uri'
 
 module Keycloak
+  OLD_KEYCLOAK_JSON_FILE = 'keycloak.json'
+  KEYCLOAK_JSON_FILE = 'config/keycloak.json'
+
   class << self
     attr_accessor :proxy, :generate_request_exception, :keycloak_controller,
                   :proc_cookie_token, :proc_external_attributes,
                   :realm, :auth_server_url
   end
 
-
   def self.explode_exception
-    if Keycloak.generate_request_exception == nil
-      Keycloak.generate_request_exception = true
-    end
+    Keycloak.generate_request_exception = true if Keycloak.generate_request_exception.nil?
     Keycloak.generate_request_exception
   end
 
+  def self.installation_file
+    if File.exists?(KEYCLOAK_JSON_FILE)
+      @installation_file ||= KEYCLOAK_JSON_FILE
+    else
+      @installation_file ||= OLD_KEYCLOAK_JSON_FILE
+    end
+  end
+
+  def self.installation_file=(file = nil)
+    raise InstallationFileNotFound unless file.instance_of?(String) && File.exists?(file)
+    @installation_file = file || KEYCLOAK_JSON_FILE
+  end
+
   module Client
     class << self
       attr_accessor :realm, :auth_server_url
       attr_reader :client_id, :secret, :configuration, :public_key
     end
 
-    KEYCLOAK_JSON_FILE = 'keycloak.json'
-
-    def self.get_token(user, password)
+    def self.get_token(user, password, client_id = '', secret = '')
       setup_module
 
-      payload = { 'client_id' => @client_id,
-                  'client_secret' => @secret,
+      client_id = @client_id if client_id.blank?
+      secret = @secret if secret.blank?
+
+      payload = { 'client_id' => client_id,
+                  'client_secret' => secret,
                   'username' => user,
                   'password' => password,
                   'grant_type' => 'password' }
@@ -40,11 +54,14 @@ module Keycloak
       mount_request_token(payload)
     end
 
-    def self.get_token_by_code(code, redirect_uri)
+    def self.get_token_by_code(code, redirect_uri, client_id = '', secret = '')
       verify_setup
 
-      payload = { 'client_id' => @client_id,
-                  'client_secret' => @secret,
+      client_id = @client_id if client_id.blank?
+      secret = @secret if secret.blank?
+
+      payload = { 'client_id' => client_id,
+                  'client_secret' => secret,
                   'code' => code,
                   'grant_type' => 'authorization_code',
                   'redirect_uri' => redirect_uri }
@@ -52,48 +69,55 @@ module Keycloak
       mount_request_token(payload)
     end
 
-    def self.get_token_by_exchange(issuer, issuer_token)
-      setup_module 
-      
-      payload = { 'client_id' => @client_id, 'client_secret' => @secret, 'audience' => @client_id, 'grant_type' => 'urn:ietf:params:oauth:grant-type:token-exchange', 'subject_token_type' => 'urn:ietf:params:oauth:token-type:access_token', 'subject_issuer' => issuer, 'subject_token' => issuer_token }
-      header = {'Content-Type' => 'application/x-www-form-urlencoded'} 
-     _request = -> do
-        RestClient.post(@configuration['token_endpoint'], payload, header){|response, request, result| 
-        # case response.code 
-        # when 200 
-        # response.body 
-        # else 
-        # response.return! 
-        # end 
-        response.body 
-      }
+    def self.get_token_by_exchange(issuer, issuer_token, client_id = '', secret = '', token_endpoint = '')
+      setup_module
+
+      client_id = @client_id if client_id.blank?
+      secret = @secret if secret.blank?
+      token_endpoint = @configuration['token_endpoint'] if token_endpoint.blank?
+
+      payload = { 'client_id' => client_id, 'client_secret' => secret, 'audience' => client_id, 'grant_type' => 'urn:ietf:params:oauth:grant-type:token-exchange', 'subject_token_type' => 'urn:ietf:params:oauth:token-type:access_token', 'subject_issuer' => issuer, 'subject_token' => issuer_token }
+      header = { 'Content-Type' => 'application/x-www-form-urlencoded' }
+      _request = -> do
+        RestClient.post(token_endpoint, payload, header){|response, request, result|
+        # case response.code
+        # when 200
+        # response.body
+        # else
+        # response.return!
+        # end
+          response.body
+        }
       end
-       
-        exec_request _request 
+      exec_request _request
     end
 
-    def self.get_userinfo_issuer(access_token = '')
+    def self.get_userinfo_issuer(access_token = '', userinfo_endpoint = '')
       verify_setup
-      
+
+      userinfo_endpoint = @configuration['userinfo_endpoint'] if userinfo_endpoint.blank?
+
       access_token = self.token["access_token"] if access_token.empty?
       payload = { 'access_token' => access_token }
       header = { 'Content-Type' => 'application/x-www-form-urlencoded' }
       _request = -> do
-        RestClient.post(@configuration['userinfo_endpoint'], payload, header){ |response, request, result|
-          response.body 
-        } 
+        RestClient.post(userinfo_endpoint, payload, header){ |response, request, result|
+          response.body
+        }
       end
-      
-      exec_request _request 
+
+      exec_request _request
     end
 
-    def self.get_token_by_refresh_token(refresh_token = '')
+    def self.get_token_by_refresh_token(refresh_token = '', client_id = '', secret = '')
       verify_setup
 
+      client_id = @client_id if client_id.blank?
+      secret = @secret if secret.blank?
       refresh_token = self.token['refresh_token'] if refresh_token.empty?
 
-      payload = { 'client_id' => @client_id,
-                  'client_secret' => @secret,
+      payload = { 'client_id' => client_id,
+                  'client_secret' => secret,
                   'refresh_token' => refresh_token,
                   'grant_type' => 'refresh_token' }
 
@@ -103,8 +127,8 @@ module Keycloak
     def self.get_token_by_client_credentials(client_id = '', secret = '')
       setup_module
 
-      client_id = @client_id if client_id.empty?
-      secret = @secret if secret.empty?
+      client_id = @client_id if client_id.blank?
+      secret = @secret if secret.blank?
 
       payload = { 'client_id' => client_id,
                   'client_secret' => secret,
@@ -113,23 +137,24 @@ module Keycloak
       mount_request_token(payload)
     end
 
-    def self.get_token_introspection(token = '', client_id = '', secret = '')
+    def self.get_token_introspection(token = '', client_id = '', secret = '', token_introspection_endpoint = '')
       verify_setup
 
-      token = self.token["access_token"] if token.empty?
-      payload = { 'token' => token }
+      client_id = @client_id if client_id.blank?
+      secret = @secret if secret.blank?
+      token = self.token["access_token"] if token.blank?
+      token_introspection_endpoint = @configuration['token_introspection_endpoint'] if token_introspection_endpoint.blank?
 
-      client_id = @client_id if client_id.empty?
-      secret = @secret if secret.empty?
+      payload = { 'token' => token }
 
       authorization = Base64.strict_encode64("#{client_id}:#{secret}")
       authorization = "Basic #{authorization}"
 
-      header = {'Content-Type' => 'application/x-www-form-urlencoded',
-                'authorization' => authorization}
+      header = { 'Content-Type' => 'application/x-www-form-urlencoded',
+                 'authorization' => authorization }
 
       _request = -> do
-        RestClient.post(@configuration['token_introspection_endpoint'], payload, header){|response, request, result|
+        RestClient.post(token_introspection_endpoint, payload, header){|response, request, result|
           case response.code
           when 200..399
             response.body
@@ -142,31 +167,36 @@ module Keycloak
       exec_request _request
     end
 
-    def self.url_login_redirect(redirect_uri, response_type = 'code')
+    def self.url_login_redirect(redirect_uri, response_type = 'code', client_id = '', authorization_endpoint = '')
       verify_setup
 
-      p = URI.encode_www_form({ response_type: response_type, client_id: @client_id, redirect_uri: redirect_uri })
-      "#{@configuration['authorization_endpoint']}?#{p}"
+      client_id = @client_id if client_id.blank?
+      authorization_endpoint = @configuration['authorization_endpoint'] if authorization_endpoint.blank?
+
+      p = URI.encode_www_form({ response_type: response_type, client_id: client_id, redirect_uri: redirect_uri })
+      "#{authorization_endpoint}?#{p}"
     end
 
-    def self.logout(redirect_uri = '', refresh_token = '')
+    def self.logout(redirect_uri = '', refresh_token = '', client_id = '', secret = '', end_session_endpoint = '')
       verify_setup
 
       if self.token || !refresh_token.empty?
 
         refresh_token = self.token['refresh_token'] if refresh_token.empty?
+        client_id = @client_id if client_id.blank?
+        secret = @secret if secret.blank?
+        end_session_endpoint = @configuration['end_session_endpoint'] if end_session_endpoint.blank?
 
-        payload = { 'client_id' => @client_id,
-                    'client_secret' => @secret,
-                    'refresh_token' => refresh_token
-              }
+        payload = { 'client_id' => client_id,
+                    'client_secret' => secret,
+                    'refresh_token' => refresh_token }
 
-        header = {'Content-Type' => 'application/x-www-form-urlencoded'}
+        header = { 'Content-Type' => 'application/x-www-form-urlencoded' }
 
         if redirect_uri.empty?
-          final_url = @configuration['end_session_endpoint']
+          final_url = end_session_endpoint
         else
-          final_url = "#{@configuration['end_session_endpoint']}?#{URI.encode_www_form({ redirect_uri: redirect_uri })}"
+          final_url = "#{end_session_endpoint}?#{URI.encode_www_form({ redirect_uri: redirect_uri })}"
         end
 
         _request = -> do
@@ -186,17 +216,18 @@ module Keycloak
       end
     end
 
-    def self.get_userinfo(access_token = '')
+    def self.get_userinfo(access_token = '', userinfo_endpoint = '')
       verify_setup
 
       access_token = self.token["access_token"] if access_token.empty?
+      userinfo_endpoint = @configuration['userinfo_endpoint'] if userinfo_endpoint.blank?
 
       payload = { 'access_token' => access_token }
 
       header = { 'Content-Type' => 'application/x-www-form-urlencoded' }
 
       _request = -> do
-        RestClient.post(@configuration['userinfo_endpoint'], payload, header){ |response, request, result|
+        RestClient.post(userinfo_endpoint, payload, header){ |response, request, result|
           case response.code
           when 200
             response.body
@@ -215,12 +246,16 @@ module Keycloak
       "#{@auth_server_url}/realms/#{@realm}/account"
     end
 
-    def self.has_role?(user_role, access_token = '')
+    def self.has_role?(user_role, access_token = '', client_id = '', secret = '', token_introspection_endpoint = '')
       verify_setup
 
-      if user_signed_in?(access_token)
+      client_id = @client_id if client_id.blank?
+      secret = @secret if secret.blank?
+      token_introspection_endpoint = @configuration['token_introspection_endpoint'] if token_introspection_endpoint.blank?
+
+      if user_signed_in?(access_token, client_id, secret, token_introspection_endpoint)
         dt = decoded_access_token(access_token)[0]
-        dt = dt["resource_access"][@client_id]
+        dt = dt["resource_access"][client_id]
         if dt != nil
           dt["roles"].each do |role|
             return true if role.to_s == user_role.to_s
@@ -234,11 +269,15 @@ module Keycloak
       end
     end
 
-    def self.user_signed_in?(access_token = '')
+    def self.user_signed_in?(access_token = '', client_id = '', secret = '', token_introspection_endpoint = '')
       verify_setup
 
+      client_id = @client_id if client_id.blank?
+      secret = @secret if secret.blank?
+      token_introspection_endpoint = @configuration['token_introspection_endpoint'] if token_introspection_endpoint.blank?
+
       begin
-        JSON(get_token_introspection(access_token))['active'] === true
+        JSON(get_token_introspection(access_token, client_id, secret, token_introspection_endpoint))['active'] === true
       rescue => e
         if e.class < Keycloak::KeycloakException
           raise
@@ -286,8 +325,8 @@ module Keycloak
       KEYCLOACK_CONTROLLER_DEFAULT = 'session'
 
       def self.get_installation
-        if File.exists?(KEYCLOAK_JSON_FILE)
-          installation = JSON File.read(KEYCLOAK_JSON_FILE)
+        if File.exists?(Keycloak.installation_file)
+          installation = JSON File.read(Keycloak.installation_file)
           @realm = installation["realm"]
           @client_id = installation["resource"]
           @secret = installation["credentials"]["secret"]
@@ -296,7 +335,7 @@ module Keycloak
           openid_configuration
         else
           if Keycloak.realm.blank? || Keycloak.auth_server_url.blank?
-            raise "#{KEYCLOAK_JSON_FILE} and relm settings not found."
+            raise "#{Keycloak.installation_file} and relm settings not found."
           else
             @realm = Keycloak.realm
             @auth_server_url = Keycloak.auth_server_url
@@ -328,7 +367,7 @@ module Keycloak
       end
 
       def self.openid_configuration
-        RestClient.proxy = Keycloak.proxy unless Keycloak.proxy.empty?
+        RestClient.proxy = Keycloak.proxy if Keycloak.proxy.present?
         config_url = "#{@auth_server_url}/realms/#{@realm}/.well-known/openid-configuration"
         _request = -> do
           RestClient.get config_url
@@ -398,16 +437,12 @@ module Keycloak
     end
 
     def self.revoke_consent_user(id, client_id = nil, access_token = nil)
-      if client_id.nil?
-        client_id = Keycloak::Client.client_id
-      end
+      client_id = Keycloak::Client.client_id if client_id.blank?
       generic_delete("users/#{id}/consents/#{client_id}", nil, nil, access_token)
     end
 
     def self.update_account_email(id, actions, redirect_uri = '', client_id = nil, access_token = nil)
-      if client_id.nil?
-        client_id = Keycloak::Client.client_id
-      end
+      client_id = Keycloak::Client.client_id if client_id.blank?
       generic_put("users/#{id}/execute-actions-email", {:redirect_uri => redirect_uri, :client_id => client_id}, actions, access_token)
     end
 
@@ -529,7 +564,6 @@ module Keycloak
       def self.full_url(service)
         base_url + service
       end
-
   end
 
   module Internal
@@ -538,32 +572,44 @@ module Keycloak
     class << self
     end
 
-    def self.get_users(query_parameters = nil)
+    def self.get_users(query_parameters = nil, client_id = '', secret = '')
+      client_id = Keycloak::Client.client_id if client_id.blank?
+      secret = Keycloak::Client.secret if secret.blank?
+
       proc = lambda {|token|
         Keycloak::Admin.get_users(query_parameters, token["access_token"])
       }
 
-      default_call(proc)
+      default_call(proc, client_id, secret)
     end
 
-    def self.change_password(user_id, redirect_uri = '')
+    def self.change_password(user_id, redirect_uri = '', client_id = '', secret = '')
+      client_id = Keycloak::Client.client_id if client_id.blank?
+      secret = Keycloak::Client.secret if secret.blank?
+
       proc = lambda {|token|
         Keycloak.generic_request(token["access_token"],
                                  Keycloak::Admin.full_url("users/#{user_id}/execute-actions-email"),
-                                 {:redirect_uri => redirect_uri, :client_id => Keycloak::Client.client_id},
+                                 {:redirect_uri => redirect_uri, :client_id => client_id},
                                  ['UPDATE_PASSWORD'],
                                  'PUT')
       }
 
-      default_call(proc)
+      default_call(proc, client_id, secret)
     end
 
-    def self.forgot_password(user_login, redirect_uri = '')
-      user = get_user_info(user_login, true)
-      change_password(user['id'], redirect_uri)
+    def self.forgot_password(user_login, redirect_uri = '', client_id = '', secret = '')
+      client_id = Keycloak::Client.client_id if client_id.blank?
+      secret = Keycloak::Client.secret if secret.blank?
+
+      user = get_user_info(user_login, true, client_id, secret)
+      change_password(user['id'], redirect_uri, client_id, secret)
     end
 
-    def self.get_logged_user_info
+    def self.get_logged_user_info(client_id = '', secret = '')
+      client_id = Keycloak::Client.client_id if client_id.blank?
+      secret = Keycloak::Client.secret if secret.blank?
+
       proc = lambda {|token|
         userinfo = JSON Keycloak::Client.get_userinfo
         Keycloak.generic_request(token["access_token"],
@@ -571,10 +617,13 @@ module Keycloak
                                  nil, nil, 'GET')
       }
 
-      default_call(proc)
+      default_call(proc, client_id, secret)
     end
 
-    def self.get_user_info(user_login, whole_word = false)
+    def self.get_user_info(user_login, whole_word = false, client_id = '', secret = '')
+      client_id = Keycloak::Client.client_id if client_id.blank?
+      secret = Keycloak::Client.secret if secret.blank?
+
       proc = lambda { |token|
         if user_login.index('@').nil?
           search = {:username => user_login}
@@ -610,12 +659,15 @@ module Keycloak
         end
       }
 
-      default_call(proc)
+      default_call(proc, client_id, secret)
     end
 
-    def self.exists_name_or_email(value, user_id = '')
+    def self.exists_name_or_email(value, user_id = '', client_id = '', secret = '')
+      client_id = Keycloak::Client.client_id if client_id.blank?
+      secret = Keycloak::Client.secret if secret.blank?
+
       begin
-        usuario = Keycloak::Internal.get_user_info(value, true)
+        usuario = Keycloak::Internal.get_user_info(value, true, client_id, secret)
         if user_id.empty? || user_id != usuario['id']
           usuario.present?
         else
@@ -626,15 +678,20 @@ module Keycloak
       end
     end
 
-    def self.logged_federation_user?
-      info = get_logged_user_info
+    def self.logged_federation_user?(client_id = '', secret = '')
+      client_id = Keycloak::Client.client_id if client_id.blank?
+      secret = Keycloak::Client.secret if secret.blank?
+      info = get_logged_user_info(client_id, secret)
       info['federationLink'] != nil
     end
 
-    def self.create_simple_user(username, password, email, first_name, last_name, realm_roles_names, client_roles_names, proc = nil)
+    def self.create_simple_user(username, password, email, first_name, last_name, realm_roles_names, client_roles_names, proc = nil, client_id = '', secret = '')
+      client_id = Keycloak::Client.client_id if client_id.blank?
+      secret = Keycloak::Client.secret if secret.blank?
+
       begin
         username.downcase!
-        user = get_user_info(username, true)
+        user = get_user_info(username, true, client_id, secret)
         newUser = false
       rescue Keycloak::UserLoginNotFound
         newUser = true
@@ -653,7 +710,7 @@ module Keycloak
                                                 Keycloak::Admin.full_url("users/"),
                                                 nil, user_representation, 'POST')
 
-          user = get_user_info(username, true) if newUser
+          user = get_user_info(username, true, client_id, secret) if newUser
 
           credential_representation = { type: "password",
                                         temporary: false,
@@ -665,7 +722,7 @@ module Keycloak
 
             client = JSON Keycloak.generic_request(token["access_token"],
                                                    Keycloak::Admin.full_url("clients/"),
-                                                   { clientId: Keycloak::Client.client_id }, nil, 'GET')
+                                                   { clientId: client_id }, nil, 'GET')
 
             if client_roles_names.count > 0
               roles = []
@@ -708,38 +765,49 @@ module Keycloak
         end
       }
 
-      if default_call(proc_default)
+      if default_call(proc_default, client_id, secret)
         proc.call user unless proc.nil?
       end
     end
 
-    def self.create_starter_user(username, password, email, client_roles_names, proc = nil)
-      Keycloak::Internal.create_simple_user(username, password, email, '', '', [], client_roles_names, proc)
+    def self.create_starter_user(username, password, email, client_roles_names, proc = nil, client_id = '', secret = '')
+      client_id = Keycloak::Client.client_id if client_id.blank?
+      secret = Keycloak::Client.secret if secret.blank?
+      Keycloak::Internal.create_simple_user(username, password, email, '', '', [], client_roles_names, proc, client_id, secret)
     end
 
-    def self.get_client_roles
+    def self.get_client_roles(client_id = '', secret = '')
+      client_id = Keycloak::Client.client_id if client_id.blank?
+      secret = Keycloak::Client.secret if secret.blank?
+
       proc = lambda {|token|
-        client = JSON Keycloak::Admin.get_clients({ clientId: Keycloak::Client.client_id }, token["access_token"])
+        client = JSON Keycloak::Admin.get_clients({ clientId: client_id }, token["access_token"])
 
         Keycloak.generic_request(token["access_token"],
                                  Keycloak::Admin.full_url("clients/#{client[0]['id']}/roles"),
                                  nil, nil, 'GET')
       }
 
-      default_call(proc)
+      default_call(proc, client_id, secret)
     end
 
-    def self.get_client_user_roles(user_id)
+    def self.get_client_user_roles(user_id, client_id = '', secret = '')
+      client_id = Keycloak::Client.client_id if client_id.blank?
+      secret = Keycloak::Client.secret if secret.blank?
+
       proc = lambda {|token|
-        client = JSON Keycloak::Admin.get_clients({ clientId: Keycloak::Client.client_id }, token["access_token"])
+        client = JSON Keycloak::Admin.get_clients({ clientId: client_id }, token["access_token"])
         Keycloak::Admin.get_effective_client_level_role_composite_user(user_id, client[0]['id'], token["access_token"])
       }
 
-      default_call(proc)
+      default_call(proc, client_id, secret)
     end
 
-    def self.has_role?(user_id, user_role)
-      roles = JSON get_client_user_roles(user_id)
+    def self.has_role?(user_id, user_role, client_id = '', secret = '')
+      client_id = Keycloak::Client.client_id if client_id.blank?
+      secret = Keycloak::Client.secret if secret.blank?
+
+      roles = JSON get_client_user_roles(user_id, client_id, secret)
       if !roles.nil?
         roles.each do |role|
           return true if role['name'].to_s == user_role.to_s
@@ -752,15 +820,17 @@ module Keycloak
 
     protected
 
-      def self.default_call(proc)
+      def self.default_call(proc, client_id = '', secret = '')
+        client_id = Keycloak::Client.client_id if client_id.blank?
+        secret = Keycloak::Client.secret if secret.blank?
         begin
           tk = nil
           resp = nil
 
           Keycloak::Client.get_installation
 
-          payload = { 'client_id' => Keycloak::Client.client_id,
-                      'client_secret' => Keycloak::Client.secret,
+          payload = { 'client_id' => client_id,
+                      'client_secret' => secret,
                       'grant_type' => 'client_credentials' }
 
           header = {'Content-Type' => 'application/x-www-form-urlencoded'}
@@ -780,8 +850,8 @@ module Keycloak
           Keycloak::Client.exec_request _request
         ensure
           if tk
-            payload = { 'client_id' => Keycloak::Client.client_id,
-                        'client_secret' => Keycloak::Client.secret,
+            payload = { 'client_id' => client_id,
+                        'client_secret' => secret,
                         'refresh_token' => tk["refresh_token"] }
 
             header = {'Content-Type' => 'application/x-www-form-urlencoded'}

data/lib/keycloak/exceptions.rb

@@ -3,4 +3,5 @@ module Keycloak
     class UserLoginNotFound < KeycloakException; end
     class ProcCookieTokenNotDefined < KeycloakException; end
     class ProcExternalAttributesNotDefined < KeycloakException; end
+    class InstallationFileNotFound < KeycloakException; end
 end

data/lib/keycloak/version.rb

@@ -1,3 +1,3 @@
 module Keycloak
-  VERSION = "2.3.2"
+  VERSION = "2.4.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: keycloak
 version: !ruby/object:Gem::Version
-  version: 2.3.2
+  version: 2.4.0
 platform: ruby
 authors:
 - Guilherme Portugues
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-04-06 00:00:00.000000000 Z
+date: 2018-12-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -140,7 +140,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.7.3
+rubygems_version: 2.7.7
 signing_key: 
 specification_version: 4
 summary: Add authentication to applications and secure services with Keycloak