lesli 5.0.13 → 5.0.14

data/app/interfaces/lesli/requester_interface.rb

@@ -0,0 +1,103 @@
+=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 RequesterInterface
+
+        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
+
+        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
+    end
+end

data/app/interfaces/lesli/responder_interface.rb

@@ -0,0 +1,127 @@
+=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 ResponderInterface
+
+        # Return an standard http 200 respond
+        def respond_as_successful(payload = nil)
+            payload
+        end
+
+        # Usage example
+        # tasks = Task
+        # .joins(:detail)
+        # .page(query[:pagination][:page])
+        # .per(query[:pagination][:perPage])
+        #
+        # respond_with_pagination(tasks)
+        #
+        # IMPORTANT: It is strictly necessary to use the pagination methods
+        #            to make this work properly
+        def respond_as_pagination(payload)
+            {
+                pagination: {
+                    page: payload.current_page,
+                    pages: payload.total_pages,
+                    total: payload.total_count,
+                    results: payload.length
+                },
+                records: payload
+            }
+        end
+
+
+
+
+        def respond_with_successful(payload = nil)
+            respond_with_http(200, respond_as_successful(payload))
+        end
+
+        def respond_with_pagination(payload)
+            respond_with_http(200, respond_as_pagination(payload))
+        end
+
+        # JSON not found response
+        def respond_with_not_found
+            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.lesliroles.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

data/app/lib/date2.rb

@@ -1,200 +1,2 @@
-=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
-
-class Date2
-
-    def initialize(datetime = Time.current, format = "%Y-%m-%d %H:%M:%S")
-
-        # NOTE: user should be able to change this through settings table
-        # get initial datetime configuration
-        config = Lesli.config.datetime
-
-
-        # NOTE: Do not modify settings here,
-        # if you need a different date format you should change it in the config file
-        # Check the docs for more information: /development/docs/rails-lib-time
-
-        # configuration example
-        # @settings = {
-        #     :time_zone => config[:time_zone],
-        #     :start_week_on => config[:start_week_on],
-        #     :format => {
-        #         :date => "%d.%m.%Y",
-        #         :time => "%H:%M %p", # 12 hours datetime format
-        #         :time => "%H:%M",    # 24 hours datetime format (default)
-        #         :date_time => "%d.%m.%Y %I:%M %p", # 12 hours datetime format
-        #         :date_time => "%d.%m.%Y %H:%M",    # 24 hours datetime format (default)
-        #         :date_words => "%A, %B %d, %Y",
-        #         :date_time_words => "%A, %B %d, %Y, %I:%M %p", # 12 hours datetime in words format
-        #         :date_time_words => "%A, %B %d, %Y, %H:%M"    # 24 hours datetime in words format (default)
-        #     }
-        # }
-
-        @settings = {
-            :time_zone => config[:time_zone],
-            :start_week_on => config[:start_week_on],
-            :format => {
-                :date => "%d.%m.%Y",
-                :time => "%H:%M",
-                :date_time => config[:formats][:date_time],
-                :date_words => "%A, %B %d, %Y",
-                :date_time_words => "%A, %B %d, %Y, %I:%M %p", # 12 hours datetime in words format
-                :date_time_words => "%A, %B %d, %Y, %H:%M"    # 24 hours datetime in words format (default)
-            }
-        }
-
-
-        # default date format
-        @format = set_format(:date)
-
-
-        # get a valid timezone
-        @zone = ActiveSupport::TimeZone.new(@settings[:time_zone])
-
-
-        # get datetime object from user params
-        @datetime = parse_initial_datetime(datetime, format).in_time_zone(@zone)
-
-    end
-
-    # set date format and return Date2 instance
-    def date
-        set_format(:date)
-        self
-    end
-
-    # set time format and return Date2 instance
-    def time
-        set_format(:time)
-        self
-    end
-
-    # set date_time format and return Date2 instance
-    def date_time
-        set_format(:date_time)
-        self
-    end
-
-    # set date_words format and return Date2 instance
-    def date_words
-        set_format(:date_words)
-        self
-    end
-
-    # set date_time_words format and return Date2 instance
-    def date_time_words
-        set_format(:date_time_words)
-        self
-    end
-
-    # return query string to get timestamps columns from database
-    def db_timestamps table=""
-
-        # avoid ambiguous columns
-        table = table.concat(".") if table != ""
-
-        # get right format for dates
-        format = self.db_format
-
-        "TO_CHAR(#{table}created_at at time zone 'utc' at time zone '#{@settings[:time_zone]}', '#{format}') as created_at_date, TO_CHAR(#{table}updated_at at time zone 'utc' at time zone '#{@settings[:time_zone]}', '#{format}') as updated_at_date"
-
-    end
-
-    # return query string to get a datetime column from database
-    def db_column column, table=""
-
-        # avoid ambiguous columns
-        table = table.concat(".") if table != ""
-
-        # get right format for dates
-        format = self.db_format
-
-        # compatibility for SQLite
-        if ActiveRecord::Base.connection.adapter_name == "SQLite"
-            return "strftime('#{format}', #{table}#{column}) as #{column}_string"
-        end
-
-        "TO_CHAR(#{table}#{column} at time zone 'utc' at time zone '#{@settings[:time_zone]}', '#{format}') as #{column}_string"
-
-    end
-
-    # convert a datetime object to string representation using defined format
-    def to_s
-        @datetime.strftime(@format)
-    end
-
-    def get
-        @datetime
-    end
-
-    private
-
-
-    # get datetime object or string datetime and return a datetime object
-    def parse_initial_datetime datetime, format
-
-        return datetime if datetime.is_a?(Time)
-
-        if datetime.is_a?(::String) and datetime.size == 25 and datetime[10] == "T"
-            return ::DateTime.iso8601(datetime)
-        end
-
-        return ::DateTime.strptime(datetime, format)
-    end
-
-
-    def set_format format
-        @format = @settings[:format][format || :date]
-    end
-
-
-    def db_format
-        format = @format
-
-        # SQLite format dates are the same of ruby format 
-        return format if ActiveRecord::Base.connection.adapter_name == "SQLite"
-
-        # Convert Ruby to postgresql date format
-        format = format.gsub("%Y", "YYYY")
-        format = format.gsub("%m", "MM")
-        format = format.gsub("%d", "DD")
-
-        # Convert Ruby to postgresql time format
-        format = format.gsub("%H", "HH24") # 24 hours format
-        format = format.gsub("%I", "HH12") # 12 hours format
-        format = format.gsub("%p", "AM") # Meridian indicator (AM/PM)
-        format = format.gsub("%M", "MI")
-
-        format
-    end
-
+class Date2 < LesliDate::Formatter
 end

data/app/lib/lesli/courier.rb

@@ -0,0 +1,54 @@
+module Lesli
+    class Courier
+
+        # Store the module_name (e.g., :lesli_support as LesliSupport)
+        def initialize(module_name, on_error=nil)
+            @module_name = module_name.to_s.camelize
+            @on_error=on_error
+        end
+
+        # Dynamically determine the class to call (e.g., :ticket_service as TicketService)
+        def from(service_name, *args)
+            @service_params = args
+            @service_name = service_name.to_s.camelize
+            self
+        end
+
+        # Store the method name to call on the service (e.g., :index_with_deadline)
+        def call(method_name, *args)
+            @method_params = args 
+            @method_name = method_name
+            self.execute
+        end
+
+        private 
+
+        # Execute the final call to the service, either with or without params
+        def execute
+
+            module_name = "#{@module_name}"
+
+            # Look up the module and class dynamically
+            return @on_error unless Object.const_defined?(module_name)
+
+            module_service_name = "#{@module_name}::#{@service_name}"
+
+            return @on_error unless Object.const_defined?(module_service_name)
+
+            # Create a reference of the module service object
+            module_service_class = module_service_name.constantize
+            
+            # Instantiate the service class with or without arguments
+            module_service_instance = module_service_class.new(*@service_params.to_a) 
+
+            # Check if the method is defined on the service instance
+            return @on_error unless module_service_instance.respond_to?(@method_name)
+
+            # Dynamically call the method on the service instance
+            module_service_instance.send(@method_name)
+
+        rescue 
+            return @on_error
+        end
+    end
+end

data/app/mailers/lesli/application_lesli_mailer.rb

@@ -34,61 +34,31 @@ module Lesli
     class ApplicationLesliMailer < ActionMailer::Base
 
         # Set a dynamic template according to the engine that is sending the email
-        # this is equivalent to: default template_path: -> { "engine_name/emails" }
-=begin
-        default(
-
-            from: -> {
-
-                instance = Rails.application.config.lesli.dig(:instance)
-
-                # add custom email name for emails sent from www.lesli.cloud
-                if instance[:code] == 'lesli_cloud'
-                    return email_address_with_name(
-                        Rails.configuration.lesli.dig(:env, :action_mailer, :default_options_from), 
-                        "Lesli"
-                    )
-                end
-
-                Rails.configuration.lesli.dig(:env, :action_mailer, :default_options_from)
-
-            },
-
-            template_path: -> {
-
-                instance = Rails.application.config.lesli.dig(:instance)
-
-                # get class that is executing the mailer
-                module_info = self.class.name.split("::")
-
-                # mailers from engines
-                if module_info.length > 1
-                    return "#{ instance[:code] }/emails/#{(module_info[0].underscore)}/#{ module_info[1].underscore }"
-                end
-
-                # mailers from core
-                return "#{ instance[:code] }/emails/#{ module_info[0].underscore }"
+        default(template_path: Lesli.config.mailer.dig(:templates))
 
-            }
-
-        )
-=end
         #after_action :log_mail_requests
 
-        #default(template_path: "lesli/emails/devise_mailer")
-
         def initialize
 
             super
 
-            # some @email data is defined on: LesliMails/src/partials/data.html
-            
-            @email = {}
+            @app = {}
             @custom = {}
-            @params = {
-                :host => default_url_options[:host] || ""
-            }
+            @params = {}
+        end
 
+        def build_url(path, params = {})
+            default_url = Rails.application.config.action_mailer.default_url_options
+            host = default_url[:host].to_s.sub(/\Ahttps?:\/\//, "")
+            scheme = default_url[:protocol]&.delete(":") || "http"
+
+            URI::Generic.build(
+                scheme: scheme,
+                host: host,
+                port: default_url[:port],
+                path: path,
+                query: params.to_query.presence
+            ).to_s
         end
 
         protected
@@ -97,6 +67,8 @@ module Lesli
 
             @params = @params.merge(params)
 
+            build_app_from_params(params)
+
             mail(
                 to: to, 
                 subject: subject,
@@ -109,21 +81,20 @@ module Lesli
 
         def build_app_from_params(params)
 
-            @app[:host] = default_url_options[:host]
-            # @app[:company] = {
-            #     id: 0,
-            #     name: "",
-            #     tag_line: "",
-            # }
-
-            # return if params[:user].blank? || params[:user].class.name != "User"
+            @app[:host] = build_url("/")
+            @app[:company] = {
+                id: 0,
+                name: "",
+                tag_line: "",
+            }
 
-            # @app[:company] = {
-            #     id: params[:user].account.id,
-            #     name: params[:user].account.company_name,
-            #     tag_line: params[:user].account.company_tag_line,
-            # }
+            return if params[:user].blank? || params[:user].class.name != "Lesli::User"
 
+            @app[:company] = {
+                id: params[:user].account.id,
+                name: params[:user].account.name,
+                #tag_line: params[:user].account.company_tag_line,
+            }
         end
 
         def build_customization_from_params(params)
@@ -174,6 +145,8 @@ module Lesli
                 }
             end
 
+            if defined? LesliMailer
+            end
             # TODO: Save template path and view used within the email
             Account::Log.log_email(
                 "#{self.class.to_s}/#{self.action_name}", 

data/app/mailers/lesli/devise_mailer.rb

@@ -1,23 +1,21 @@
 module Lesli
     class DeviseMailer < ApplicationLesliMailer
 
-        default(template_path: "lesli/emails/devise_mailer")
-
         # Sends an email with instructions to allow the user reset the password
         def reset_password_instructions(user, token, opts = {})
 
             # defaults for new accounts/users
-            email_template = "reset_password_instructions"
+            email_template = "devise/reset_password_instructions"
             email_subject = I18n.t("core.users/confirmations.mailer_email_verification")
 
             # email parameters
             params = {
-                url: "/password/edit?reset_password_token=#{token}",
-                user_name: user.full_name
+                url: build_url("/password/edit", { reset_password_token: token}),
+                full_name: user.full_name
             }
 
             # send email
-            pp email(
+            email(
                 params,
                 to: user.email, 
                 subject: email_subject,
@@ -29,7 +27,7 @@ module Lesli
         def confirmation_instructions(user, token, opts = {})
 
             # defaults for new accounts/users
-            email_template = "confirmation_instructions"
+            email_template = "devise/confirmation_instructions"
             email_subject = I18n.t("core.users/confirmations.mailer_email_verification")
 
             # # custom email and subject if user is changin his email address
@@ -44,7 +42,7 @@ module Lesli
 
             # email parameters
             params = {
-                url: "/confirmation?confirmation_token=#{token}"
+                url: build_url("/confirmation", { confirmation_token: token})
             }
 
             # send email
@@ -55,5 +53,15 @@ module Lesli
                 template_name: email_template
             )
         end
+
+        def welcome(user)
+            email_recipient = user.unconfirmed_email || user.email
+            email(
+                { :user => user },
+                to: email_recipient, 
+                subject: "test",
+                template_name: "devise/welcome"
+            )
+        end
     end
 end