virtuatable-core 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: eaef58986378462da6ff78e3aeac595cbed418f3351254e3e99b303059fe21d1
+  data.tar.gz: 1ed97f4ff856ecfbe5ccf969547ee0141f03f1e9c59304661880f6d4e87bfaf7
+SHA512:
+  metadata.gz: ffc760f437db7e376de09c5e88fa794e440729600819f8cce7474d4db6a122185fc20472020e131ae889d6371f1cf95f0fb7389506ac4ec1f5a9840a3ed2dc98
+  data.tar.gz: '08addb4e9612082536359a2a624f5eded215ba382a8f9b16aebf016cfc35b9c9dbc12a503a3160780dc81896bdabf0434f1966062d5eb339e999eadef92cbec1'

data/lib/core/models/account.rb

@@ -0,0 +1,102 @@
+module Core
+  module Models
+    # A user account with all related attributes. It holds credentials and informations about a designated user.
+    # @author Vincent Courtois <courtois.vincent@outlook.com>
+    class Account
+      include Mongoid::Document
+      include Mongoid::Timestamps
+      include ActiveModel::SecurePassword
+      include Core::Models::Concerns::Enumerable
+
+      # @!attribute [rw] username
+      #   @return [String] the nickname the user chose at subscription, must be given, unique, and 6 or more characters long.
+      field :username, type: String
+      # @!attribute [r] password_digest
+      #   @return [String] the password of the user, encrypted with the Blowfish algorithm.
+      field :password_digest, type: String
+      # @!attribute [rw] lastname
+      #   @return [String] the last name (family name) of the user.
+      field :lastname, type: String, default: ''
+      # @!attribute [rw] firstname
+      #   @return [String] the first name of the user.
+      field :firstname, type: String, default: ''
+      # @!attribute [rw] email
+      #   @return [String] the email address of the user, useful to contact them ; it must be given, unique, and have an email format.
+      field :email, type: String
+      # @!attribute [rw] language
+      #   @return [Symbol] the language preferred by this user.
+      enum_field :language, [:en_GB, :fr_FR], default: :fr_FR
+      # @!attribute [rw] gender
+      #   @return [Symbol] the way you prefer the application to gender you.
+      enum_field :gender, [:female, :male, :neutral], default: :neutral
+
+      # @!attribute [w] password
+      #   @return [String] password, in clear, of the user ; do not attempt to get the value, just set it when changing the password.
+      # @!attribute [w] password_confirmation
+      #   @return [String] the confirmation of the password, do not get, just set it ; it must be the same as the password.
+      has_secure_password validations: false
+
+      # @!attribute [rw] groups
+      #   @return [Array<Core::Models::Permissions::Group>] the groups giving their corresponding rights to the current account.
+      has_and_belongs_to_many :groups, class_name: 'Core::Models::Permissions::Group', inverse_of: :accounts
+      
+      # @!attribute [rw] applications
+      #   @return [Array<Core::Models::OAuth::Application] the applications this user has created and owns.
+      has_many :applications, class_name: 'Core::Models::OAuth::Application', inverse_of: :creator
+      # @!attribute [rw] authorizations
+      #   @return [Array<Core::Models::OAuth::Authorization>] the authorization issued by this account to third-party applications to access its data.
+      has_many :authorizations, class_name: 'Core::Models::OAuth::Authorization', inverse_of: :account
+      # @!attribute [rw] services
+      #   @return [Array<Core::Models::Monitoring::Service>] the services created by this user.
+      has_many :services, class_name: 'Core::Models::Monitoring::Service', inverse_of: :creator
+      # @!attribute [rw] sessions
+      #   @return [Array<Core::Models::Authentication::Session>] the sessions on which this account is, or has been logged in.
+      has_many :sessions, class_name: 'Core::Models::Authentication::Session', inverse_of: :account
+      # @!attribute [rw] invitations
+      #   @return [Array<Core::Models::Campaigns::Invitation>] the invitations in campaigns you have been issued.
+      has_many :invitations, class_name: 'Core::Models::Campaigns::Invitation', inverse_of: :account
+      # @!attribute [rw] invitations
+      #   @return [Array<Core::Models::Campaigns::Invitation>] the invitations you've issued yourself to other players.
+      has_many :created_invitations, class_name: 'Core::Models::Campaigns::Invitation', inverse_of: :creator
+      # @!attribute [rw] permissions
+      #   @return [Array<Core::Models::Files::Permission>] the file access permissions granted to this account.
+      has_many :permissions, class_name: 'Core::Models::Files::Permission', inverse_of: :account
+      # @!attribute [rw] messages
+      #   @return [Array<Core::Models::Chatrooms::Messages>] all the messages ever sent by the user.
+      has_many :messages, class_name: 'Core::Models::Chatrooms::Message', inverse_of: :account
+
+      has_many :memberships, class_name: 'Core::Models::Chatrooms::Membership', inverse_of: :account
+
+      # @!attribute [rw] notifications
+      #  @return [Array<Core::Models::Notification>] the notifications linked to this user.
+      embeds_many :notifications, class_name: 'Core::Models::Notification', inverse_of: :account
+
+      # @return [Array<Core::Models::Notification>] the unread notifications that should be displayed first for the user.
+      def unread_notifications
+        notifications.where(read: false)
+      end
+
+      # @return [Array<Core::Models::Notification>] the notifications already read, less important to display than the unread ones.
+      def read_notifications
+        notifications.where(read: true)
+      end
+
+      validates :username,
+        presence: {message: 'required'},
+        length: {minimum: 6, message: 'minlength', if: :username?},
+        uniqueness: {message: 'uniq', if: :username?}
+
+      validates :email,
+        presence: {message: 'required'},
+        format: {with: /\A[a-z0-9._%+-]+@[a-z0-9.-]+\.[a-z]{2,}\z/, message: 'pattern', if: :email?},
+        uniqueness: {message: 'uniq', if: :email?}
+
+      validates :password,
+        presence: {message: 'required', if: ->{ !persisted? || password_digest_changed? }},
+        confirmation: {message: 'confirmation', if: :password_digest_changed?}
+
+      validates :password_confirmation,
+        presence: {message: 'required', if: :password_digest_changed?}
+    end
+  end
+end

data/lib/core/models/authentication/session.rb

@@ -0,0 +1,30 @@
+module Core
+  module Models
+    module Authentication
+      # A session represents the connection of the user on our frontend application. Nobody else than our frontend should
+      # have access to the session or it's content (in particular to the token), instead they shall use the OAuth2.0 protocol.
+      # A session shall ONLY be created by a premium application (only our frontend applications are premium).
+      # @author Vincent Courtois <courtois.vincent@outlook.com>
+      class Session
+        include Mongoid::Document
+        include Mongoid::Timestamps
+
+        # @!attribute [rw] token
+        #   @return [String] the unique token for this session, used to identify it and be sure the user is connected on this application.
+        field :token, type: String
+        # @!attribute [rw] websocket_id
+        #   @return [String] the ID of the websocket on which the session is connected. It's not an association because instances are embedded.
+        field :websocket_id, type: String, default: ''
+
+        # @!attribute [rw] account
+        #   @return [Core::Models::Account] the account connected to the application.
+        belongs_to :account, class_name: 'Core::Models::Account', inverse_of: :sessions
+
+        validates :token,
+          presence: {message: 'required'},
+          uniqueness: {message: 'uniq', if: :token?},
+          length: {minimum: 10, message: 'minlength', if: :token?}
+      end
+    end
+  end
+end

data/lib/core/models/authentication.rb

@@ -0,0 +1,9 @@
+module Core
+  module Models
+    # This module holds the logic for user authentication to our frontend.
+    # @author Vincent Courtois <courtois.vincent@outlook.com>
+    module Authentication
+      autoload :Session, 'core/models/authentication/session'
+    end
+  end
+end

data/lib/core/models/campaign.rb

@@ -0,0 +1,110 @@
+module Core
+  module Models
+    # A campaign is a gathering of accounts playing on the same interface, and interacting in a common game.
+    # @author Vincent Courtois <courtois.vincent@outlook.com>
+    class Campaign
+      include Mongoid::Document
+      include Mongoid::Timestamps
+
+      # @!attribute [rw] title
+      #   @return [String] the title, or name, of the campaign, used to identify it in the list.
+      field :title, type: String
+      # @!attribute [rw] description
+      #   @return [String] a more detailed description, used to give further information about the campaign in general.
+      field :description, type: String
+      # @!attribute [rw] is_private
+      #   @return [Boolean] TRUE if the campaign can be joined only by being invited by the creator, FALSE if it's publicly displayed and accessible.
+      field :is_private, type: Boolean, default: true
+      # @!attribute [rw] tags
+      #   @return [Array<String>] an array of tags describing characteristics of this campaign.
+      field :tags, type: Array, default: []
+      # @!attributes [rw] max_players
+      #   @return [Integer] the maximum number of players allowed in this campaign.
+      field :max_players, type: Integer, default: 5
+
+      # @!attribute [rw] invitations
+      #   @return [Array<Core::Models::Campaigns::Invitation>] the invitations to players that have been made for this campaign.
+      has_many :invitations, class_name: 'Core::Models::Campaigns::Invitation', inverse_of: :campaign
+      # @!attribute [rw] files
+      #   @return [Array<Core::Models::Files::Document>] the files uploaded in this campaign.
+      has_many :files, class_name: 'Core::Models::Files::Document'
+
+      # @!attribute [rw] chatroom
+      #   @return [Core::Models::Chatrooms::Campaign] the chatroom linked to this campaign.
+      embeds_one :chatroom, class_name: 'Core::Models::Chatrooms::Campaign', inverse_of: :campaign
+
+      # @!attribute [rw] ruleset
+      #   @return [Core::Models::Ruleset] the set of rules this campaign is based upon.
+      belongs_to :ruleset, class_name: 'Core::Models::Ruleset', inverse_of: :campaigns, optional: true
+
+      validates :title,
+        presence: {message: 'required'},
+        length: {minimum: 4, message: 'minlength', if: :title?}
+
+      validates :max_players,
+        numericality: {less_than: 21, message: 'maximum'}
+
+      validate :title_unicity
+
+      validate :max_players_minimum
+
+      # Sets the creator of the campaign. This method is mainly used for backward-compatibility needs.
+      # @param account [Core::Models::Account] the account of the creator for this campaign.
+      def creator=(account)
+        if !invitations.where(account: account).exists?
+          invitation = Core::Models::Campaigns::Invitation.create(
+            campaign: self,
+            account: account,
+            status: :creator
+          )
+        end
+      end
+
+      # Getter for the creator account of this campaign.
+      # @return [Core::Models::Account] the account of the player creating this campaign.
+      def creator
+        invitations.to_a.find(&:status_creator?).account
+      end
+
+      # Adds an error message if the account creating this campaign already has a campaign with the very same name.
+      def title_unicity
+        # First we take all the other campaign ids of the user.
+        campaign_ids = creator.invitations.where(:campaign_id.ne => _id).pluck(:campaign_id)
+        # With this list of campaign IDs, we look for a campaign with the same title.
+        same_title_campaign = Core::Models::Campaign.where(:_id.in => campaign_ids, title: title)
+        if !creator.nil? && title? && same_title_campaign.exists?
+          errors.add(:title, 'uniq')
+        end
+      end
+
+      # Validation for the max number of players for a campaign.
+      # If there is a max number of players, and the current number of
+      # players is above it, or the max number of players is 0, raises an error.
+      def max_players_minimum
+        if max_players? && (max_players < players_count || max_players < 1)
+          errors.add(:max_players, 'minimum')
+        end
+      end
+
+      # @return [Array<Core::Models::Campaigns::Invitation>] the players in this campaign.
+      def players
+        invitations.to_a.select do |invitation|
+          [:creator, :accepted].include? invitation.enum_status
+        end
+      end
+
+      # @return [Integer] the number of players in this campaign.
+      def players_count
+        players.count
+      end
+
+      def messages
+        chatroom.messages
+      end
+
+      after_initialize do
+        self.chatroom = Core::Models::Chatrooms::Campaign.new(campaign: self)
+      end
+    end
+  end
+end

data/lib/core/models/campaigns/invitation.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Core
+  module Models
+    module Campaigns
+      # An invitation is the linked between a player and a campaign.
+      # It keeps the history of the interaction between the player and the campaign.
+      #
+      # @author Vincent Courtois <courtois.vincent@outlook.com>
+      class Invitation
+        include Mongoid::Document
+        include Mongoid::Timestamps
+        include Core::Models::Concerns::Enumerable
+        include Core::Models::Concerns::Historizable
+
+        # @!attribute [rw] account
+        #   @return [Core::Models::Account] the account the invitation has been issued to.
+        belongs_to :account, class_name: 'Core::Models::Account', inverse_of: :invitations
+        # @!attribute [rw] campaign
+        #   @return [Core::Models::Campaign] the campaign the invitation has been made in.
+        belongs_to :campaign, class_name: 'Core::Models::Campaign', inverse_of: :invitations
+
+        # @!attribute [rw] status
+        #   @return [Symbol] the current status of the invitation.
+        historize enum_field :status,
+          [:pending, :request, :accepted, :refused, :expelled, :left, :master, :creator],
+          default: :pending
+      end
+    end
+  end
+end

data/lib/core/models/campaigns/tag.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Core
+  module Models
+    module Campaigns
+      # A campaign tag is a string describing a characteristic of the campaign it's in.
+      # @author Vincent Courtois <courtois.vincent@outlook.com>
+      class Tag
+        include Mongoid::Document
+        include Mongoid::Timestamps
+
+        # @!attribute [rw] content
+        #   @return [String] the string content of the tag, describing a characteristic.
+        field :content, type: String
+        # @!attribute [rw] count
+        #   @return [Integer] the number of campaigns this tag is in, avoiding a join.
+        field :count, type: Integer, default: 1
+
+        validates :content, presence: { message: 'required' }, uniqueness: { message: 'uniq' }
+      end
+    end
+  end
+end

data/lib/core/models/campaigns.rb

@@ -0,0 +1,10 @@
+module Core
+  module Models
+    # The campaigns module is holding the logic for some objects related to campaigns.
+    # @author Vincent Courtois <courtois.vincent@outlook.com>
+    module Campaigns
+      autoload :Invitation, 'core/models/campaigns/invitation'
+      autoload :Tag       , 'core/models/campaigns/tag'
+    end
+  end
+end

data/lib/core/models/chatrooms/base.rb

@@ -0,0 +1,16 @@
+module Core
+  module Models
+    module Chatrooms
+      # The base chatroom class, made to be subclassed in campaign and personal chatrooms.
+      # @author Vincent Courtois <courtois.vincent@outlook.com>
+      class Base
+        include Mongoid::Document
+        include Mongoid::Timestamps
+
+        # @!attribute [rw] messages
+        #   @return [Array<Core::Models::Chatrooms::Message>] the messages sent in this chatroom.
+        has_many :messages, class_name: 'Core::Models::Chatrooms::Message', inverse_of: :chatroom
+      end
+    end
+  end
+end

data/lib/core/models/chatrooms/campaign.rb

@@ -0,0 +1,13 @@
+module Core
+  module Models
+    module Chatrooms
+      # Represents the chatroom embedded in a campaign.
+      # @author Vincent Courtois <courtois.vincent@outlook.com>
+      class Campaign < Core::Models::Chatrooms::Base
+        # @!attribute [rw] campaign
+        #   @return [Core::Models::Campaign] the campaign the chatroom is linked to.
+        embedded_in :campaign, class_name: 'Core::Models::Campaign', inverse_of: :chatroom
+      end
+    end
+  end
+end

data/lib/core/models/chatrooms/conversation.rb

@@ -0,0 +1,9 @@
+module Core
+  module Models
+    module Chatrooms
+      class Conversation < Core::Models::Chatrooms::Base
+        has_many :memberships, class_name: 'Core::Models::Chatrooms::Membership', inverse_of: :chatroom
+      end
+    end
+  end
+end

data/lib/core/models/chatrooms/membership.rb

@@ -0,0 +1,17 @@
+module Core
+  module Models
+    module Chatrooms
+      class Membership
+        include Mongoid::Document
+        include Mongoid::Timestamps
+        include Core::Models::Concerns::Enumerable
+
+        enum_field :status, [:shown, :hidden], default: :shown
+
+        belongs_to :chatroom, class_name: 'Core::Models::Chatrooms::Private', inverse_of: :memberships
+
+        belongs_to :account, class_name: 'Core::Models::Account', inverse_of: :memberships
+      end
+    end
+  end
+end

data/lib/core/models/chatrooms/message.rb

@@ -0,0 +1,33 @@
+module Core
+  module Models
+    module Chatrooms
+      # This model represents an in-game tchat message sent in the tchat of a campaign.
+      # @author Vincent Courtois <courtois.vincent@outlook.com>
+      class Message
+        include Mongoid::Document
+        include Mongoid::Timestamps
+        include Core::Models::Concerns::Enumerable
+
+        # @!attribute [rw] type
+        #  @return [Symbol] the type of message (plain text or command) contained in the data, used to parse and display it.
+        enum_field :type, [:text, :command], default: :text
+        # @!attribute [rw] data
+        #   @return [Hash] the additional data passed to the message (arguments of the command, or content of the text)
+        field :data, type: Hash, default: {}
+        # @!attribute {rw} raw
+        #   @return [String] the content as typed by the user, without any parsing or transformation.
+        field :raw, type: String, default: ''
+        # @!attribute [rw] deleted
+        #   @return [Boolean] TRUE if the message has been marked as deleted by its user, FALSE otherwise.
+        field :deleted, type: Boolean, default: false
+
+        # @!attribute [rw] campaign
+        #   @return [Core::Models::Chatrooms::Campaign] the chatroom in which the message has been emitted.
+        belongs_to :chatroom, class_name: 'Core::Models::Chatrooms::Campaign', inverse_of: :messages
+        # @!attribute [rw] player
+        #   @return [Core::Models::Account] the account that has emitted the message in the campaign.
+        belongs_to :account, class_name: 'Core::Models::Account', inverse_of: :messages
+      end
+    end
+  end
+end

data/lib/core/models/chatrooms.rb

@@ -0,0 +1,13 @@
+module Core
+  module Models
+    # The chatrooms modules regroup all classes concerning messages between players.
+    # @author Vincent Courtois <courtois.vincent@outlook.com>
+    module Chatrooms
+      autoload :Base        , 'core/models/chatrooms/base'
+      autoload :Campaign    , 'core/models/chatrooms/campaign'
+      autoload :Conversation, 'core/models/chatrooms/conversation'
+      autoload :Message     , 'core/models/chatrooms/message'
+      autoload :Membership  , 'core/models/chatrooms/membership'
+    end
+  end
+end

data/lib/core/models/concerns/activable.rb

@@ -0,0 +1,20 @@
+module Core
+  module Models
+    module Concerns
+      # Concerns for the objects that can be activated or deactivated, included the corresponding scopes.
+      # @author Vincent Courtois <courtois.vincent@outlook.com>
+      module Activable
+        extend ActiveSupport::Concern
+
+        included do
+          # @!attribute [rw] active
+          #   @return [Boolean] the active status of the instance, indicating if someone has deactivated it or not.
+          field :active, type: Boolean, default: true
+        
+          scope :active  , ->{ where(active: true)  }
+          scope :inactive, ->{ where(active: false) }
+        end
+      end
+    end
+  end
+end

data/lib/core/models/concerns/diagnosticable.rb

@@ -0,0 +1,24 @@
+module Core
+  module Models
+    module Concerns
+      # Includes the diagnostic URL field, and the related validations.
+      # @author Vincent Courtois <courtois.vincent@outlook.com>
+      module Diagnosticable
+        extend ActiveSupport::Concern
+
+        # Module holding the class methods for the classes including this concern.
+        # @author Vincent Courtois <courtois.vincent@outlook.com>
+        included do
+          # @!attribute [rw] diagnostic
+          #   @return [String] the diagnostic URL to know the status of an entity (usually a gateway, or an instance of a service).
+          field :diagnostic, type: String, default: '/status'
+
+          validates :diagnostic,
+            presence: {message: "required"},
+            length: {minimum: 4, message: "minlength"},
+            format: {with: /\A(\/[a-z]+)+\z/, message: "pattern"}
+        end
+      end
+    end
+  end
+end

data/lib/core/models/concerns/enumerable.rb

@@ -0,0 +1,50 @@
+module Core
+  module Models
+    module Concerns
+      # Defines enumerations for the Mongoid models. An enumeration is a field that can only use a given set of values.
+      # @author Vincent Courtois <courtois.vincent@outlook.com>
+      module Enumerable
+        extend ActiveSupport::Concern
+
+        # Submodule holding all the static methods add to the current subclass.
+        # @author Vincent Courtois <courtois.vincent@outlook.com>
+        module ClassMethods
+          
+          # Creates the field with the given name, set of possible values, and options.
+          # @param field_name [String] the name of the enumerated field.
+          # @param values [Array<Symbol>] the possible values of the enumerated field.
+          # @param options [Hash<Symbol, Any>] the possible options for the field.
+          def enum_field(field_name, values, options = {})
+            returned = field :"enum_#{field_name}", type: Symbol, default: options[:default]
+
+            validates :"enum_#{field_name}", inclusion: {in: values.map(&:to_sym), message: 'inclusion'}
+
+            define_method field_name do
+              return self["enum_#{field_name}"]
+            end
+
+            define_method "#{field_name}=" do |value|
+              if values.include? value.to_sym
+                self["enum_#{field_name}"] = value.to_sym
+              end
+            end
+
+            values.map(&:to_sym).each do |value|
+              define_method "#{field_name}_#{value}!" do
+                self["enum_#{field_name}"] = value
+              end
+
+              define_method "#{field_name}_#{value}?" do
+                self["enum_#{field_name}"] == value
+              end
+            end
+
+            # This is to make enumerations historizable by
+            # returning the field object created by Mongoid.
+            returned
+          end
+        end
+      end
+    end
+  end
+end

data/lib/core/models/concerns/historizable.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Core
+  module Models
+    module Concerns
+      # This module is what I call "a beautiful piece of Ruby engineering"
+      # It takes any mongoid field that you may have declared, and historizes
+      # it in a dedicated relation if this relation does not already exists.
+      #
+      # What it does exactly :
+      # - Creates the :history relation if it does not already exists.
+      # - Creates a method to check for changes of a specific attribute.
+      # - Check for changes at initialization to insert the first value.
+      # - Check for changes at update/save to store the history.
+      #
+      # @author Vincent Courtois <courtois.vincent@outlook.com>
+      module Historizable
+        extend ActiveSupport::Concern
+
+        # Adds an entry in the history table for the given field.
+        # It checks several things to make the history entry valid :
+        # - the new value is different from the old value
+        # - the old value is identical to the last recorded new value.
+        #
+        # @param field [String] the name of the field to historize
+        # @param from [Any] the old value before update
+        # @param to [Any] the new value after update.
+        def add_history(field:, from:, to:)
+          return if from == to
+          return if !history.empty? && history.order_by(:created_at.desc).first.to != from
+
+          event = Core::Models::Event.create(field: field, from: from, to: to, document: self)
+          event.save
+        end
+
+        # Submodule holding all the static methods add to the current subclass.
+        # @author Vincent Courtois <courtois.vincent@outlook.com>
+        module ClassMethods
+          
+          # Takes the Mongoid declared field and creates the callbacks
+          # to intercept any value change and add it to the history.
+          # @field field [Mongoid::Fields::Standard] the Mongoid field to historize.
+          def historize(field)
+
+            unless relations.key?('history')
+              embeds_many :history, class_name: 'Core::Models::Event'
+            end
+
+            after_initialize do |doc|
+              add_history(field: field.name, from: nil, to: doc[field.name])
+            end
+
+            after_save do |doc|
+              if doc.changed_attributes.key?(field.name)
+                from = doc.changed_attributes[field.name]
+                add_history(field: field.name, from: from, to: doc[field.name])
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/core/models/concerns/mime_typable.rb

@@ -0,0 +1,44 @@
+module Core
+  module Models
+    module Concerns
+      # Includes the MIME type field to files to ensure only supported types are included.
+      # @author Vincent Courtois <courtois.vincent@outlook.com>
+      module MimeTypable
+        extend ActiveSupport::Concern
+
+        # Submodule holding all the static methods add to the current subclass.
+        # @author Vincent Courtois <courtois.vincent@outlook.com>
+        module ClassMethods
+          # Defines the MIME type attribute with the given possible MIME types.
+          # @param values [Array<String>] the possible MIME types, * can be used as wild cards.
+          def mime_type(values)
+
+            # @!attribute [rw] mime_type
+            #   @return [String] the MIME type of the file, obtained from the uploaded file.
+            field :mime_type, type: String
+        
+            validates :mime_type, presence: {message: 'required'}
+
+            validate :mime_type_validity, if: :mime_type?
+
+            # Validates the validity of the MIME type by checking if it respects any of the given mime types.
+            # If it does not respect any MIME types possible, it adds an error to the mime_type field and invalidates.
+            define_method :mime_type_validity do
+              checked_types = if values.is_a? Symbol
+                self.send(values) rescue []
+              else
+                values
+              end
+              return true if checked_types.empty?
+              checked_types.each do |type|
+                type_regex = ::Regexp.new("^#{type.sub(/\*/, '(.+)')}$")
+                return true if !type_regex.match(mime_type).nil?
+              end
+              errors.add(:mime_type, 'pattern')
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/core/models/concerns/premiumable.rb

@@ -0,0 +1,17 @@
+module Core
+  module Models
+    module Concerns
+      # Includes the premium field to make the entity including it accessible only to premium applications or not.
+      # @author Vincent Courtois <courtois.vincent@outlook.com>
+      module Premiumable
+        extend ActiveSupport::Concern
+
+        included do
+          # @!attribute [rw] premium
+          #   @return [Boolean] TRUE if the entity is made to be accessible only to premiuma pplications, FALSE otherwise.
+          field :premium, type: Boolean, default: false
+        end
+      end
+    end
+  end
+end