keycloak 2.2.1 → 2.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d5c9d602c2e3293471963d545dbee24cc6fd3809
-  data.tar.gz: c1dfa2841bf345cb4b779d200ce665484ea410a9
+  metadata.gz: b4049ff4cd3aa28843c716f1087015fe93b8f293
+  data.tar.gz: dfd32b98b0dde41107f0dbd9b93c0031bf76fc47
 SHA512:
-  metadata.gz: '055529d1d998ccaf4923eb9d95e37f2253bc3248702dc3cb1094f917bfd1e85ff7ff7fcac97e853e3415129e3d186cd8852106a6a41fd61245ef899d0c5af19e'
-  data.tar.gz: 63af48c60747368bfbeab593e4636c2f407bf038464db76d623a24112a026538f8a9ddca666eb54ae45cca89ab96b3b645a8cd80068593af27ccd116fa296240
+  metadata.gz: b14927bbff9d4213c5b36cb0ebe5d78b887d1106183a71a363c8996b972fc3f32481ec7d3986658f3326b5a7764e9af7619e52d29f4fa188fdbe79f3075e5158
+  data.tar.gz: a21406c6aa9ed8406c86dc8a256a323c671173ef042a2d4229e24fc9679b3692d58c18c1e5cb6c39184f88ac4f1288ee899310be6bdd5424f01dea17a00066a4

data/README.md

@@ -3,22 +3,191 @@ A gem Keycloak foi desenvolvida para integrar aplicações e serviços ao sistem
 
 O seu desenvolvimento foi baseado na versão 3.2 do Keycloak, cuja documentação pode ser encontrada [aqui](http://www.keycloak.org/archive/documentation-3.2.html).
 
-## Installation
+## Instalação
 
-Add this line to your application's Gemfile:
+Adicione esta linha no <b>Gemfile</b> de sua aplicação:
 
 ```ruby
 gem 'keycloak'
 ```
 
-And then execute:
+Então execute:
 
     $ bundle
 
-Or install it yourself as:
+Ou instale você mesmo:
 
     $ gem install keycloak
 
-## Usage
+## Utilização
 
-TODO: Write usage instructions here
+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, será necessário 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>.
+
+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>.
+
+### Module Keycloak
+
+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.proxy
+```
+
+Caso o ambiente onde a sua aplicação será utilizada exija a utilização de proxy para o consumo das APIs do Keycloak, então defina-o neste atributo. Ao ser instalada, a gem cria o arquivo `keycloak.rb` em `config/initializers`. Este atributo pode ser encontrado e definido nesse arquivo.
+
+```ruby
+Keycloak.generate_request_exception
+```
+
+Este atributo serve para definir se as exceções HTTP geradas nos retornos das requisições feitas para o Keycloak serão ou não estouradas na aplicação. Caso definido como `false`, então a exceção não será estourada e a resposta HTTP será retornada para a aplicação fazer o seu próprio tratamento. O valor default deste atributo é `true`. Ao ser instalada, a gem cria o arquivo `keycloak.rb` em `config/initializers`. Este atributo pode ser encontrado e definido nesse arquivo.
+
+
+```ruby
+Keycloak.keycloak_controller
+```
+
+É recomendado que a sua aplicação possua um controller que centraliza as ações de sessão que o Keycloak irá gerenciar, tais como a ação de login, logout, atualização de sessão, reset de senha, entre outras. Defina neste atributo qual é o nome do controller que desempenhará esse papel. Se o nome do seu controler é `SessionController`, então o valor deste atributo deverá ser apenas `session`. Ao ser instalada, a gem cria o arquivo `keycloak.rb` em `config/initializers`. Este atributo pode ser encontrado e definido nesse arquivo.
+
+
+```ruby
+Keycloak.proc_cookie_token
+```
+
+Este atributo trata-se de um método anônimo (lâmbida). O mesmo deve ser implementado na aplicação para que a gem tenha acesso ao token de autenticação que, por sua vez, deverá ser armazenado no cookie. Ao realizar a autenticação no keycloak através da gem, o sistema deverá armazenar o token retornado no cookie do browser, como por exemplo: 
+```ruby
+cookies.permanent[:keycloak_token] = Keycloak::Client.get_token(params[:user_login], params[:user_password])
+```
+A aplicação poderá recuperar o token no cookie implementando o método `Keycloak.proc_cookie_token` da seguinte forma:
+```ruby
+Keycloak.proc_cookie_token = -> do
+  cookies.permanent[:keycloak_token]
+end
+```
+Desta forma, todas as vezes que a gem precisar utilizar as informações do token para consumir um serviço do Keycloak, ele irá invocar este método lâmbida.
+
+
+```ruby
+Keycloak.proc_external_attributes
+```
+
+O Keycloak dá a possibilidade de que novos atributos sejam mapeados no cadastro de usuários. Porém, quando esses atributos são específicos da aplicação, recomenda-se que a própria os gerencie. Para isso, a melhor solução é criar esses atributos na aplicação - exemplo: criar uma tabela no banco de dados da própria aplicação contendo as colunas representando cada um dos atributos, inserindo também nessa tabela uma coluna de identificação única (unique key), contendo na mesma o Id do usuário criado no Keycloak, indicando que esse pertencente àquele Id possui aqueles atributos.
+Para que a gem tenha acesso a esses atributos, definina o atributo`Keycloak.proc_external_attributes` com um método lâmbida obtendo do `model` os atributos do usuário logado. Exemplo:
+```ruby
+Keycloak.proc_external_attributes = -> do
+  atributos = UsuariosAtributo.find_or_create_by(user_keycloak_id: Keycloak::Client.get_attribute('sub'))
+  if atributos.status.nil?
+    atributos.status = false
+    atributos.save
+  end
+  atributos
+end
+```
+
+<b>Observação:</b> Os atributos `Keycloak.proc_cookie_token` e `Keycloak.proc_external_attributes` podem ser definidos no `initialize` do controler `ApplicationController`.
+
+
+### Client
+
+Esse módulo possui os métodos que representam as APIs de <b>endpoints</b>. Esses serviços são fundamentais para a criação e atualização de tokens, efetuação de login e logout, e, também para a obtenção de informações sintéticas de um usuário logado. O que habilita a gem a fazer uso de todos esses serviços é o arquivo de instalação do client citado anteriormente.
+
+Vamos ao detalhamento de cada um desses métodos:
+
+
+```ruby
+Keycloak::Client.get_token(user, password)
+```
+
+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`.
+
+
+```ruby
+Keycloak::Client.url_login_redirect(redirect_uri, response_type = 'code')
+```
+
+Para efetuar a autenticação dos usuários de sua aplicação utilizando um template configurado no Keycloak, redirecione a requisição para a url retornada nesse método. Passe como parâmetro a url que o usuário terá acesso no caso de êxito na autenticação(`redirect_uri`) e também o tipo de resposta (`response_type`), que caso não informado, a gem assumirá o valor `code`. Caso a autenticação seja bem sucedida, então será retornado um `code` que te habilitará a requisitar um token ao Keycloak.
+
+
+```ruby
+Keycloak::Client.get_token_by_code(code, redirect_uri)
+```
+
+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_refresh_token(refresh_token = '')
+```
+
+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 = '')
+```
+
+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.
+
+
+```ruby
+Keycloak::Client.get_token_by_client_credentials(client_id = '', secret = '')
+```
+
+Há alguns serviços do Keycloak como <b>reset de senha</b>, <b>cadastro de usuário</b> na tela inicial da aplicação ou até mesmo autenticação seguindo o padrão <b>OAuth 2.0</b>, que a autenticação de um usuário torna-se desnecessária. Sendo assim, podemos obter um token utilizando as credenciais da sua própria aplicação (Client) cadastrada no Keycloak. Para obter esse token, deve-se passar como parâmetro desse método o `client_id` - informado pela pessoa que cadastrou sua aplicação no Keycloak - e a `secret` de sua aplicação gerado pelo Keycloak - para gerar uma `secret`, o <b>Access Type</b> do seu Client (Aplicação) deverá estar configurado como `confidential`. Caso você não passe nenhum desses parãmetros, a gem utilizará as credenciais contidas no arquivo de instalação citado anteriormente.
+
+
+```ruby
+Keycloak::Client.logout(redirect_uri = '', refresh_token = '')
+```
+
+Quando utilizado antes da expiração da sessão do usuário logado, esse método encerra a sessão. Se o prâ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 = '')
+```
+
+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. Cado o parâmetro `access_token` não seja informado, então a gem obterá essa informação no cookie.
+
+
+```ruby
+Keycloak::Client.url_user_account
+```
+
+Retorna a <b>url</b> para acesso ao cadastro de usuários do Reino do arquivo de instalação (`keycloak.json`). Para ter acesso a tela, o Keycloak exigirá a autenticação do usuário. Após logado, e caso tenha permissão, o usuário terá acesso a suas informações cadastrais podendo inclusive alterá-las.
+
+
+```ruby
+Keycloak::Client.has_role?(user_role, access_token = '')
+```
+
+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 = '')
+```
+
+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.
+
+
+```ruby
+Keycloak::Client.get_attribute(attribute_name, access_token = '')
+```
+
+Esse método decodifica o JWT `access_token` e retorna o valor do atributo de nome passado no parâmetro `attribute_name`. Esse atributo pode ser um <b>mapper</b> - cadastrado na seção <b>Mappers</b> do cadastro do <b>Client</b> do Reino. Caso o `access_token` não seja informado, então a gem utilizará o `access_token` do cookie.
+
+
+```ruby
+Keycloak::Client.token
+```
+
+Retorna o último token autenticado armazenado no cookie. Quando na aplicação é implementado o método `Keycloak.proc_cookie_token` e um usuário faz a autenticação da aplicação, esse método retornará o token desse usuário.
+
+
+```ruby
+Keycloak::Client.external_attributes
+```
+
+Quando implementado o método `Keycloak.proc_external_attributes`, o método `external_attributes` o retornará. A finalidade desse método é retornar os atributos específicos da aplicação não mapeados no Keycloak.

data/lib/keycloak.rb

@@ -51,14 +51,14 @@ module Keycloak
       mount_request_token(payload)
     end
 
-    def self.get_token_by_refresh_token(refreshToken = '')
+    def self.get_token_by_refresh_token(refresh_token = '')
       verify_setup
 
-      refreshToken = self.token['refresh_token'] if refreshToken.empty?
+      refresh_token = self.token['refresh_token'] if refresh_token.empty?
 
       payload = { 'client_id' => @client_id,
                   'client_secret' => @secret,
-                  'refresh_token' => refreshToken,
+                  'refresh_token' => refresh_token,
                   'grant_type' => 'refresh_token' }
 
       mount_request_token(payload)
@@ -149,12 +149,12 @@ module Keycloak
       end
     end
 
-    def self.get_userinfo(accessToken = '')
+    def self.get_userinfo(access_token = '')
       verify_setup
 
-      accessToken = self.token["access_token"] if accessToken.empty?
+      access_token = self.token["access_token"] if access_token.empty?
 
-      payload = { 'access_token' => accessToken }
+      payload = { 'access_token' => access_token }
 
       header = { 'Content-Type' => 'application/x-www-form-urlencoded' }
 
@@ -178,15 +178,15 @@ module Keycloak
       "#{@url}/realms/#{@realm}/account"
     end
 
-    def self.has_role?(userRole, accessToken = '')
+    def self.has_role?(user_role, access_token = '')
       verify_setup
 
-      if user_signed_in?(accessToken)
-        dt = decoded_access_token(accessToken)[0]
+      if user_signed_in?(access_token)
+        dt = decoded_access_token(access_token)[0]
         dt = dt["resource_access"][@client_id]
         if dt != nil
           dt["roles"].each do |role|
-            return true if role.to_s == userRole.to_s
+            return true if role.to_s == user_role.to_s
           end
           false
         else
@@ -197,11 +197,11 @@ module Keycloak
       end
     end
 
-    def self.user_signed_in?(accessToken = '')
+    def self.user_signed_in?(access_token = '')
       verify_setup
 
       begin
-        JSON(get_token_introspection(accessToken))['active'] === true
+        JSON(get_token_introspection(access_token))['active'] === true
       rescue => e
         if e.class < Keycloak::KeycloakException
           raise
@@ -211,10 +211,10 @@ module Keycloak
       end
     end
 
-    def self.get_attribute(attributeName, accessToken = '')
+    def self.get_attribute(attributeName, access_token = '')
       verify_setup
 
-      attr = decoded_access_token(accessToken)[0]
+      attr = decoded_access_token(access_token)[0]
       attr[attributeName]
     end
 
@@ -306,14 +306,14 @@ module Keycloak
         exec_request _request
       end
 
-      def self.decoded_access_token(accessToken = '')
-        accessToken = self.token["access_token"] if accessToken.empty?
-        JWT.decode accessToken, @public_key, false, { :algorithm => 'RS256' }
+      def self.decoded_access_token(access_token = '')
+        access_token = self.token["access_token"] if access_token.empty?
+        JWT.decode access_token, @public_key, false, { :algorithm => 'RS256' }
       end
 
-      def self.decoded_refresh_token(refreshToken = '')
-        refreshToken = self.token["access_token"] if refreshToken.empty?
-        JWT.decode refreshToken, @public_key, false, { :algorithm => 'RS256' }
+      def self.decoded_refresh_token(refresh_token = '')
+        refresh_token = self.token["access_token"] if refresh_token.empty?
+        JWT.decode refresh_token, @public_key, false, { :algorithm => 'RS256' }
       end
 
       def self.decoded_id_token(idToken = '')
@@ -331,97 +331,97 @@ module Keycloak
     class << self
     end
 
-    def self.get_users(queryParameters = nil, accessToken = nil)
-      generic_get("users/", queryParameters, accessToken)
+    def self.get_users(query_parameters = nil, access_token = nil)
+      generic_get("users/", query_parameters, access_token)
     end
 
-    def self.create_user(userRepresentation, accessToken = nil)
-      generic_post("users/", nil, userRepresentation, accessToken)
+    def self.create_user(user_representation, access_token = nil)
+      generic_post("users/", nil, user_representation, access_token)
     end
 
-    def self.count_users(accessToken = nil)
-      generic_get("users/count/", nil, accessToken)
+    def self.count_users(access_token = nil)
+      generic_get("users/count/", nil, access_token)
     end
 
-    def self.get_user(id, accessToken = nil)
-      generic_get("users/#{id}", nil, accessToken)
+    def self.get_user(id, access_token = nil)
+      generic_get("users/#{id}", nil, access_token)
     end
 
-    def self.update_user(id, userRepresentation, accessToken = nil)
-      generic_put("users/#{id}", nil, userRepresentation, accessToken)
+    def self.update_user(id, user_representation, access_token = nil)
+      generic_put("users/#{id}", nil, user_representation, access_token)
     end
 
-    def self.delete_user(id, accessToken = nil)
-      generic_delete("users/#{id}", nil, nil, accessToken)
+    def self.delete_user(id, access_token = nil)
+      generic_delete("users/#{id}", nil, nil, access_token)
     end
 
-    def self.revoke_consent_user(id, clientID = nil, accessToken = nil)
-      if clientID.nil?
-        clientID = Keycloak::Client.client_id
+    def self.revoke_consent_user(id, client_id = nil, access_token = nil)
+      if client_id.nil?
+        client_id = Keycloak::Client.client_id
       end
-      generic_delete("users/#{id}/consents/#{clientID}", nil, nil, accessToken)
+      generic_delete("users/#{id}/consents/#{client_id}", nil, nil, access_token)
     end
 
-    def self.update_account_email(id, actions, redirectUri = '', clientID = nil, accessToken = nil)
-      if clientID.nil?
-        clientID = Keycloak::Client.client_id
+    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
-      generic_put("users/#{id}/execute-actions-email", {:redirect_uri => redirectUri, :client_id => clientID}, actions, accessToken)
+      generic_put("users/#{id}/execute-actions-email", {:redirect_uri => redirect_uri, :client_id => client_id}, actions, access_token)
     end
 
-    def self.get_role_mappings(id, accessToken = nil)
-      generic_get("users/#{id}/role-mappings", nil, accessToken)
+    def self.get_role_mappings(id, access_token = nil)
+      generic_get("users/#{id}/role-mappings", nil, access_token)
     end
 
-    def self.get_clients(queryParameters = nil, accessToken = nil)
-      generic_get("clients/", queryParameters, accessToken)
+    def self.get_clients(query_parameters = nil, access_token = nil)
+      generic_get("clients/", query_parameters, access_token)
     end
 
-    def self.get_all_roles_client(id, accessToken = nil)
-      generic_get("clients/#{id}/roles", nil, accessToken)
+    def self.get_all_roles_client(id, access_token = nil)
+      generic_get("clients/#{id}/roles", nil, access_token)
     end
 
-    def self.get_roles_client_by_name(id, roleName, accessToken = nil)
-      generic_get("clients/#{id}/roles/#{roleName}", nil, accessToken)
+    def self.get_roles_client_by_name(id, role_name, access_token = nil)
+      generic_get("clients/#{id}/roles/#{role_name}", nil, access_token)
     end
 
-    def self.add_client_level_roles_to_user(id, client, roleRepresentation, accessToken = nil)
-      generic_post("users/#{id}/role-mappings/clients/#{client}", nil, roleRepresentation, accessToken)
+    def self.add_client_level_roles_to_user(id, client, role_representation, access_token = nil)
+      generic_post("users/#{id}/role-mappings/clients/#{client}", nil, role_representation, access_token)
     end
 
-    def self.delete_client_level_roles_from_user(id, client, roleRepresentation, accessToken = nil)
-      generic_delete("users/#{id}/role-mappings/clients/#{client}", nil, roleRepresentation, accessToken)
+    def self.delete_client_level_roles_from_user(id, client, role_representation, access_token = nil)
+      generic_delete("users/#{id}/role-mappings/clients/#{client}", nil, role_representation, access_token)
     end
 
-    def self.get_client_level_role_for_user_and_app(id, client, accessToken = nil)
-      generic_get("users/#{id}/role-mappings/clients/#{client}", nil, accessToken)
+    def self.get_client_level_role_for_user_and_app(id, client, access_token = nil)
+      generic_get("users/#{id}/role-mappings/clients/#{client}", nil, access_token)
     end
 
-    def self.update_effective_user_roles(id, clientID, rolesNames, accessToken = nil)
-      client = JSON get_clients({ clientId: clientID })
+    def self.update_effective_user_roles(id, client_id, rolesNames, access_token = nil)
+      client = JSON get_clients({ clientId: client_id })
 
-      userRoles = JSON get_client_level_role_for_user_and_app(id, client[0]['id'], accessToken)
+      user_roles = JSON get_client_level_role_for_user_and_app(id, client[0]['id'], access_token)
 
       roles = Array.new
       # Include new role
       rolesNames.each do |r|
         if r && !r.empty?
           found = false
-          userRoles.each do |ur|
+          user_roles.each do |ur|
             found = ur['name'] == r
             break if found
             found = false
           end
           if !found
-            role = JSON get_roles_client_by_name(client[0]['id'], r, accessToken)
+            role = JSON get_roles_client_by_name(client[0]['id'], r, access_token)
             roles.push(role)
           end
         end
       end
 
-      garbageRoles = Array.new
+      garbage_roles = Array.new
       # Exclude old role
-      userRoles.each do |ur|
+      user_roles.each do |ur|
         found = false
         rolesNames.each do |r|
           if r && !r.empty?
@@ -431,43 +431,43 @@ module Keycloak
           end
         end
         if !found
-          garbageRoles.push(ur)
+          garbage_roles.push(ur)
         end
       end
 
-      if garbageRoles.count > 0
-        delete_client_level_roles_from_user(id, client[0]['id'], garbageRoles, accessToken)
+      if garbage_roles.count > 0
+        delete_client_level_roles_from_user(id, client[0]['id'], garbage_roles, access_token)
       end
 
       if roles.count > 0
-        add_client_level_roles_to_user(id, client[0]['id'], roles, accessToken)
+        add_client_level_roles_to_user(id, client[0]['id'], roles, access_token)
       end
     end
 
-    def self.reset_password(id, credentialRepresentation, accessToken = nil)
-      generic_put("users/#{id}/reset-password", nil, credentialRepresentation, accessToken)
+    def self.reset_password(id, credentialRepresentation, access_token = nil)
+      generic_put("users/#{id}/reset-password", nil, credentialRepresentation, access_token)
     end
 
-    def self.get_effective_client_level_role_composite_user(id, client, accessToken = nil)
-      generic_get("users/#{id}/role-mappings/clients/#{client}/composite", nil, accessToken)
+    def self.get_effective_client_level_role_composite_user(id, client, access_token = nil)
+      generic_get("users/#{id}/role-mappings/clients/#{client}/composite", nil, access_token)
     end
 
     # Generics methods
 
-    def self.generic_get(service, queryParameters = nil, accessToken = nil)
-      Keycloak.generic_request(effective_access_token(accessToken), full_url(service), queryParameters, nil, 'GET')
+    def self.generic_get(service, query_parameters = nil, access_token = nil)
+      Keycloak.generic_request(effective_access_token(access_token), full_url(service), query_parameters, nil, 'GET')
     end
 
-    def self.generic_post(service, queryParameters, bodyParameter, accessToken = nil)
-      Keycloak.generic_request(effective_access_token(accessToken), full_url(service), queryParameters, bodyParameter, 'POST')
+    def self.generic_post(service, query_parameters, body_parameter, access_token = nil)
+      Keycloak.generic_request(effective_access_token(access_token), full_url(service), query_parameters, body_parameter, 'POST')
     end
 
-    def self.generic_put(service, queryParameters, bodyParameter, accessToken = nil)
-      Keycloak.generic_request(effective_access_token(accessToken), full_url(service), queryParameters, bodyParameter, 'PUT')
+    def self.generic_put(service, query_parameters, body_parameter, access_token = nil)
+      Keycloak.generic_request(effective_access_token(access_token), full_url(service), query_parameters, body_parameter, 'PUT')
     end
 
-    def self.generic_delete(service, queryParameters = nil, bodyParameter = nil, accessToken = nil)
-      Keycloak.generic_request(effective_access_token(accessToken), full_url(service), queryParameters, bodyParameter, 'DELETE')
+    def self.generic_delete(service, query_parameters = nil, body_parameter = nil, access_token = nil)
+      Keycloak.generic_request(effective_access_token(access_token), full_url(service), query_parameters, body_parameter, 'DELETE')
     end
 
     private
@@ -496,19 +496,19 @@ module Keycloak
     class << self
     end
 
-    def self.get_users(queryParameters = nil)
+    def self.get_users(query_parameters = nil)
       proc = lambda {|token|
-        Keycloak::Admin.get_users(queryParameters, token["access_token"])
+        Keycloak::Admin.get_users(query_parameters, token["access_token"])
       }
 
       default_call(proc)
     end
 
-    def self.change_password(userID, redirectURI = '')
+    def self.change_password(user_id, redirect_uri = '')
       proc = lambda {|token|
         Keycloak.generic_request(token["access_token"],
-                                 Keycloak::Admin.full_url("users/#{userID}/execute-actions-email"),
-                                 {:redirect_uri => redirectURI, :client_id => Keycloak::Client.client_id},
+                                 Keycloak::Admin.full_url("users/#{user_id}/execute-actions-email"),
+                                 {:redirect_uri => redirect_uri, :client_id => Keycloak::Client.client_id},
                                  ['UPDATE_PASSWORD'],
                                  'PUT')
       }
@@ -516,9 +516,9 @@ module Keycloak
       default_call(proc)
     end
 
-    def self.forgot_password(userLogin, redirectURI = '')
-      user = get_user_info(userLogin, true)
-      change_password(user['id'], redirectURI)
+    def self.forgot_password(user_login, redirect_uri = '')
+      user = get_user_info(user_login, true)
+      change_password(user['id'], redirect_uri)
     end
 
     def self.get_logged_user_info
@@ -532,12 +532,12 @@ module Keycloak
       default_call(proc)
     end
 
-    def self.get_user_info(userLogin, wholeWord = false)
+    def self.get_user_info(user_login, whole_word = false)
       proc = lambda { |token|
-        if userLogin.index('@').nil?
-          search = {:username => userLogin}
+        if user_login.index('@').nil?
+          search = {:username => user_login}
         else
-          search = {:email => userLogin}
+          search = {:email => user_login}
         end
         users = JSON Keycloak.generic_request(token["access_token"],
                                               Keycloak::Admin.full_url("users/"),
@@ -548,8 +548,8 @@ module Keycloak
         else
           efective_index = -1
           users.each_with_index do |user, i|
-            if wholeWord
-              efective_index = i if userLogin == user['username'] || userLogin == user['email']
+            if whole_word
+              efective_index = i if user_login == user['username'] || user_login == user['email']
             else
               efective_index = 0
             end
@@ -557,7 +557,7 @@ module Keycloak
           end
 
           if efective_index >= 0
-            if wholeWord
+            if whole_word
               users[efective_index]
             else
               users
@@ -576,9 +576,9 @@ module Keycloak
       info['federationLink'] != nil
     end
 
-    def self.create_starter_user(userName, password, email, clientRolesNames, proc = nil)
+    def self.create_starter_user(username, password, email, client_roles_names, proc = nil)
       begin
-        user = get_user_info(userName, true)
+        user = get_user_info(username, true)
         newUser = false
       rescue Keycloak::UserLoginNotFound
         newUser = true
@@ -587,7 +587,7 @@ module Keycloak
       end
 
       proc_default = lambda { |token|
-        user_representation = { username: userName,
+        user_representation = { username: username,
                                 email: email,
                                 enabled: true }
 
@@ -595,7 +595,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) if newUser
 
           credential_representation = { type: "password",
                                         temporary: false,
@@ -610,7 +610,7 @@ module Keycloak
                                                    { clientId: Keycloak::Client.client_id }, nil, 'GET')
 
             roles = []
-            clientRolesNames.each do |r|
+            client_roles_names.each do |r|
               if r.present?
                 role = JSON Keycloak.generic_request(token["access_token"],
                                                      Keycloak::Admin.full_url("clients/#{client[0]['id']}/roles/#{r}"),
@@ -646,20 +646,20 @@ module Keycloak
       default_call(proc)
     end
 
-    def self.get_client_user_roles(userID)
+    def self.get_client_user_roles(user_id)
       proc = lambda {|token|
         client = JSON Keycloak::Admin.get_clients({ clientId: Keycloak::Client.client_id }, token["access_token"])
-        Keycloak::Admin.get_effective_client_level_role_composite_user(userID, client[0]['id'], token["access_token"])
+        Keycloak::Admin.get_effective_client_level_role_composite_user(user_id, client[0]['id'], token["access_token"])
       }
 
       default_call(proc)
     end
 
-    def self.has_role?(userID, userRole)
-      roles = JSON get_client_user_roles(userID)
+    def self.has_role?(user_id, user_role)
+      roles = JSON get_client_user_roles(user_id)
       if !roles.nil?
         roles.each do |role|
-          return true if role['name'].to_s == userRole.to_s
+          return true if role['name'].to_s == user_role.to_s
         end
         false
       else
@@ -721,15 +721,15 @@ module Keycloak
 
   private
 
-    def self.generic_request(accessToken, uri, queryParameters, bodyParameter, method)
+    def self.generic_request(access_token, uri, query_parameters, body_parameter, method)
       Keycloak::Client.verify_setup
       final_url = uri
 
       header = {'Content-Type' => 'application/x-www-form-urlencoded',
-                'Authorization' => "Bearer #{accessToken}"}
+                'Authorization' => "Bearer #{access_token}"}
 
-      if queryParameters
-        parameters = URI.encode_www_form(queryParameters)
+      if query_parameters
+        parameters = URI.encode_www_form(query_parameters)
         final_url = final_url << '?' << parameters
       end
 
@@ -742,7 +742,7 @@ module Keycloak
         end
       when 'POST', 'PUT'
         header["Content-Type"] = 'application/json'
-        parameters = JSON.generate bodyParameter
+        parameters = JSON.generate body_parameter
         _request = -> do
           case method.upcase
           when 'POST'
@@ -757,9 +757,9 @@ module Keycloak
         end
       when 'DELETE'
         _request = -> do
-          if bodyParameter
+          if body_parameter
             header["Content-Type"] = 'application/json'
-            parameters = JSON.generate bodyParameter
+            parameters = JSON.generate body_parameter
             RestClient::Request.execute(method: :delete, url: final_url,
                           payload: parameters, headers: header) { |response, request, result|
               rescue_response(response)

data/lib/keycloak/version.rb

@@ -1,3 +1,3 @@
 module Keycloak
-  VERSION = "2.2.1"
+  VERSION = "2.2.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: keycloak
 version: !ruby/object:Gem::Version
-  version: 2.2.1
+  version: 2.2.2
 platform: ruby
 authors:
 - Guilherme Portugues
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-09-01 00:00:00.000000000 Z
+date: 2017-09-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler