virtuatable-core 1.4.0 → 1.6.0.dev1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bb7485c8bb6e781dcf4b6d3299d3065769a4556e01421fba08eb2404a3d982a5
-  data.tar.gz: 281cce31ddad58a7ffb44e8fd78de1bdefdc5d5f1f2f6b53f8a89e9125e8792e
+  metadata.gz: d04349e236702f20e0c4a2542187eb4d1a0ef59d6ff4b44f90ff7d1a2484f783
+  data.tar.gz: f1e41d1f2b0a89c2851d617c2642222351a96cda77f0baeefed1a67eb98150d5
 SHA512:
-  metadata.gz: 2df4695bf1450c3c99cc3d86e5cee1cc91050275b6f54e40c587553376e93bd9752aac1683692a556c3265c16bab9fb06daa530b30645b3b4fdb6748a5e741ec
-  data.tar.gz: eee4af9a5591e1ef3fa5a7a5a1071791680a02af442df91bcfb03d5f4f63cc334ea6fe78edfbfb848a358af3d0df9327fb13429b0d104637e9622ae71c568d64
+  metadata.gz: d1a87bca549bdc10d5f9dbee7c483051a0af0d7ec0cfb5594051a64b617e07fe8e32f8fcb7231398a078e4ca30d4d51e3434eb703bbdf5f5790474da897d8c6d
+  data.tar.gz: 910921c135060a8b78065c146e41ccc6e13f32e24ed75bafd4b3f507058ccb22a47c88f75ecfff991831c65382e1c56c3971124b07855e7e7513242871eec184

data/lib/core/decorators/account.rb

@@ -0,0 +1,9 @@
+module Core
+  module Decorators
+    class Account < Core::Decorators::Base
+      def has_password?(password)
+        BCrypt::Password.new(object.password_digest) == password
+      end
+    end
+  end
+end

data/lib/core/decorators/application.rb

@@ -0,0 +1,17 @@
+module Core
+  module Decorators
+    class Application < Core::Decorators::Base
+      def to_h
+        {
+          client_id: client_id,
+          name: name,
+          premium: premium
+        }
+      end
+
+      def has_secret?(secret)
+        object.client_secret == secret
+      end
+    end
+  end
+end

data/lib/core/decorators/base.rb

@@ -0,0 +1,15 @@
+module Core
+  module Decorators
+    class Base < Draper::Decorator
+      delegate_all
+
+      def id
+        object.id.to_s
+      end
+
+      def to_json
+        to_h.to_json
+      end
+    end
+  end
+end

data/lib/core/decorators/campaign.rb

@@ -0,0 +1,20 @@
+module Core
+  module Decorators
+    class Campaign < Draper::Decorator
+      delegate_all
+
+      def to_simple_h
+        {
+          id: id.to_s,
+          title: title,
+          description: description,
+          tags: tags,
+          players: {
+            current: invitations.where(status: :accepted).count,
+            max: max_players
+          }
+        }
+      end
+    end
+  end
+end

data/lib/core/decorators/session.rb

@@ -0,0 +1,13 @@
+module Core
+  module Decorators
+    class Session < Core::Decorators::Base
+      def to_h
+        {
+          token: token,
+          account_id: account.id.to_s,
+          created_at: created_at.iso8601
+        }
+      end
+    end
+  end
+end

data/lib/core/decorators/token.rb

@@ -0,0 +1,12 @@
+module Core
+  module Decorators
+    class Token < Core::Decorators::Base
+
+      def to_h
+        {
+          token: value
+        }
+      end
+    end
+  end
+end

data/lib/core/decorators.rb

@@ -0,0 +1,10 @@
+module Core
+  module Decorators
+    autoload :Account, 'core/decorators/account'
+    autoload :Application, 'core/decorators/application'
+    autoload :Base, 'core/decorators/base'
+    autoload :Campaign, 'core/decorators/campaign'
+    autoload :Session, 'core/decorators/session'
+    autoload :Token, 'core/decorators/token'
+  end
+end

data/lib/core/helpers/declarators.rb

@@ -13,9 +13,9 @@ module Core
       # @param verb [String] the HTTP method for the route.
       # @param path [String] the whole URI with parameters for the route.
       # @param options [Hash] the additional options for the route.
-      def api_route(verb, path, premium: false, scopes: ['data::usage'], &block)
+      def api_route(verb, path, premium: false, scopes: [], &block)
         send(verb, path) do
-          scope_objects = fetch_scopes(scopes)
+          scope_objects = fetch_scopes(scopes + ['data::usage'])
           appli = application(premium: premium)
           check_app_scopes(appli, scope_objects)
           check_token_scopes(token, scope_objects)

data/lib/core/helpers/parameters.rb

@@ -12,8 +12,12 @@ module Core
         super.merge(body_params)
       end
 
+      def sym_params
+        params.map { |k, v| [k.to_sym, v] }.to_h
+      end
+
       # The parameters from the JSON body if it is sent.
-      # @return [Hash] the JSON body parsed as a dictionary.
+      # @return [Hash] the JSON body parsed as a dict ionary.
       def body_params
         request.body.rewind
         JSON.parse(request.body.read.to_s)

data/lib/core/helpers/responses.rb

@@ -13,7 +13,7 @@ module Core
       def api_list(items)
         halt 200, {
           count: items.count,
-          items: items.map { |item| enhanced_h(item) }
+          items: items.map { |item| item.to_h }
         }.to_json
       end
 
@@ -21,13 +21,13 @@ module Core
       # returning the informations about the created item.
       # @param item [Object] any object that responds to #to_h to display to the user.
       def api_created(item)
-        halt 201, enhanced_json(item)
+        halt 201, item.to_json
       end
 
       # Displays an item with the standards of the API.
       # @param item [Object] the item to display as a JSON formatted hash.
       def api_item(item)
-        halt 200, enhanced_json(item)
+        halt 200, item.to_json
       end
 
       # Displays a message with a 200 status code
@@ -35,16 +35,6 @@ module Core
       def api_ok(message)
         api_item message: message
       end
-
-      private
-
-      def enhanced_h(item)
-        (item.respond_to?(:enhance) ? item.enhance : item).to_h
-      end
-
-      def enhanced_json(item)
-        enhanced_h(item).to_json
-      end
     end
   end
 end

data/lib/core/models/oauth/access_token.rb

@@ -13,44 +13,29 @@ module Core
         # @!attribute [rw] value
         #   @return [String] the value of the token, returned to the application when built.
         field :value, type: String, default: ->{ SecureRandom.hex }
-        # @!attribute [rw] expiration
-        #   @return [Integer] the time, in seconds, after which the token is declared expired, and thus can't be used anymore.
-        field :expiration, type: Integer, default: 86400
 
         # @!attribute [rw] authorization
         #   @return [Core::Models::OAuth::Authorization] the authorization code that issued this token to the application for this user.
-        belongs_to :authorization, class_name: 'Core::Models::OAuth::Authorization', inverse_of: :tokens
+        belongs_to :authorization, class_name: 'Core::Models::OAuth::Authorization', inverse_of: :tokens, optional: true
+        # @!attribute [rw] generator
+        #   @return [Core::Models::Oauth::AccessToken] the token that generated this one.
+        belongs_to :generator, class_name: 'Core::Models::OAuth::AccessToken', inverse_of: :generated, optional: true
 
-
-        # A refresh token is attached to each and every refresh token so that it can be used to deliver a new access token.
-        # @!attribute [rx] refresh_token
-        #   @return [Core::Models::OAuth::RefreshToken] the refresh token linked to this token
-        has_one :refresh_token, class_name: 'Core::Models::OAuth::RefreshToken', inverse_of: :token
+        # @!attribute [rw] generated
+        #   @return [Core::Models::OAuth::AccessToken] the token that has been generated by the current one.
+        has_one :generated, class_name: 'Core::Models::OAuth::AccessToken', inverse_of: :generator
 
         validates :value, 
           presence: {message: 'required'},
           uniqueness: {message: 'uniq'}
 
-        # Checks if the current date is inferior to the creation date + expiration period
-        # @return [Boolean] TRUE if the token is expired, FALSE otherwise.
-        def expired?
-          # Handles the case where the token is given to a premium app (our apps have infinite tokens).
-          return false if premium?
-          return true if refresh_token.used?
-
-          created_at.to_time.to_i + expiration < Time.now.to_i
-        end
-
         # Returns the scopes this access token can use to access the application
         # @return [Array<Core::Models::OAuth::Scope>] the array of scopes from the linked authorization
         def scopes
-          # Premium applications (our applications) have all the rights on the API.
-          return Core::Models::OAuth::Scope.all.to_a if premium?
-
-          authorization.scopes
+          premium ? Core::Models::OAuth::Scope.all.to_a : authorization.scopes
         end
 
-        def premium?
+        def premium
           authorization.application.premium
         end
       end

data/lib/core/models/oauth/authorization.rb

@@ -17,7 +17,7 @@ module Core
         field :code, type: String, default: ->{ SecureRandom.hex }
         # @!attribute [rw] expiration
         #   @return [Integer] the time, in seconds, after which the authorization is declared expired.
-        field :expiration, type: Integer, default: 86400
+        field :expiration, type: Integer, default: 60
 
         # @!attribute [rw] account
         #   @return [Arkaaan::Account] the account granting the authorization to access its data to the application.
@@ -41,6 +41,10 @@ module Core
         def expired?
           created_at.to_time.to_i + expiration < Time.now.to_i
         end
+
+        def used?
+          tokens.count > 0
+        end
       end
     end
   end

data/lib/core/services/accounts.rb

@@ -1,16 +1,44 @@
+# frozen_string_literal: true
+
 module Core
   module Services
+    # Service managing user accounts.
+    # @author Vincent Courtois <courtois.vincent@outlook.com>
     class Accounts < Core::Services::Base
-      def get_by_username(username)
+      include Singleton
+
+      # Gets an account given the nickname of the user.
+      #
+      # @param username [String] the nickname the user chose at account creation.
+      # @return [Core::Models::Account] the account linked to this username.
+      #
+      # @raise [Core::Helpers::Errors::BadRequest] if the username is not given.
+      # @raise [Core::Helpers::Errors::NotFound] if the username does not exist.
+      def get_by_username(username: nil, **ignored)
+        require_parameters username: username
         account = Core::Models::Account.find_by(username: username)
-        if account.nil?
-          raise Core::Helpers::Errors::NotFound.new(
-            field: 'username',
-            error: 'unknown'
-          )
-        end
+        raise unknown_err(field: 'username') if account.nil?
+
+        Core::Decorators::Account.new(account)
+      end
+
+      # Gets and authenticates an account using its credentials.
+      #
+      # @param username [String] the nickname the user chose at account creation.
+      # @param password [String] the password, in clear, to identify the user with.
+      # @return [Core::Decorators::Account] the account if it is correctly found.
+      #
+      # @raise [Core::Helpers::Errors::BadRequest] if a needed parameter is not given.
+      # @raise [Core::Helpers::Errors::NotFound] if a user with this nickname is not found.
+      # @raise [Core::Helpers::Errors::Forbidden] if the password does not match the user.
+      def get_by_credentials(username: nil, password: nil, **ignored)
+        require_parameters password: password
+        account = get_by_username(username: username)
+
+        raise forbidden_err(field: 'password', error: 'wrong') unless account.has_password?(password)
+
         account
       end
     end
   end
-end
+end

data/lib/core/services/applications.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Core
+  module Services
+    # Service managing applications, allowing easy access to them with or without
+    # providing client secret for example.
+    # @author Vincent Courtois <courtois.vincent@outlook.com>
+    class Applications < Core::Services::Base
+      include Singleton
+
+      # Gets an application given its credentials (client UUID and client secret).
+      #
+      # @param client_id [String] the unique public identifier of the application.
+      # @param client_secret [String] the password for the application.
+      # @return [Core::Models::OAuth::Application] the application if it has been found.
+      #
+      # @raise [Core::Helpers::Errors::BadRequest] if a parameter is not correctly given.
+      # @raise [Core::Helpers::Errors::Forbidden] if the client secret is wrong for this application.
+      # @raise [Core::Helpers::Errors::Unknown] if the application is not found.
+      def get_by_credentials(client_id: nil, client_secret: nil, **_ignored)
+        require_parameters client_secret: client_secret
+        application = get_by_id(client_id: client_id)
+        raise forbidden_err(field: 'client_secret', error: 'wrong') unless application.has_secret?(client_secret)
+
+        application
+      end
+
+      # Gets an application given its client UUID.
+      #
+      # @param client_id [String] the unique identifier of the application to get
+      # @return [Core::Models::OAuth::Application] the application found if no error is raised.
+      #
+      # @raise [Core::Helpers::Errors::Unknown] if the application is not found.
+      def get_by_id(client_id: nil, **_ignored)
+        require_parameters client_id: client_id
+        application = Core::Models::OAuth::Application.find_by(client_id: client_id)
+        raise unknown_err(field: 'client_id') if application.nil?
+
+        Core::Decorators::Application.new(application)
+      end
+    end
+  end
+end

data/lib/core/services/authorizations.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Core
+  module Services
+    # Service managing authorization codes. These codes represent the access a user
+    # is giving to an application on all or part of its data.
+    # @author Vincent Courtois <courtois.vincent@outlook.com>
+    class Authorizations < Core::Services::Base
+      include Singleton
+
+      # Gets the authorization code corresponding to the provided value if it is linked to the
+      # application matching the provided credentials. Otherwise it raises errors.
+      #
+      # @param client_id [String] the UUID of the application.
+      # @param client_secret [String] the password of the application.
+      # @param authorization_code [String] the code of the authorization you're trying to get.
+      #
+      # @return [Core::Models::OAuth::Authorization] the authorization code object if found.
+      #
+      # @raise [Core::Helpers::Errors::NotFound] if the application or the authorization is unknown
+      # @raise [Core::Helpers::Errors::BadRequest] if any parameter is nil.
+      # @raise [Core::Helpers::Errors::Forbidden] if the secret does not match the application,
+      #   or the authorization code does not belong to the application.
+      def get_by_credentials(client_id: nil, client_secret: nil, authorization_code: nil, **_ignored)
+        require_parameters authorization_code: authorization_code
+        application = Core.svc.applications.get_by_credentials(
+          client_id: client_id,
+          client_secret: client_secret
+        )
+        authorization = get_by_code(authorization_code: authorization_code)
+        raise mismatch_error if authorization.application.id.to_s != application.id.to_s
+
+        authorization
+      end
+
+      # Gets an authorization code by its corresponding value.
+      # @param authorization_code [String] the code value of the authorization object.
+      # @return [Core::Models::OAuth::Authorization] the authorization object.
+      # @raise [Core::Helpers::Errors::NotFound] if the authorization code is not found.
+      def get_by_code(authorization_code: nil, **_ignored)
+        require_parameters authorization_code: authorization_code
+        authorization = Core::Models::OAuth::Authorization.find_by(code: authorization_code)
+        raise unknown_err(field: 'authorization_code') if authorization.nil?
+
+        authorization
+      end
+
+      private
+
+      def mismatch_error
+        bad_request_err(field: 'client_id', error: 'mismatch')
+      end
+    end
+  end
+end

data/lib/core/services/base.rb

@@ -1,11 +1,28 @@
+# frozen_string_literal: true
+
 module Core
   module Services
     class Base
-      attr_reader :services
+      # Raises an error if any parameter is nil, and nothing if all parameters are found.
+      # @raise [Core::Helpers::Errors::BadRequest] an error if any parameter is nil.
+      def require_parameters(**parameters)
+        parameters.keys.each do |key|
+          value = parameters[key]
+          raise bad_request_err(field: key.to_s, error: 'required') if value.nil?
+        end
+      end
+
+      def bad_request_err(field: nil, error: nil)
+        Core::Helpers::Errors::BadRequest.new(field: field, error: error)
+      end
+
+      def unknown_err(field: nil, error: 'unknown')
+        Core::Helpers::Errors::NotFound.new(field: field, error: error)
+      end
 
-      def initialize(registry)
-        @services = registry
+      def forbidden_err(field: nil, error: 'forbidden')
+        Core::Helpers::Errors::Forbidden.new(field: field, error: error)
       end
     end
   end
-end
+end

data/lib/core/services/campaigns.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Core
+  module Services
+    class Campaigns
+      include Singleton
+
+      # Lists all the campaigns of a user identified by its account.
+      #
+      # @param account [Core::Models::Account] the user requesting its campaigns.
+      # @param page [Integer] the page in the list of campaigns to return to the users.
+      # @param per_page [Integer] the number of campaigns per page.
+      #
+      # @return [Array<Hash>] an array of hash representing campaigns.
+      def list(account, page: 0, per_page: 20, **_ignored)
+        campaigns = campaigns(account).skip(page * per_page).limit(per_page)
+        campaigns.map do |campaign|
+          Core::Decorators::Campaign.new(campaign).to_simple_h
+        end
+      end
+
+      def campaigns(account)
+        invitations = account.invitations.where(enum_status: 'creator')
+        Core::Models::Campaign.where(:id.in => invitations.map(&:campaign_id))
+      end
+    end
+  end
+end

data/lib/core/services/registry.rb

@@ -1,15 +1,39 @@
+# frozen_string_literal: true
+
 module Core
   module Services
     # The registry holds references to all the services accessible in the library. To access
-    # all services and be able to manage resources easily, just instanciate the 
+    # all services and be able to manage resources easily, just instanciate the
     class Registry
+      include Singleton
 
-      attr_reader :accounts, :sessions
+      # @!attribute [r] accounts
+      #   @return [Core::Services::Accounts] the service managing accounts
+      attr_reader :accounts
+      # @!attribute [r] sessions
+      #   @return [Core::Services::Sessions] the service managing sessions
+      attr_reader :sessions
+      # @!attribute [r] campaigns
+      #   @return [Core::Services::Campaigns] the service managing campaigns
+      attr_reader :campaigns
+      # @!attribute [r] applications
+      #   @return [Core::Services::Applications] the service managing applications
+      attr_reader :applications
+      # @!attribute [r] authorizations
+      #   @return [Core::Services::Authorizations] the service managing authorizations
+      attr_reader :authorizations
+      # @!attribute [r] tokens
+      #   @return [Core::Services::Tokens] the service managing OAuth access tokens
+      attr_reader :tokens
 
       def initialize
-        @accounts = Core::Services::Accounts.new(self)
-        @sessions = Core::Services::Sessions.new(self)
+        @accounts = Core::Services::Accounts.instance
+        @sessions = Core::Services::Sessions.instance
+        @campaigns = Core::Services::Campaigns.instance
+        @applications = Core::Services::Applications.instance
+        @authorizations = Core::Services::Authorizations.instance
+        @tokens = Core::Services::Tokens.instance
       end
     end
   end
-end
+end

data/lib/core/services/sessions.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'bcrypt'
 require 'securerandom'
 
@@ -6,6 +8,8 @@ module Core
     # Service concerning sessions (log in and log out)
     # @author Vincent Courtois <courtois.vincent@outlook.com>
     class Sessions < Core::Services::Base
+      include Singleton
+
       # Creates a new session from the given user credentials. IT will
       # * check that the user exists in the database
       # * check that the password matches the user encrypted password
@@ -15,19 +19,31 @@ module Core
       # @param username [string] the name of the user trying to log in
       # @param password [string] the password the user has provided
       # @return [Core::Models::Authentication::Session] the login session
-      def create(username, password)
-        account = services.accounts.get_by_username(username)
-        if BCrypt::Password.new(account.password_digest) != password
-          raise Core::Helpers::Errors::Forbidden.new(
-            field: 'password',
-            error: 'wrong'
-          )
-        end
-        return Core::Models::Authentication::Session.create(
+      def create_from_credentials(username: nil, password: nil, **ignored)
+        account = Core.svc.accounts.get_by_credentials(
+          username: username,
+          password: password
+        )
+        session = Core::Models::Authentication::Session.create(
           account: account,
           token: SecureRandom.uuid
         )
       end
+
+      # Gets the session by its unique identifier.
+      #
+      # @param session_id [String] the unique identifier of the session you're searching.
+      # @return [Core::Decorators::Session] the decorated session to display in the API.
+      #
+      # @raise [Core::Helpers::Errors::BadRequest] if the session ID is not given or nil
+      # @raise [Core::Helpers::Errors::NotFound] if no session with its ID exist in the database.
+      def get_by_id(session_id: nil, **ignored)
+        require_parameters session_id: session_id
+        session = Core::Models::Authentication::Session.find_by(token: session_id)
+        raise unknown_err(field: 'session_id') if session.nil?
+
+        Core::Decorators::Session.new(session)
+      end
     end
   end
-end
+end

data/lib/core/services/tokens.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Core
+  module Services
+    # Service handling every operations concerning access tokens. This should mainly be
+    # used in the authentication backend as we should be the only ones to manage tokens.
+    # @author Vincent Courtois <courtois.vincent@outlook.com>
+    class Tokens < Core::Services::Base
+      include Singleton
+
+      def create_from_authorization(client_id: nil, client_secret: nil, authorization_code: nil, **_ignored)
+        authorization = Core.svc.authorizations.get_by_credentials(
+          client_id: client_id,
+          client_secret: client_secret,
+          authorization_code: authorization_code
+        )
+        raise forbidden_err(field: 'authorization_code', error: 'used') if authorization.used?
+
+        created = Core::Models::OAuth::AccessToken.create(authorization: authorization)
+        Core::Decorators::Token.new(created)
+      end
+
+      # Refreshes the token for the next request the client wants to issue by re-creating it
+      # from the previous token to add it to the tokens chain.
+      #
+      def create_from_token(client_id: nil, client_secret: nil, token: nil, **_ignored)
+        token = get_by_value(token: token)
+        authorization = Core.svc.authorizations.get_by_credentials(
+          client_id: client_id,
+          client_secret: client_secret,
+          authorization_code: token.authorization.code
+        )
+        raise forbidden_err(field: 'token', error: 'used') unless token.generated.nil?
+
+        created = Core::Models::OAuth::AccessToken.create(
+          generator: token,
+          authorization: authorization
+        )
+        Core::Decorators::Token.new(created)
+      end
+
+      def get_by_value(token: nil, **_ignored)
+        require_parameters token: token
+        token = Core::Models::OAuth::AccessToken.find_by(value: token)
+        raise unknown_err(field: 'token') if token.nil?
+
+        Core::Decorators::Token.new(token)
+      end
+    end
+  end
+end

data/lib/core/services.rb

@@ -5,8 +5,12 @@ module Core
   # @author Vincent Courtois <courtois.vincent@outlook.com>
   module Services
     autoload :Accounts, 'core/services/accounts'
+    autoload :Applications, 'core/services/applications'
+    autoload :Authorizations, 'core/services/authorizations'
     autoload :Base, 'core/services/base'
+    autoload :Campaigns, 'core/services/campaigns'
     autoload :Registry, 'core/services/registry'
     autoload :Sessions, 'core/services/sessions'
+    autoload :Tokens, 'core/services/tokens'
   end
 end

data/lib/core/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Core
-  VERSION = '1.4.0'
+  VERSION = '1.6.0.dev1'
 end

data/lib/core.rb

@@ -1,12 +1,18 @@
 # frozen_string_literal: true
 
-%w[active_model mongoid active_support].each { |g| require g }
+%w[active_model mongoid active_support draper].each { |g| require g }
 
 # Main module of the application, holding all the subsequent classes.
 # @author Vincent Courtois <courtois.vincent@outlook.com>
 module Core
   autoload :Controllers, 'core/controllers'
+  autoload :Decorators, 'core/decorators'
   autoload :Helpers, 'core/helpers'
   autoload :Models, 'core/models'
   autoload :Services, 'core/services'
+
+  # Returns the registry of services for easier access to each of them.
+  def self.svc
+    Core::Services::Registry.instance
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: virtuatable-core
 version: !ruby/object:Gem::Version
-  version: 1.4.0
+  version: 1.6.0.dev1
 platform: ruby
 authors:
 - Vincent Courtois
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-05-08 00:00:00.000000000 Z
+date: 2022-05-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: database_cleaner
@@ -276,6 +276,20 @@ dependencies:
     - - '='
       - !ruby/object:Gem::Version
         version: 2.1.0
+- !ruby/object:Gem::Dependency
+  name: draper
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: This gem holds the model layer for my table-top RPG games application.
 email: courtois.vincent@outlook.com
 executables: []
@@ -285,6 +299,13 @@ files:
 - lib/core.rb
 - lib/core/controllers.rb
 - lib/core/controllers/base.rb
+- lib/core/decorators.rb
+- lib/core/decorators/account.rb
+- lib/core/decorators/application.rb
+- lib/core/decorators/base.rb
+- lib/core/decorators/campaign.rb
+- lib/core/decorators/session.rb
+- lib/core/decorators/token.rb
 - lib/core/helpers.rb
 - lib/core/helpers/accounts.rb
 - lib/core/helpers/applications.rb
@@ -332,14 +353,17 @@ files:
 - lib/core/models/oauth/access_token.rb
 - lib/core/models/oauth/application.rb
 - lib/core/models/oauth/authorization.rb
-- lib/core/models/oauth/refresh_token.rb
 - lib/core/models/oauth/scope.rb
 - lib/core/models/ruleset.rb
 - lib/core/services.rb
 - lib/core/services/accounts.rb
+- lib/core/services/applications.rb
+- lib/core/services/authorizations.rb
 - lib/core/services/base.rb
+- lib/core/services/campaigns.rb
 - lib/core/services/registry.rb
 - lib/core/services/sessions.rb
+- lib/core/services/tokens.rb
 - lib/core/version.rb
 homepage: https://rubygems.org/gems/virtuatable-core
 licenses:
@@ -356,9 +380,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubygems_version: 3.2.3
 signing_key: 

data/lib/core/models/oauth/refresh_token.rb

@@ -1,29 +0,0 @@
-module Core
-  module Models
-    module OAuth
-      # A refresh token is used when an access token is expired, to get a new one. It is then recreated for the next expiration.
-      # @author Vincent Courtois <courtois.vincent@outlook.com>
-      class RefreshToken
-        include Mongoid::Document
-        include Mongoid::Timestamps
-
-        store_in collection: 'oauth_refresh_tokens'
-
-        # @!attribute [rw] value
-        #   @return [String] the value of the token, returned to the application when built.
-        field :value, type: String, default: ->{ SecureRandom.hex }
-        # @!attribute [rw] used_at
-        #   @return [DateTime] the date and time at which this refresh token has been useds to create a new access token.
-        field :used_at, type: DateTime, default: nil
-
-        # @!attribute [rw] authorization
-        #   @return [Core::Models::OAuth::Authorization] the authorization code that issued this token to the application for this user.
-        belongs_to :token, class_name: 'Core::Models::OAuth::AccessToken', inverse_of: :refresh_token
-
-        def used?
-          !used_at.nil? && used_at < DateTime.now
-        end
-      end
-    end
-  end
-end