slots-jwt 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 839d8b81d5e72a4e4034aa14fcbf8ba479f7137d35e3ac31ff3f853a780f8925
-  data.tar.gz: 1c0b98884bb29be89fa2900ae627c08f7a9aa17871ec161643388b3a22ed0e16
+  metadata.gz: f9ef8bc2c373d7fd9558bdf34f137778f20554f1569a6cab5bc71360a219c9ba
+  data.tar.gz: e63b72c4ff710c3f632eb799aa5339038717ab6a6285c6a46c2f0b7b7baffe4f
 SHA512:
-  metadata.gz: 5073aed2a69fae5b4b03bd531030943e8c31c0d908a69ae3843db4c91b0531c68135ff7096865edcf6c33875a4eff86738871d2e21443cd35109a4683fd9b9de
-  data.tar.gz: 42d073d5a20f7aab3e066825b9e058f90a9342fb19093170a7853190ac8c18193c14f6db1a0b636ddfd9abd2e8186583f5fe844e4aed470c65d216593a1d5037
+  metadata.gz: 42247e6c390d46dedc038a9cb85eed133ce6ff8951d2d0a882c5bdc4e73aec5b336fb5e96d20b770e2e463718bd57995e6dea42b7da26a0c76a9437b344fd10f
+  data.tar.gz: 600d9578cf4e4e819d71a851dbf7d4ed40a7776c209474daf4d398729ec927df0ed2325041241e3b5d48e36863294308558a2f33d4cef88d413306783ce9fa61

data/README.md

@@ -12,6 +12,7 @@ Token authentication solution for rails 5 API. Slots use JSON Web Tokens for aut
 - [Testing](#testing)
 - [Configurations](#configurations)
 - [Routes](#routes)
+- [Login Hooks](#login-hooks)
 - [Contributing](#contributing)
 - [License](#license)
 
@@ -104,10 +105,11 @@ ignore_login!
 ```
 This takes all the same options as `require_login!`.
 
+### Reject new tokens
 To not allow a user to sign in the following can be used in the authentication model:
 ```ruby
 class User < ApplicationRecord
-  slots :database_authentication
+  ...
 
   reject_new_token do
     !self.approved # Return true if they cannot get a new token
@@ -116,6 +118,29 @@ end
 ```
 This will not allow unapproved users to get a new token (login or update_session_token).
 
+### Login Hooks
+To run certain methods on failed/successful logins there are hooks:
+```ruby
+class User < ApplicationRecord
+  ...
+
+  failed_login do
+    # This method will be called on failed logins even if they
+    # do not have valid login identifier so might need to check
+    # if its an actual user by:
+    # next if new_record?
+    some_failed_login_stuff
+  end
+
+  successful_login do
+    # Do something with
+    some_successful_login_stuff
+  end
+end
+```
+NOTE: `failed_login` will get called if `reject_new_token` is true
+
+
 ## Authorization
 Sometimes when dealing with authentication you also need authorization. While in most cases you should use another gem to handle this, if it is simple (like an admin or approved user) slots can handle it. Just add the following:
 ```ruby
@@ -143,9 +168,10 @@ A custom message or status can be returned using the following:
 catch_invalid_token(response: {my_message: 'Some custom message'}, status: :im_a_teapot)
 ```
 NOTE: If you want the token to be rejected for all tokens (i.e. require all routes to have an approved user) add the above to the `ApplicationController`. You can then also add more specific requirements to a controller by also adding it in the controller like requiring an admin. To ignore a `reject_token` use `skip_callback!` which again takes the same params as `before_action`.
+WARNING: If you do not require the user to be loaded from the DB the `admin` field will be from the JWT.
 
 ## Sessions
-If sessions are allowed (`session_lifetime` is not nil) `session: true` can be passed along when signing in to receive a session token. A session tokens has a the session id in the payload of the JWT. This is kept in the JWT so the front-end only has to track one token. There are two ways to get a new token after a session token has expired.
+If sessions are allowed (`session_lifetime` is not nil) `session: true` can be passed along when signing in to receive a session token. A session tokens has the session id in the payload of the JWT. This is kept in the JWT so the front-end only has to track one token. There are two ways to get a new token after a session token has expired.
   1. The first is by sending the token to `MOUNT_LOCATION/update_session_token`. This method will always return a new token even if the token has not expired. This will return the same information as `sign_in` (user information and with the token in the header).
   2. The second is by adding `update_expired_session_tokens!` (which takes the usual options of a `before_action` `only`, `except`, etc). This method will allow any route to take a valid expired token and it will return a new token in the headers with usual route information in the body. A token will only be returned in the header if the token passed is expired. When using this method a problem can arise were two request are made at the same time with the same expired token. The first request processed would return a new token but the second request would fail because the expired token does not match the information of the session anymore (since it was just updated) and would therefore return unauthorized. To fix this there is a previous jwt lifetime (which defaults to 5 seconds and can be changed in the config). This will allow the previous token to be valid for 5 seconds (or whatever is set in config). If a previous token is sent that is within the previous lifetime it will be a valid token but it will not return a new token (since one was already returned in the earlier request).
 
@@ -210,7 +236,7 @@ end
 ### Filter
 Filter must be used with at least one of the above.
 ```ruby
-class PermissionFilter < Slots::PermissionFilter
+class PermissionFilter < Slots::JWT::PermissionFilter
   def allowed?
     # available methods schema_member, current_user, required_permission, valid_loaded_user
     return true if required_permission == :anyone

data/lib/slots/jwt/generic_methods.rb

@@ -12,12 +12,22 @@ module Slots
         !(self.class._reject_new_token?(self))
       end
 
+      def failed_login
+        !(self.class._failed_login(self))
+      end
+
+      def successful_login
+        !(self.class._successful_login(self))
+      end
+
       def run_token_created_callback
         self.class._token_created_callback(self)
       end
 
       def authenticate?(password)
-        password.present? && persisted? && respond_to?(:authenticate) && authenticate(password) && allowed_new_token?
+        to_return = password.present? && persisted? && respond_to?(:authenticate) && authenticate(password) && allowed_new_token?
+        to_return ? successful_login : failed_login
+        to_return
       end
 
       def authenticate!(password)
@@ -41,6 +51,20 @@ module Slots
           (@_reject_new_token ||= []).any? { |b| user.instance_eval(&b) }
         end
 
+        def failed_login(&block)
+          (@_failed_login ||= []).push(block)
+        end
+        def _failed_login(user)
+          (@_failed_login ||= []).any? { |b| user.instance_eval(&b) }
+        end
+
+        def successful_login(&block)
+          (@_successful_login ||= []).push(block)
+        end
+        def _successful_login(user)
+          (@_successful_login ||= []).any? { |b| user.instance_eval(&b) }
+        end
+
         def token_created_callback(&block)
           (@_token_created_callback ||= []).push(block)
         end

data/lib/slots/jwt/tokens.rb

@@ -43,6 +43,7 @@ module Slots
       end
       def set_token!(slots_jwt)
         @slots_jwt = slots_jwt
+        @extra_payload = slots_jwt.extra_payload
         self
       end
 

data/lib/slots/jwt/version.rb

@@ -2,6 +2,6 @@
 
 module Slots
   module JWT
-    VERSION = "0.1.0"
+    VERSION = "0.1.1"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: slots-jwt
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Jonathon Gardner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-11-01 00:00:00.000000000 Z
+date: 2020-04-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -130,8 +130,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 3.0.1
 signing_key: 
 specification_version: 4
 summary: Token Authentication for Rails using JWT.