lesli 5.0.13 → 5.0.14

data/app/controllers/lesli/interfaces/application/authorization.rb

@@ -1,107 +0,0 @@
-module Lesli
-    module Interfaces
-        module Application
-            module Authorization
-
-
-                # Validate user authentication and session status
-                def authorize_request
-
-                    # this version Lesli requires to be mounted as root "/"
-                    # engine_path = Lesli::Engine.routes.find_script_name({})
-                    engine_path = nil
-
-                    # check if the users is logged into the system
-                    unless user_signed_in?()
-
-                        message = "Please Login to view that page!"
-
-                        # check if requested url is valid
-                        if (request.get? && is_navigational_format? && !request.xhr? && !request.fullpath.blank?)
-
-                            # redirect only if the path worth it
-                            if request.fullpath != "/"
-
-                                # redirect with requested url, so user will be redirected after login
-                                redirect_to("#{engine_path}/login?r=#{request.fullpath}", notice: message) and return
-
-                            end
-
-                        end
-
-                        # redirect to root route
-                        redirect_to("#{engine_path}/login", notice: message) and return
-
-                    end
-
-                    # run aditinal validations only for html requests
-                    return true unless request.format.html?
-
-                    # # get the current user session
-                    # current_session = current_user.sessions.find_by(id: session[:user_session_id])
-
-                    # # check if user has an active session
-                    # if current_session.equal? nil or !current_session.active?
-                    #     current_user.logs.create({ title: "system_session_logout", description: "session finished by the system"})
-                    #     sign_out current_user
-                    #     redirect_to "#{engine_path}/logout" and return
-                    # end
-
-                    # if !current_session.expiration_at.blank? && current_session.expiration_at < Time.current
-                    #     current_user.logs.create({ title: "system_session_logout", description: "session expired by the system"})
-                    #     sign_out current_user
-                    #     redirect_to "#{engine_path}/logout" and return
-                    # end
-
-                    # # check password expiration date
-                    # if current_user.has_expired_password?
-                    #     unless controller_name == "profiles"
-                    #         current_user.logs.create({ description: "redirect_due_to_expired_password" })
-                    #         redirect_to "/administration/profile#force-password-reset", notice: I18n.t("core.users/sessions.messages_danger_password_expired")
-                    #         return
-                    #     end
-                    # end
-
-                end
-
-
-                # Check if current_user has privileges to complete this request
-                # allowed core methods:
-                #   [:index, :create, :update, :destroy, :new, :show, :edit, :options, :search, :resources]
-                def authorize_privilege
-
-                    # check if user has access to the requested controller
-                    # this search is over all the privileges for all the roles of the user
-                    granted = current_user.has_privileges_for?(params[:controller], params[:action])
-
-                    # get the path to which the user is limited to
-                    limited_path = current_user.has_role_limited_to_path?
-
-                    # to redirect to the limited path we must check:
-                    #   limited_path must not to be nil or empty string ("")
-                    #   limited_path must not to be equal to the current path (to avoid a loop)
-                    #   request must not to be AJAX
-                    #   request must be for show or index views
-                    if  !limited_path.blank? and
-                        !(limited_path == request.original_fullpath) and
-                        !(request[:format] == "json") and
-                        ["show", "index"].include?(params[:action])
-
-                        return redirect_to(limited_path)
-                    end
-
-                    # privilege for object not found
-                    if granted.blank?
-                        current_user.logs.create({ title: "privilege_not_found", description: request.path })
-                        return respond_with_unauthorized({ controller: params[:controller], privilege: params[:action] })
-                    end
-
-                    unless granted
-                        current_user.logs.create({ title: "privilege_not_granted", description: request.path })
-                        return respond_with_unauthorized({ controller: params[:controller], privilege: params[:action] })
-                    end
-                end
-            end
-        end
-    end
-end

data/app/controllers/lesli/interfaces/application/customization.rb

@@ -1,46 +0,0 @@
-module Lesli
-    module Interfaces
-        module Application
-            module Customization
-
-                # set customization only for lesli_cloud instance
-                def set_customizer
-=begin
-                    # @account is only for html and pdf requests
-                    return unless request.format.html? || request.format.pdf?
-
-                    # return unless Lesli.instance[:code] == "lesli_cloud"
-
-                    @lesli[:customization] = {}
-
-                    logos = {}
-                    # logo_identifiers = Account::File.file_types.keys
-                    # custom_logos = current_user.account.files.where("file_type in (?)", logo_identifiers).order(id: :desc).all
-                    # logo_identifiers.each do |logo_identifier|
-                    #     custom_logo = custom_logos.find { |logo| logo.file_type == logo_identifier}
-                    #     next unless custom_logo
-
-                    #     custom_logo_url = "/administration/account/files/#{custom_logo.id}"
-                    #     custo_logo_url = custom_logo.attachment_url if custom_logo.attachment_identifier
-                    #     custom_logo_url = custom_logo.attachment_public_url if custom_logo.attachment_public_identifier
-
-                    #     logos[logo_identifier.to_sym] = custom_logo_url
-                    # end
-                    @lesli[:customization][:logos] = logos
-
-                    colors = {}
-                    # color_identifiers = ::Account::Setting.theme_settings_keys
-                    # custom_colors = current_user.account.settings.where("name in (?)", color_identifiers).all
-                    # color_identifiers.each do |color_identifier|
-                    #     custom_color = custom_colors.find { |color| color.name == color_identifier}
-                    #     next unless custom_color
-
-                    #     colors[color_identifier.to_sym] = custom_color.value
-                    # end
-                    @lesli[:customization][:colors] = colors
-=end
-                end
-            end
-        end
-    end
-end

data/app/controllers/lesli/interfaces/application/logger.rb

@@ -1,134 +0,0 @@
-=begin
-
-Lesli
-
-Copyright (c) 2023, Lesli Technologies, S. A.
-
-This program is free software: you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation, either version 3 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with this program. If not, see http://www.gnu.org/licenses/.
-
-Lesli · Ruby on Rails SaaS Development Framework.
-
-Made with ♥ by https://www.lesli.tech
-Building a better future, one line of code at a time.
-
-@contact  hello@lesli.tech
-@website  https://www.lesli.tech
-@license  GPLv3 http://www.gnu.org/licenses/gpl-3.0.en.html
-
-// · ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~
-// · 
-=end
-
-module Lesli
-    module Interfaces
-        module Application
-            module Logger
-                def get_user_agent(as_string=true)
-
-                    http_user_agent = request.env["HTTP_USER_AGENT"]
-
-                    # parse user agent
-                    user_agent = UserAgent.parse(http_user_agent)
-
-                    user_agent_version = user_agent.version.to_a.first(2).join(".")
-
-                    # return user agent as object
-                    if as_string == false
-                        return {
-                            platform: user_agent.platform,
-                            os: user_agent.os,
-                            browser: user_agent.browser,
-                            version: user_agent_version
-                        }
-                    end
-
-                    # return user agent info as string
-                    "#{user_agent.platform} #{user_agent.os} - #{user_agent.browser} #{user_agent_version}"
-                end
-
-                def log_requests
-                    log_account_requests
-                    log_user_requests
-                end 
-
-                def log_account_requests
-                    return unless Lesli.config.security.dig(:enable_analytics)
-                    return unless defined?(LesliAudit)
-                    return unless current_user
-
-                    # Try to save a unique record for this request configuration
-                    current_user.account.audit.account_requests.upsert(
-                        {
-                            request_controller: controller_path,
-                            request_action: action_name,
-                            request_count: 1
-                        },
-                        
-                        # group of columns to consider a request as unique
-                        unique_by: %i[request_controller request_action created_at account_id],
-
-                        # if request id is not unique, increase the counter for this configuration
-                        on_duplicate: Arel.sql("request_count = lesli_audit_account_requests.request_count + 1")
-                    )
-                end
-
-                # Track all user activity
-                # this is disabled by default in the settings file
-                def log_user_requests
-                    return unless Lesli.config.security.dig(:enable_analytics)
-                    return unless defined?(LesliAudit)
-                    return unless current_user
-                    return unless session[:user_session_id]
-                    
-                    # Try to save a unique record for this request configuration
-                    current_user.account.audit.user_requests.upsert(
-                        {
-                            request_controller: controller_path,
-                            request_action: action_name,
-                            session_id: session[:user_session_id],
-                            user_id: current_user.id,
-                            request_count: 1
-                        },
-                                
-                        # group of columns to consider a request as unique
-                        unique_by: %i[request_controller request_action created_at user_id session_id],
-
-                        # if request id is not unique
-                        #   - increase the counter for this configuration
-                        #   - update the datetime of the last request
-                        on_duplicate: Arel.sql(
-                            'request_count = lesli_audit_user_requests.request_count + 1'
-                        )
-                    )
-                end
-
-                # Track specific account activity
-                # this is disabled by default in the settings file
-                def log_account_activity(system_module, system_process, title = nil, payload = nil, description = nil)
-                    # return unless Rails.application.config.lesli.dig(:security, :enable_analytics)
-
-                    # account = Account.first
-
-                    # account.activities.create({
-                    #     system_module:,
-                    #     system_process:,
-                    #     description:,
-                    #     payload:,
-                    #     title:
-                    # })
-                end
-            end
-        end
-    end
-end

data/app/controllers/lesli/interfaces/application/requester.rb

@@ -1,84 +0,0 @@
-=begin
-
-Lesli
-
-Copyright (c) 2023, Lesli Technologies, S. A.
-
-This program is free software: you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation, either version 3 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with this program. If not, see http://www.gnu.org/licenses/.
-
-Lesli · Ruby on Rails SaaS Development Framework.
-
-Made with ♥ by https://www.lesli.tech
-Building a better future, one line of code at a time.
-
-@contact  hello@lesli.tech
-@website  https://www.lesli.tech
-@license  GPLv3 http://www.gnu.org/licenses/gpl-3.0.en.html
-
-// · ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~
-// · 
-=end
-
-module Lesli
-    module Interfaces
-        module Application
-            module Requester
-
-                def set_path
-                    @@engine_path = Lesli::Engine.routes.find_script_name({})
-                end
-
-                # Set the user language based on user_settings, session configuration or instance default locale
-                def set_locale
-                    # get saved language in session, browser language or the default in config
-                    # the session param is setted in settings controller through "get :language, to: "settings#language""
-                    locale = session[:locale] || I18n.default_locale
-
-                    # get user's preferred language
-                    # IMPORTANT:
-                    #       Here it's not possible to use the methods provided by devise to check if user is
-                    #       authenticated "user_signed_in", due those methods redirects to the login controller
-                    #       if user is not authenticated; For some scenarios we need to have control of the behavior
-                    #       for not authenticated user requests, thats why here we go deeper and check if user is
-                    #       authenticated checking the warden storage
-                    # locale = current_user.locale if warden.authenticated?
-
-                    # language defined in the http header request
-                    locale = request.headers["Require-Language"] unless request.headers["Require-Language"].blank?
-
-                    # use default locale if requested language is not supported
-                    locale = I18n.default_locale unless I18n.available_locales.include?(locale.to_sym)
-
-                    # set the new locale
-                    I18n.locale = locale
-                end
-
-                # Set default query params for:
-                def set_requester
-                    @query = {
-                        search: params[:search] || nil,
-                        pagination: {
-                            perPage: (params[:perPage] ? params[:perPage].to_i : 12),
-                            page: (params[:page] ? params[:page].to_i : 1)
-                        },
-                        order: {
-                            by: (params[:orderBy] || "id"),
-                            dir: (params[:order] || "desc")
-                        }
-                    }
-                end
-            end
-        end
-    end
-end

data/app/controllers/lesli/interfaces/application/responder.rb

@@ -1,132 +0,0 @@
-=begin
-
-Lesli
-
-Copyright (c) 2023, Lesli Technologies, S. A.
-
-This program is free software: you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation, either version 3 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with this program. If not, see http://www.gnu.org/licenses/.
-
-Lesli · Your Smart Business Assistant.
-
-Made with ♥ by https://www.lesli.tech
-Building a better future, one line of code at a time.
-
-@contact  hello@lesli.tech
-@website  https://lesli.tech
-@license  GPLv3 http://www.gnu.org/licenses/gpl-3.0.en.html
-
-// · ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~
-// ·
-=end
-
-module Lesli
-    module Interfaces
-        module Application
-            module Responder
-                # Return an standard http 200 respond
-                def respond_with_successful(payload = nil)
-                    # Response for modern Lesli 3 apps
-                    respond_with_http(200, payload)
-                end
-
-                # Usage example
-                # tasks = Task
-                # .joins(:detail)
-                # .page(query[:pagination][:page])
-                # .per(query[:pagination][:perPage])
-                #
-                # respond_with_successful_pagination(tasks)
-                #
-                # IMPORTANT: It is strictly necessary to use the pagination methods
-                #            to make this work properly
-                def respond_with_pagination(records, payload = nil)
-                    respond_with_http(200, {
-                        pagination: {
-                            page: records.current_page,
-                            pages: records.total_pages,
-                            total: records.total_count,
-                            results: records.length
-                        },
-                        records: payload || records
-                    })
-                end
-
-                # JSON not found response
-                def respond_with_not_found
-                    # Keep compatibility with Deutsche Leibrenten
-                    if defined? DeutscheLeibrenten
-                        response_body = {
-                            successful: false,
-                            error: {
-                                message: I18n.t("core.shared.messages_danger_not_found"),
-                                details: []
-                            }
-                        }
-                        return render(status: 404, json: response_body.to_json)
-                    end
-
-                    respond_with_http(404, {
-                                          message: I18n.t("core.shared.messages_danger_not_found")
-                                      })
-                end
-
-                # JSON not found response
-                def respond_with_unauthorized(detail = {})
-                    error_object = {}
-
-                    error_object[:message] = I18n.t("core.shared.view_text_unauthorized_request")
-                    error_object[:detail] = detail if Rails.env == "development"
-
-                    error_object[:role] = "( #{current_user.roles.map(&:name).join(', ')} )" if (Rails.env == "development") && !current_user.blank?
-
-                    respond_to do |format|
-                        format.json { render status: 401, json: error_object.to_json }
-                        format.html { redirect_to "/401" } if Rails.env == "production"
-                        format.html { render status: 401, json: error_object.to_json }
-                        # format.xlsx { redirect_to "/401" } if Rails.env == "production"
-                        # format.xlsx { render status: 401, json: error_object.to_json }
-                    end
-                end
-
-                # JSON failure response due users has to perform an action
-                # example: respond_with_action({ :redirect => "telephone_confirmation" })
-                def respond_with_action(action, message = "Action Required")
-                    respond_with_http(490, { :message => message, :action => action })
-                end
-
-                # JSON failure response
-                def respond_with_error(message = "", details = [])
-                    # Message should be a String
-                    message = "" unless message.instance_of?(String)
-
-                    # TODO:
-                    #   check if active error and then:
-                    #       message = error message to sentence
-                    #       details = error array of messages
-                    #   check another types of errors and parse respond according
-                    respond_with_http(400, { :message => message, :details => details })
-                end
-
-                # Respond with an standard http message
-                def respond_with_http(status, payload)
-                    unless payload.nil?
-                        return render(:status => status, content_type: "application/json", json: payload.to_json)
-                    end
-
-                    render(:status => status, content_type: "application/json", json: "")
-                end
-            end
-        end
-    end
-end