lesli 5.0.0

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

@@ -0,0 +1,133 @@
+=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
+
+                # 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 current_user
+                    return unless session[:user_session_id]
+
+
+                    # Try to save a unique record for this request configuration
+                    current_user.requests.upsert(
+                        {
+                            request_controller: controller_path,
+                            request_action: action_name,
+                            request_method: request.method,
+                            request_count: 1,
+                            session_id: session[:user_session_id]
+                        },
+                        
+                        # group of columns to consider a request as unique
+                        unique_by: %i[request_controller request_action user_id session_id],
+
+                        # if request id is not unique, increase the counter for this configuration
+                        on_duplicate: Arel.sql("request_count = lesli_user_requests.request_count + 1")
+                    )
+
+                    # update the last used date for the current session
+                    #current_user.sessions.where(id: session[:user_session_id]).first&.touch(:last_used_at)
+                end
+
+                # Track user agents
+                # this is disabled by default in the settings file
+                def log_user_agent
+                    return unless Lesli.config.security.dig(:enable_analytics)
+                    return unless current_user
+                    return unless session[:user_session_id]
+
+                    user_agent = get_user_agent(false)
+
+                    # Try to save a unique record for this agent configuration
+                    current_user.agents.upsert(
+                        {
+                            os: user_agent[:os] || "unknown",
+                            platform: user_agent[:platform] || "unknown",
+                            browser: user_agent[:browser] || "unknown",
+                            version: user_agent[:version] || "unknown",
+                            count: 1
+                        },
+                        # group of columns to consider a agent as unique
+                        unique_by: %i[platform os browser version user_id],
+
+                        # if request id is not unique, increase the counter for this configuration
+                        on_duplicate: Arel.sql("count = lesli_user_agents.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

@@ -0,0 +1,84 @@
+=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_helpers_for_request
+                    @query = {
+                        search: params[:search] || nil,
+                        pagination: {
+                            perPage: (params[:perPage] ? params[:perPage].to_i : 15),
+                            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

@@ -0,0 +1,132 @@
+=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

data/app/controllers/lesli/profiles_controller.rb

@@ -0,0 +1,60 @@
+module Lesli
+  class ProfilesController < ApplicationController
+    before_action :set_profile, only: %i[ show edit update destroy ]
+
+    # GET /profiles
+    def index
+      @profiles = Profile.all
+    end
+
+    # GET /profiles/1
+    def show
+    end
+
+    # GET /profiles/new
+    def new
+      @profile = Profile.new
+    end
+
+    # GET /profiles/1/edit
+    def edit
+    end
+
+    # POST /profiles
+    def create
+      @profile = Profile.new(profile_params)
+
+      if @profile.save
+        redirect_to @profile, notice: "Profile was successfully created."
+      else
+        render :new, status: :unprocessable_entity
+      end
+    end
+
+    # PATCH/PUT /profiles/1
+    def update
+      if @profile.update(profile_params)
+        redirect_to @profile, notice: "Profile was successfully updated.", status: :see_other
+      else
+        render :edit, status: :unprocessable_entity
+      end
+    end
+
+    # DELETE /profiles/1
+    def destroy
+      @profile.destroy
+      redirect_to profiles_url, notice: "Profile was successfully destroyed.", status: :see_other
+    end
+
+    private
+      # Use callbacks to share common setup or constraints between actions.
+      def set_profile
+        @profile = Profile.find(params[:id])
+      end
+
+      # Only allow a list of trusted parameters through.
+      def profile_params
+        params.fetch(:profile, {})
+      end
+  end
+end

data/app/controllers/users/confirmations_controller.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+class Users::ConfirmationsController < Devise::ConfirmationsController
+  # GET /resource/confirmation/new
+  # def new
+  #   super
+  # end
+
+  # POST /resource/confirmation
+  # def create
+  #   super
+  # end
+
+  # GET /resource/confirmation?confirmation_token=abcdef
+  # def show
+  #   super
+  # end
+
+  # protected
+
+  # The path used after resending confirmation instructions.
+  # def after_resending_confirmation_instructions_path_for(resource_name)
+  #   super(resource_name)
+  # end
+
+  # The path used after confirmation.
+  # def after_confirmation_path_for(resource_name, resource)
+  #   super(resource_name, resource)
+  # end
+end

data/app/controllers/users/omniauth_callbacks_controller.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+class Users::OmniauthCallbacksController < Devise::OmniauthCallbacksController
+  # You should configure your model like this:
+  # devise :omniauthable, omniauth_providers: [:twitter]
+
+  # You should also create an action method in this controller like this:
+  # def twitter
+  # end
+
+  # More info at:
+  # https://github.com/heartcombo/devise#omniauth
+
+  # GET|POST /resource/auth/twitter
+  # def passthru
+  #   super
+  # end
+
+  # GET|POST /users/auth/twitter/callback
+  # def failure
+  #   super
+  # end
+
+  # protected
+
+  # The path used when OmniAuth fails
+  # def after_omniauth_failure_path_for(scope)
+  #   super(scope)
+  # end
+end

data/app/controllers/users/passwords_controller.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+class Users::PasswordsController < Devise::PasswordsController
+  # GET /resource/password/new
+  # def new
+  #   super
+  # end
+
+  # POST /resource/password
+  # def create
+  #   super
+  # end
+
+  # GET /resource/password/edit?reset_password_token=abcdef
+  # def edit
+  #   super
+  # end
+
+  # PUT /resource/password
+  # def update
+  #   super
+  # end
+
+  # protected
+
+  # def after_resetting_password_path_for(resource)
+  #   super(resource)
+  # end
+
+  # The path used after sending reset password instructions
+  # def after_sending_reset_password_instructions_path_for(resource_name)
+  #   super(resource_name)
+  # end
+end

data/app/controllers/users/registrations_controller.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+class Users::RegistrationsController < Devise::RegistrationsController
+  # before_action :configure_sign_up_params, only: [:create]
+  # before_action :configure_account_update_params, only: [:update]
+
+  # GET /resource/sign_up
+  # def new
+  #   super
+  # end
+
+  # POST /resource
+  # def create
+  #   super
+  # end
+
+  # GET /resource/edit
+  # def edit
+  #   super
+  # end
+
+  # PUT /resource
+  # def update
+  #   super
+  # end
+
+  # DELETE /resource
+  # def destroy
+  #   super
+  # end
+
+  # GET /resource/cancel
+  # Forces the session data which is usually expired after sign
+  # in to be expired now. This is useful if the user wants to
+  # cancel oauth signing in/up in the middle of the process,
+  # removing all OAuth session data.
+  # def cancel
+  #   super
+  # end
+
+  # protected
+
+  # If you have extra params to permit, append them to the sanitizer.
+  # def configure_sign_up_params
+  #   devise_parameter_sanitizer.permit(:sign_up, keys: [:attribute])
+  # end
+
+  # If you have extra params to permit, append them to the sanitizer.
+  # def configure_account_update_params
+  #   devise_parameter_sanitizer.permit(:account_update, keys: [:attribute])
+  # end
+
+  # The path used after sign up.
+  # def after_sign_up_path_for(resource)
+  #   super(resource)
+  # end
+
+  # The path used after sign up for inactive accounts.
+  # def after_inactive_sign_up_path_for(resource)
+  #   super(resource)
+  # end
+end