virtuatable-core 1.0.0

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

@@ -0,0 +1,29 @@
+module Core
+  module Models
+    module Concerns
+      # Includes the slug field, always the same in all models.
+      # @author Vincent Courtois <courtois.vincent@outlook.com>
+      module Sluggable
+        extend ActiveSupport::Concern
+
+        # Module holding the class methods for the classes including this concern.
+        # @author Vincent Courtois <courtois.vincent@outlook.com>
+        module ClassMethods
+          # Add the field and its validations in the model including it.
+          # @param entity_type [String,Symbol] the name of the model including it, to be included in the error messages.
+          def make_sluggable(entity_type)
+            # @!attribute [rw] slug
+            #   @return [String] the slug of the current entity ; it must be snake-cased, longer than four characters, unique for the entity and given.
+            field :slug, type: String
+
+            validates :slug,
+              length: {minimum: 4, message: 'minlength', if: :slug?},
+              format: {with: /\A[a-z]+(_[a-z]+)*\z/, message: 'pattern', if: :slug?},
+              uniqueness: {message: 'uniq', if: :slug?},
+              presence: {message: 'required'}
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+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 Typable
+        extend ActiveSupport::Concern
+
+        included do
+          include Core::Models::Concerns::Enumerable
+          
+          # @!attribute [rw] type
+          #   @return [Symbol] the type of the instance, determining its way of being deployed, restarted, etc.
+          enum_field :type, [:heroku, :local, :unix], default: :heroku
+        end
+      end
+    end
+  end
+end

data/lib/core/models/concerns.rb

@@ -0,0 +1,16 @@
+module Core
+  module Models
+    # This module holds the shared concerns to include in the desired models.
+    # @author Vincent Courtois <courtois.vincent@outlook.com>
+    module Concerns
+      autoload :Activable     , 'core/models/concerns/activable'
+      autoload :Diagnosticable, 'core/models/concerns/diagnosticable'
+      autoload :Enumerable    , 'core/models/concerns/enumerable'
+      autoload :Historizable  , 'core/models/concerns/historizable'
+      autoload :MimeTypable   , 'core/models/concerns/mime_typable'
+      autoload :Premiumable   , 'core/models/concerns/premiumable'
+      autoload :Sluggable     , 'core/models/concerns/sluggable'
+      autoload :Typable       , 'core/models/concerns/typable'
+    end
+  end
+end

data/lib/core/models/decorators/errors/env_variable_missing.rb

@@ -0,0 +1,16 @@
+module Core
+  module Models
+    module Decorators
+      module Errors
+        # Error raised if the application key variable is missing.
+        # @author Vincent Courtois <courtois.vincent@outlook.com>
+        class EnvVariableMissing < Core::Models::Utils::Errors::HTTPError
+
+          def initialize(action:)
+            super(action, 'app_key', 'not_found', 404)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/core/models/decorators/errors.rb

@@ -0,0 +1,11 @@
+module Core
+  module Models
+    module Decorators
+      # Module holding all the errors concerning the code of the decorators.
+      # @author Vincent Courtois <courtois.vincent@outlook.com>
+      module Errors
+        autoload :EnvVariableMissing, 'core/models/decorators/errors/env_variable_missing'
+      end
+    end
+  end
+end

data/lib/core/models/decorators/gateway.rb

@@ -0,0 +1,111 @@
+module Core
+  module Models
+    module Decorators
+      # Decorator for a service, providing methods to make requests on it.
+      # @author Vincent Courtois <courtois.vincent@outlook.com>
+      class Gateway < Draper::Decorator
+        delegate_all
+
+        # @!attribute [rw] action
+        #   @return [String] the action of the route using this API.
+        attr_accessor :action
+
+        attr_accessor :logger
+
+        def initialize(action, _object)
+          super(_object)
+          @logger = Logger.new(STDOUT)
+          @action = action
+        end
+
+        # Shortcut to make a DELETE request on the API.
+        # @param session [Core::Models::Authentication::Session] the session of the user requesting the API.
+        # @param url [String] the URL you want to reach on the service.
+        # @param params [Hash] the additional parameters to pass in the JSON body.
+        def delete(session:, url:, params:)
+          return make_request_without_body(verb: 'delete', session: session, url: url, params: params)
+        end
+
+        # Shortcut to make a GET request on the API.
+        # @param session [Core::Models::Authentication::Session] the session of the user requesting the API.
+        # @param url [String] the URL you want to reach on the service.
+        # @param params [Hash] the additional parameters to pass in the JSON body.
+        def get(session:, url:, params:)
+          return make_request_without_body(verb: 'get', session: session, url: url, params: params)
+        end
+
+        # Shortcut to make a POST request on the API.
+        # @param session [Core::Models::Authentication::Session] the session of the user requesting the API.
+        # @param url [String] the URL you want to reach on the service.
+        # @param params [Hash] the additional parameters to pass in the JSON body.
+        def post(session:, url:, params:)
+          return make_request(verb: 'post', session: session, url: url, params: params)
+        end
+
+        # Shortcut to make a PUT request on the API.
+        # @param session [Core::Models::Authentication::Session] the session of the user requesting the API.
+        # @param url [String] the URL you want to reach on the service.
+        # @param params [Hash] the additional parameters to pass in the JSON body.
+        def put(session:, url:, params:)
+          return make_request(verb: 'put', session: session, url: url, params: params)
+        end
+
+        private
+
+        # Makes a POST request to the given service with the following steps :
+        # 1. Gets an active and running instance of the service to make the request.
+        # 2. Creates a Faraday connection to use it as a pipeline for the request.
+        # 3. Makes the actual request and returns an object with the status and body of the response.
+        #
+        # @param verb [String] the HTTP verb to use for this request.
+        # @param session [Core::Models::Authentication::Session] the session of the user requesting the API.
+        # @param url [String] the URL you want to reach on the service.
+        # @param params [Hash] the additional parameters to pass in the JSON body.
+        #
+        # @return [Hash, Boolean] FALSE if no instance are found, or an object with :status and :body keys correspding
+        #                         to the status and body of the response to the request
+        def make_request(verb:, session:, url:, params:)
+          params = before_requests(session, params)
+          connection = get_connection
+
+          response = connection.send(verb) do |req|
+            req.url url
+            req.headers['Content-Type'] = 'application/json'
+            req.body = params.to_json
+          end
+
+          return {
+            status: response.status,
+            body: JSON.parse(response.body)
+          }
+        end
+
+        def make_request_without_body(verb:, session:, url:, params:)
+          params = before_requests(session, params)
+          connection = get_connection
+          response = connection.send(verb) do |req|
+            req.url url, params
+            req.headers['Content-Type'] = 'application/json'
+          end
+        end
+
+        def before_requests(session, params)
+          if ENV['APP_KEY'].nil?
+            raise Core::Models::Decorators::Errors::EnvVariableMissing.new(action: action)
+          end
+          params[:app_key] = ENV['APP_KEY']
+          params[:session_id] = session.token
+          return params
+        end
+
+        def get_connection
+          Faraday.new(object.url) do |faraday|
+            faraday.request  :url_encoded
+            faraday.response :logger
+            faraday.adapter  Faraday.default_adapter
+          end
+        end
+      end
+    end
+  end
+end

data/lib/core/models/event.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Core
+  module Models
+    # An event is symbolizing a timestamped change in a model.
+    # It is recommended NOT to use this class directly but to use
+    # the Core::Models::Concerns::Historizable concern in a model.
+    #
+    # @author Vincent Courtois <courtois.vincent@outlook.com>
+    class Event
+      include Mongoid::Document
+      include Mongoid::Timestamps
+
+      # @!attribute [rw] field
+      #   @return [String] the name of the field being historized
+      field :field, type: String
+      # @!attribute [rw] from
+      #   @return [Any] the value of the field before update
+      field :from
+      # @!attribute [rw] to
+      #   @return [Any] the value of the field after update
+      field :to
+
+      # @!attribute [rw] document
+      #   @return [Any] the model in which the history is embedded
+      embedded_in :document, polymorphic: true, inverse_of: :history
+
+      validates :field, presence: { message: 'required' }
+    end
+  end
+end

data/lib/core/models/factories/errors/gateway_not_found.rb

@@ -0,0 +1,16 @@
+module Core
+  module Models
+    module Factories
+      module Errors
+        # Error raised when not gateway active and running is found in the factory.
+        # @author Vincent Courtois <courtois.vincent@outlook.com>
+        class GatewayNotFound < Core::Models::Utils::Errors::HTTPError
+
+          def initialize(action:)
+            super(action, 'gateway_id', 'not_found', 404)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/core/models/factories/errors.rb

@@ -0,0 +1,11 @@
+module Core
+  module Models
+    module Factories
+      # Module holding all the errors concerning the code of the factories.
+      # @author Vincent Courtois <courtois.vincent@outlook.com>
+      module Errors
+        autoload :GatewayNotFound, 'core/models/factories/errors/gateway_not_found'
+      end
+    end
+  end
+end

data/lib/core/models/factories.rb

@@ -0,0 +1,10 @@
+module Core
+  module Models
+    # Static factories are used to create decorated objects easily.
+    # @author Vincent Courtois <courtois.vincent@outlook.com>
+    module Factories
+      autoload :Gateways, 'core/models/factories/gateways'
+      autoload :Errors  , 'core/models/factories/errors'
+    end
+  end
+end

data/lib/core/models/files/document.rb

@@ -0,0 +1,52 @@
+module Core
+  module Models
+    module Files
+      # a document is an uploaded file in the S3 clone application.
+      # @author Vincent Courtois <courtois.vincent@outlook.com>
+      class Document
+        include Mongoid::Document
+        include Mongoid::Timestamps
+
+        # @!attribute [rw] name
+        #   @return [String] the filename the user entered when uploading the file.
+        field :name, type: String
+
+        field :extension, type: String
+        # @!attribute [rw] size
+        #   @return [String] the size, in bytes, of the uploaded file.
+        field :size, type: Integer, default: 0
+        # @!attribute [rw] folder
+        #   @return [String] the folder in which the file is stored in the S3 clone.
+        field :folder, type: String, default: '/'
+        # @!attribute [rw] mime_type
+        #   @return [String] the MIME type of the file. this MAY not correspond to the real
+        #     MIME type of the uploaded file, this is just an indication.
+        field :mime_type, type: String
+
+        # @!attribute [rw] creator
+        #   @return [Core::Models::Account] the account of the person that uploaded the file.
+        belongs_to :creator, class_name: 'Core::Models::Account', inverse_of: :files
+
+        # @!attribute [rw] permissions
+        #   @return [Array<Core::Models::Files::Permission>] the permissions granted to access this file.
+        has_many :permissions, class_name: 'Core::Models::Files::Permission', inverse_of: :file
+
+        validates :name, :extension, :folder, :mime_type, presence: {message: 'required'}
+
+        validates :folder, format: {without: /\/\//, message: 'format'}
+
+        validate :filename_unicity
+
+        def filename_unicity
+          existing = Core::Models::Files::Document.where(
+            name: name,
+            folder: folder,
+            extension: extension,
+            :id.ne => id
+          )
+          errors.add(:name, 'uniq') unless existing.first.nil?
+        end
+      end
+    end
+  end
+end

data/lib/core/models/files/permission.rb

@@ -0,0 +1,24 @@
+module Core
+  module Models
+    module Files
+      # The permission granted to a user to access and/or delete a file.
+      # @author Vincent Courtois <courtois.vincent@outlook.com>
+      class Permission
+        include Mongoid::Document
+        include Mongoid::Timestamps
+        include Core::Models::Concerns::Enumerable
+
+        # @!attribute [rw] type
+        #   @return [Symbol] the type of permission granted (is the user able to delete the file ?)
+        enum_field :type, [:read, :read_write]
+
+        # @!attribute [rw] file
+        #   @return [Core::Models::Files::Document] the document the permission is linked to.
+        belongs_to :file, class_name: 'Core::Models::Files::Document', inverse_of: :permissions
+        # @!attribute [rw] account
+        #   @return [Core::Models::Account] the user being granted the access to the file.
+        belongs_to :account, class_name: 'Core::Models::Account', inverse_of: :permissions
+      end
+    end
+  end
+end

data/lib/core/models/files.rb

@@ -0,0 +1,8 @@
+module Core
+  module Models
+    module Files
+      autoload :Document  , 'core/models/files/document'
+      autoload :Permission, 'core/models/files/permission'
+    end
+  end
+end

data/lib/core/models/monitoring/route.rb

@@ -0,0 +1,44 @@
+module Core
+  module Models
+    module Monitoring
+      # A route is an endpoint accessible in a service. Each route has to have an associated endpoint in the deployed instances.
+      # @param Vincent Courtois <courtois.vincent@outlook.com>
+      class Route
+        include Mongoid::Document
+        include Mongoid::Timestamps
+        include Core::Models::Concerns::Premiumable
+        include Core::Models::Concerns::Activable
+
+        # @!attribute [rw] path
+        #   @return [String] the path (URI) of the route in the service?
+        field :path, type: String, default: '/'
+        # @!attribute [rw] verb
+        #   @return [String] the verb (HTTP method) of this route in the service.
+        field :verb, type: String, default: 'get'
+        # @!attribute [rw] authenticated
+        #   @return [Boolean] if true, the session_id is needed for this route, if false it is not.
+        field :authenticated, type: Boolean, default: true
+
+        # @!attribute [rw] service
+        #   @return [Core::Models::Monitoring::Service] the service in which this route is declared.
+        belongs_to :service, class_name: 'Core::Models::Monitoring::Service', inverse_of: :routes
+
+        # @!attribute [rw] groups
+        #   @return [Array<Core::Models::Permissions::Group>] the groups having permission to access this route.
+        has_and_belongs_to_many :groups, class_name: 'Core::Models::Permissions::Group', inverse_of: :groups
+
+        validates :path,
+          format: {with: /\A(\/|((\/:?[a-zA-Z0-9_]+)+))\z/, message: 'pattern', if: :path?}
+
+        validates :verb,
+          inclusion: {message: 'unknown', in: ['get', 'post', 'put', 'delete', 'patch', 'option']}
+
+        # Returns the complete path, enriched with the path of the service.
+        # @return [String] the complete path to access this route from the outside.
+        def complete_path
+          path == '/' ? service.path : "#{service.path}#{path}"
+        end
+      end
+    end
+  end
+end

data/lib/core/models/monitoring/service.rb

@@ -0,0 +1,33 @@
+module Core
+  module Models
+    module Monitoring
+      # A service is the representation of one of the applications composing the API.
+      # @author Vincent Courtois <courtois.vincent@outlook.com>
+      class Service
+        include Mongoid::Document
+        include Mongoid::Timestamps
+        include Core::Models::Concerns::Activable
+        include Core::Models::Concerns::Diagnosticable
+        include Core::Models::Concerns::Premiumable
+
+        # @!attribute [rw] key
+        #   @return [String] the name of the service, used as a namespace on the Kubernetes side.
+        field :key, type: String
+        # @!attribute [rw] path
+        #   @return [String] the path the service will be mapped on in the API. This will be used in the Ingress.
+        field :path, type: String, default: '/'
+
+        # @!attribute [rw] creator
+        #   @return [Core::Models::Account] the creator of this service.
+        belongs_to :creator, class_name: 'Core::Models::Account', optional: true, inverse_of: :services
+        # @!attribute [rw] routes
+        #   @return [Array<Core::Models::Monitoring::Route>] the routes associated to this service, accessible from the gateway.
+        has_many :routes, class_name: 'Core::Models::Monitoring::Route', inverse_of: :service
+
+        validates :key, uniqueness: {message: 'uniq'}
+
+        validates :path, format: {with: /\A(\/:?[a-z]+)+\z/, message: 'pattern'}
+      end
+    end
+  end
+end

data/lib/core/models/monitoring.rb

@@ -0,0 +1,10 @@
+module Core
+  module Models
+    # The monitoring module holds all the logic about the services so they can be activated or deactivated.
+    # @author Vincent Courtois <courtois.vincent@outlook.com>
+    module Monitoring
+      autoload :Route  , 'core/models/monitoring/route'
+      autoload :Service, 'core/models/monitoring/service'
+    end
+  end
+end

data/lib/core/models/notification.rb

@@ -0,0 +1,24 @@
+module Core
+  module Models
+    # A notification is a little something to warn a user that an action concerning him or her occurred.
+    # @author Vincent Courtois <courtois.vincent@outlook.com>
+    class Notification
+      include Mongoid::Document
+      include Mongoid::Timestamps
+
+      # @!attribute [rw] type
+      #   @return [String] the type of notification this is supposed to be. All types are custom and facultative.
+      field :type, type: String, default: 'NOTIFICATIONS.DEFAULT'
+      # @!attribute [rw] read
+      #   @return [Boolean] TRUE if the notification has been read (seen by the user), FALSE otherwise.
+      field :read, type: Boolean, default: false
+      # @!attribute [rw] data
+      #   @return [Hash] the custom data that can be attached to this notification, for example for an invitation it can be the invited username.
+      field :data, type: Hash, default: {}
+
+      # @!attribute [rw] account
+      #   @return [Core::Models::Account] the account concerned by this notification.
+      embedded_in :account, class_name: 'Core::Models::Account', inverse_of: :notifications
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+module Core
+  module Models
+    module OAuth
+      # An access token is the value assigned to the application
+      # to access the data the user is allowed to access.
+      # @author Vincent Courtois <courtois.vincent@outlook.com>
+      class AccessToken
+        include Mongoid::Document
+        include Mongoid::Timestamps
+
+        # @!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
+
+        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?
+          created_at.to_time.to_i + expiration < Time.now.to_i
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+module Core
+  module Models
+    module OAuth
+      # An application is what is referred to in the OAuth2.0 RFC as a client, wanting to access private informations about the user.
+      # @author Vincent Courtois <courtois.vincent@outlook.com>
+      class Application
+        include Mongoid::Document
+        include Mongoid::Timestamps
+
+        # @!attribute [rw] name
+        #   @return [String] the unique name of the application, mainly used to identify and display it.
+        field :name, type: String
+        # @!attribute [rw] key
+        #   @return [String] the unique key for the application, identifying it when requesting a token for the API.
+        field :key, type: String, default: ->{ SecureRandom.hex }
+        # @!attribute [rw] premium
+        #   @return [Boolean] a value indicating whether the application should automatically receive a token when an account is created, or not.
+        field :premium, type: Boolean, default: false
+        # @!attirbute [rw] redirect_uris
+        #   @return [Array<String>] the redirection URIs used for this application.
+        field :redirect_uris, type: Array, default: []
+
+        # @!attribute [rw] creator
+        #   @return [Core::Models::Account] the account that has created this application, considered its owner.
+        belongs_to :creator, class_name: 'Core::Models::Account', inverse_of: :applications
+        # @!attribute [rw] authorizations
+        #   @return [Array<Core::Models::OAuth::Authorization>] the authorizations linked to the accounts this application can get the data from.
+        has_many :authorizations, class_name: 'Core::Models::OAuth::Authorization', inverse_of: :application
+
+        validates :name,
+          presence: {message: 'required'},
+          length: {minimum: 6, message: 'minlength'},
+          uniqueness: {message: 'uniq'}
+
+        validates :key,
+          presence: {message: 'required'},
+          uniqueness: {message: 'uniq'}
+
+        validate :redirect_uris_values
+
+        # Checks the URIs to get sure they are correct, a URI is correct if :
+        # - it is a string
+        # - it has a correct URL format.
+        def redirect_uris_values
+          redirect_uris.each do |uri|
+            if !uri.is_a? String
+              errors.add(:redirect_uris, 'type')
+              break
+            elsif uri.match(/\A(https?:\/\/)((([\da-z\.-]+)\.([a-z\.]{2,6})([\/\w \.-]*)*)|(localhost:[0-9]{2,4})\/?)\z/).nil?
+              errors.add(:redirect_uris, 'format')
+              break
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+module Core
+  module Models
+    module OAuth
+      # An OAuth authorization is granted by a user to an application to access its personal data.
+      # The application then transforms it into an access token to be able to send it with
+      # further requests, so that we know the user has authorized the application to access its data.
+      #
+      # @author Vincent Courtois <courtois.vincent@outlook.com>
+      class Authorization
+        include Mongoid::Document
+        include Mongoid::Timestamps
+
+        # @!attribute [rw] code
+        #   @return [String] the value corresponding to the authentication code in the RFC of OAuth2.0, kep for historic purpose.
+        field :code, type: String, default: ->{ SecureRandom.hex }
+
+        # @!attribute [rw] account
+        #   @return [Arkaaan::Account] the account granting the authorization to access its data to the application.
+        belongs_to :account, class_name: 'Core::Models::Account', inverse_of: :authorizations
+        # @!attribute [rw] application
+        #   @return [Core::Models::OAuth::Application] the application asking to access account's data.
+        belongs_to :application, class_name: 'Core::Models::OAuth::Application', inverse_of: :authorizations
+        # @!attribute [rw] token
+        #   @return [Core::Models::OAuth::AccessToken] the access token used further in the application process to access private data of the account.
+        has_many :tokens, class_name: 'Core::Models::OAuth::AccessToken', inverse_of: :authorization
+
+        validates :code,
+          presence: {message: 'required'},
+          uniqueness: {message: 'uniq'}
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+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
+
+        # @!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] 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: :refresh_token
+      end
+    end
+  end
+end

data/lib/core/models/oauth.rb

@@ -0,0 +1,12 @@
+module Core
+  module Models
+    # This module holds the logic for the connection of an application to our API.
+    # @author Vincent Courtois <courtois.vincent@outlook.com>
+    module OAuth
+      autoload :Application  , 'core/models/oauth/application'
+      autoload :Authorization, 'core/models/oauth/authorization'
+      autoload :AccessToken  , 'core/models/oauth/access_token'
+      autoload :RefreshToken , 'core/models/oauth/refresh_token'
+    end
+  end
+end