lesli_admin 0.1.0

data/app/assets/stylesheets/lesli_admin/application.css

@@ -0,0 +1,15 @@
+/*
+ * This is a manifest file that'll be compiled into application.css, which will include all the files
+ * listed below.
+ *
+ * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
+ * or any plugin's vendor/assets/stylesheets directory can be referenced here using a relative path.
+ *
+ * You're free to add application-wide styles to this file and they'll appear at the bottom of the
+ * compiled file so the styles you add here take precedence over styles defined in any other CSS/SCSS
+ * files in this directory. Styles in this file should be added after the last require_* statement.
+ * It is generally better to create a new file per style scope.
+ *
+ *= require_tree .
+ *= require_self
+ */

data/app/controllers/lesli_admin/accounts_controller.rb

@@ -0,0 +1,125 @@
+=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 LesliAdmin
+    class AccountsController < ApplicationController
+        before_action :set_account, only: %i[show edit update destroy]
+
+        # GET /accounts/1
+        # GET /accounts/1.json
+        def show
+            respond_to do |format|
+                format.html {}
+                format.json do
+                    set_account
+                    respond_with_successful(@account)
+                end
+            end
+        end
+    
+        # GET /accounts/new
+        def new
+        end
+    
+        # GET /accounts/1/edit
+        def edit
+        end
+    
+        # POST /accounts
+        # POST /accounts.json
+        def create
+            current_user.account.company_name = account_params[:company_name]
+            current_user.account.status = 'active'
+            current_user.account.save
+            if current_user.account.errors.any?
+                return respond_with_error(current_user.errors.full_messages.to_sentence)
+            end
+            respond_with_successful
+        end
+    
+        # PATCH/PUT /accounts/1
+        # PATCH/PUT /accounts/1.json
+        def update
+            if @account.update(account_params)
+                respond_with_successful(@account)
+            else
+                respond_with_error(@account)
+            end
+        end
+    
+        # DELETE /accounts/1
+        # DELETE /accounts/1.json
+        def destroy
+            return respond_with_not_found unless @account
+    
+            @account.destroy
+            respond_to do |format|
+                format.html { redirect_to accounts_url, notice: 'Account was successfully destroyed.' }
+                format.json { head :no_content }
+            end
+        end
+
+        private
+
+        # Use callbacks to share common setup or constraints between actions.
+        def set_account
+            #@account = current_user.account
+            @account = Account.first
+            return respond_with_not_found unless @account
+        end
+
+        # Only allow a list of trusted parameters through.
+        def account_params
+            params.require(:account).permit(
+                :id,
+                :company_name,
+                :company_name_legal,
+                :company_tagline,
+                :country,
+                :city,
+                :postal_code,
+                :address,
+                :region,
+                :website,
+                :phone_number_1,
+                :public_email,
+                :github,
+                :twitter,
+                :youtube,
+                :linkedin,
+                :facebook,
+                :status,
+                :users_id
+            )
+        end
+    end
+end

data/app/controllers/lesli_admin/application_controller.rb

@@ -0,0 +1,4 @@
+module LesliAdmin
+    class ApplicationController < Lesli::ApplicationLesliController
+    end
+end

data/app/controllers/lesli_admin/dashboards_controller.rb

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

data/app/controllers/lesli_admin/users_controller.rb

@@ -0,0 +1,244 @@
+=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 LesliAdmin
+    class UsersController < ApplicationController
+        before_action :set_user, only: [
+            :show,
+            :update,
+            :destroy,
+            :requestpassword,
+            :passwordreset,
+            :revokeaccess,
+            :logout
+        ]
+
+        # GET /users/list
+        def list
+            respond_to do |format|
+                format.json { respond_with_successful(UserService.new("current_user").list(query, params)) }
+            end
+        end
+
+        # GET /users
+        def index
+            respond_to do |format|
+                format.html { }
+                format.json {
+                    return respond_with_pagination(UserService.new("current_user").index(query, params))
+                }
+            end
+        end
+    
+        def show
+            respond_to do |format|
+                format.html {}
+                format.json {
+                    return respond_with_not_found unless @user.found?
+                    return respond_with_successful(@user.show)
+                }
+            end
+        end
+
+        def new; end
+    
+        def create
+    
+            user = UserService.new(current_user).create(user_params)
+            if user.successful?
+                respond_with_successful(user.result)
+            else 
+                respond_with_error("Error creating user", user.errors)
+            end
+    
+        end
+    
+        def update
+    
+            # validate that user exists
+            return respond_with_not_found unless @user.found?
+    
+            @user.update(user_params)
+    
+            if @user.successful?
+                respond_with_successful(@user.result)
+            else 
+                respond_with_error(@user.errors)
+            end
+    
+        end
+    
+        def destroy
+            return respond_with_not_found unless @user
+    
+            # get the user found in the UserServices
+            user = @user.result
+    
+            if user.delete
+                current_user.logs.create({ title: "deleted_user", description: "by_user_id: #{ current_user.email }" })
+                respond_with_successful()
+              else
+                respond_with_error(user.errors.full_messages.to_sentence)
+            end
+        end
+    
+        # Force the user to update his password
+        def requestpassword
+            if @user.request_password
+                respond_with_successful
+            else 
+                respond_with_error
+            end
+        end
+    
+        # Reset password (generate random)
+        def passwordreset
+    
+            pass = @user.password_reset
+    
+            if pass
+                respond_with_successful(pass)
+            else 
+                respond_with_error
+            end
+        end
+    
+        # this method is going to close all the open user sessions
+        def logout
+            if @user.logout
+                respond_with_successful
+            else 
+                respond_with_error
+            end
+        end
+    
+        # Remove all user access 
+        def revokeaccess
+            if @user.revoke_access
+                respond_with_successful
+            else 
+                respond_with_error
+            end
+        end
+    
+        def become
+    
+            # always should be disabled
+            if Rails.configuration.lesli.dig(:security, :enable_becoming) != true
+                return respond_with_unauthorized
+            end
+    
+            # Allow only sysadmin to become as user
+            return respond_with_unauthorized if current_user.email != Rails.application.config.lesli.dig(:account, :user, :email) # sysadmin user
+    
+            # Search for desire user
+            becoming_user = User.find(params[:id])
+    
+            # Return an error if user does not exist
+            return respond_with_error I18n.t("core.shared.messages_warning_user_not_found") if becoming_user.blank?
+    
+            # Extrictly save a log when becoming
+            current_user.activities.create!({
+                users_id: becoming_user.id,
+                owner_id: current_user.id,
+                description: "#{current_user.full_name} -> #{becoming_user.full_name}",
+                category: "action_become"
+            })
+    
+            # Sign in as the becoming user
+            sign_in(:user, becoming_user)
+    
+            # Create a new session for the becoming user
+            becoming_session = becoming_user.sessions.create({
+                :user_agent => get_user_agent,
+                :user_remote => request.remote_ip,
+                :session_source => "become_session",
+                :last_used_at => LC::Date.now,
+                :expiration_at => 60.minutes.from_now
+            })
+    
+            # assign the session of the becomer user to the becoming user
+            session[:user_session_id] = becoming_session[:id]
+    
+            # Response successful
+            respond_with_successful([current_user, becoming_user])
+    
+        end
+    
+        def options
+            respond_with_successful({
+                #regions: current_user.account.locations.where(level: "region"),
+                salutations: User::Detail.salutations.map {|k, v| {value: k, text: v}},
+                locales: Rails.application.config.lesli.dig(:configuration, :locales_available),
+                mfa_methods: Rails.application.config.lesli.dig(:configuration, :mfa_methods)
+            })
+        end
+    
+        private
+    
+        # @return [void]
+        # @description Sets the requested user based on the current_users's account
+        # @example
+        #     # Executing this method from a controller action:
+        #     set_user
+        #     puts @user
+        #     # This will either display nil or an instance of Account::User
+        def set_user
+            @user = UserService.new(current_user).find(params[:id])
+        end
+    
+        def user_params
+            params.require(:user).permit(
+                :active,
+                :email,
+                :alias,
+                :roles_id,
+                :first_name,
+                :last_name,
+                :telephone,
+                detail_attributes: [
+                    :title,
+                    :salutation,
+                    :address,
+                    :work_city,
+                    :work_region,
+                    :work_address
+                ]
+            )
+        end
+
+        # Only allow a list of trusted parameters through.
+        def user_params
+            params.fetch(:user, {})
+        end
+    end
+end

data/app/helpers/lesli_admin/application_helper.rb

@@ -0,0 +1,4 @@
+module LesliAdmin
+  module ApplicationHelper
+  end
+end

data/app/helpers/lesli_admin/dashboards_helper.rb

@@ -0,0 +1,4 @@
+module LesliAdmin
+  module DashboardsHelper
+  end
+end

data/app/jobs/lesli_admin/application_job.rb

@@ -0,0 +1,4 @@
+module LesliAdmin
+  class ApplicationJob < ActiveJob::Base
+  end
+end

data/app/mailers/lesli_admin/application_mailer.rb

@@ -0,0 +1,6 @@
+module LesliAdmin
+  class ApplicationMailer < ActionMailer::Base
+    default from: "from@example.com"
+    layout "mailer"
+  end
+end

data/app/models/lesli_admin/account.rb

@@ -0,0 +1,66 @@
+=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.dev
+@license  GPLv3 http://www.gnu.org/licenses/gpl-3.0.en.html
+
+// · ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~
+// · 
+=end
+
+module LesliAdmin
+    class Account < Lesli::Account
+
+        # accounts always belongs to a user
+        belongs_to :user, optional: true
+
+        # account resources
+        has_many :users
+
+        has_one :bell, class_name: "LesliBell::Account"
+
+
+
+        # account statuses
+        enum status: [
+            :registered,
+            :onboarding,
+            :active,
+            :suspended
+        ]
+
+
+        # company region (GDPR)
+        enum region: {
+            latin_america: "latin_america",
+            united_states: "united_states",
+            european_union: "european_union"
+        }
+
+
+        # required a name for the lesli account
+        validates :company_name, :presence => true
+    end
+end

data/app/models/lesli_admin/application_record.rb

@@ -0,0 +1,5 @@
+module LesliAdmin
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+  end
+end

data/app/models/lesli_admin/dashboard.rb

@@ -0,0 +1,4 @@
+module LesliAdmin
+  class Dashboard < ApplicationRecord
+  end
+end

data/app/models/lesli_admin/user.rb

@@ -0,0 +1,4 @@
+module LesliAdmin
+    class User < ::Lesli::User
+    end
+end