lesli_vault 0.1.0

data/app/vue/lesli_vault/stores/role.js

@@ -0,0 +1,243 @@
+/*
+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 Development Platform.
+
+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
+
+// · ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~
+// · 
+*/
+
+
+// · 
+import { defineStore } from "pinia"
+
+
+// · 
+export const useRole = defineStore("administration.role", {
+    state: () => {
+        return {
+            options: {},
+            records: [],
+            descriptors: [],
+            descriptorsCustom: [],
+            descriptorSearchString: '',
+            role: {
+                name: "",
+                descriptors: []
+            },
+            pagination: {
+                page: 1
+            },
+            index: { 
+                pagination: {},
+                records: []
+            },
+            loading: false,             
+            order: {
+                column: "id",
+                direction: "desc"
+            },
+            search_string: "",
+            role_activities: {}
+        }
+    },
+    actions: {
+
+        fetch() {
+            this.loading = true
+            this.http.get(this.url.admin("roles")
+                .paginate(this.pagination.page)
+                .order(this.order.column, this.order.direction)
+                .search(this.search_string))
+            .then(result => {
+                this.index = result
+                this.records = result.records.map(integrations => {
+                    integrations.created_at = this.date.dateTime(integrations.created_at)
+                    return integrations
+                })
+                this.loading = false
+            })
+        },
+
+        paginateIndex(page) {
+            this.pagination.page = page
+            this.fetch()
+        },
+
+        fetchRole(id) {
+            this.loading = true
+            this.http.get(this.url.admin("roles/:id", id)).then(result => {
+                this.role = result
+                this.getDescriptors()
+                this.loading = false
+            })
+        },
+
+        postRole() {
+            return this.http.post(this.url.admin("roles"), this.role)
+        },
+
+        putRole() {
+            this.http.put(this.url.admin("roles/:id", this.role.id), this.role).then(result => {
+                this.msg.success(I18n.t('core.roles.messages_success_role_successfully_updated'))
+            })
+        },
+
+        searchDescriptors(string) {
+            this.descriptorSearchString = string
+            this.getDescriptors()
+        },
+
+        getDescriptors() {
+
+            let url = this.url.admin("roles/:id/descriptors", this.role.id)
+
+            if (this.descriptorSearchString != '') {
+                url = url.search(this.descriptorSearchString)
+            }
+
+            this.http.get(url).then(descriptors => {
+
+                // reset the list of descriptors
+                this.descriptors = []
+                this.descriptorsCustom = []
+
+                // temporary container for the descriptor matrix
+                let descriptorgrid = {}
+
+                // convert list of descriptors from: controller/action to controller/actions (like a matrix)
+                descriptors.forEach(descriptor => {
+
+                    if (["list", "index", "show", "create", "update", "destroy"].includes(descriptor.action)) {
+
+                        if (!descriptorgrid[descriptor.reference]) {
+                            descriptorgrid[descriptor.reference] = {
+                                id: descriptor.id,
+                                name: descriptor.name,
+                                reference: descriptor.reference,
+                                controller: descriptor.controller,
+                                index: null, 
+                                show: null, 
+                                create: null, 
+                                update: null, 
+                                destroy: null
+                            }
+                        }
+
+                        // add the id of the descriptor that the action belongs to
+                        descriptorgrid[descriptor.reference][descriptor.action] = {
+                            id: descriptor.id,
+                            active: descriptor.active
+                        }
+
+                        return;
+
+                    }
+
+                    this.descriptorsCustom.push(descriptor)
+
+                })
+
+                // return the arrys only
+                this.descriptors = Object.values(descriptorgrid)
+
+            })
+        },
+
+        updateDescriptor(descriptor) {
+
+            // enable descriptor
+            if (descriptor.active) {
+                return this.postDescriptor(descriptor)
+            }
+
+            // disable descriptor
+            this.deleteDescriptor(descriptor)
+            
+        },
+
+        postDescriptor(descriptor) {
+            this.http.post(this.url.admin("roles/:id/descriptors", this.role.id), {
+                role_descriptor: {
+                    id: descriptor.id
+                }
+            })
+        },
+
+        deleteDescriptor(descriptor) {
+            this.http.delete(this.url.admin("roles/:id/descriptors/:descriptor_id", {
+                id: this.role.id,
+                descriptor_id: descriptor.id
+            }))
+        },
+
+        getOptions() {
+            this.http.get(this.url.admin("roles/options")).then(result => {
+                
+                this.options = result
+            })
+        }, 
+        /**
+         * @description This action is used to sort the results
+         */
+        sortIndex(column, direction) {
+            this.order.column = column
+            this.order.direction = direction
+            this.fetch()
+        },
+        /**
+         * @description This action is used to search
+         * @param {string} search_string 
+         */
+        search(search_string) {
+            this.search_string = search_string
+            this.fetch()
+        },
+        /**
+         * @description This action is used to delete a role
+         * @param {Integer} role_id id of the role to be deleted 
+         */
+        deleteRole(role_id){            
+            this.http.delete(this.url.admin('roles/:id', {id: role_id})).then(result => {
+                this.msg.success(I18n.t("core.users.messages_success_operation"))
+                this.fetch()
+            }).catch(error => {
+                this.msg.danger(I18n.t("core.shared.messages_danger_internal_error"))
+            })
+        },
+        /**
+         * @description This action is used to fetch activity logs from a role
+         */
+        fetchLogs(){
+            this.loading = true
+            this.http.get(this.url.admin('roles/:id/activities', {id: this.role.id})).then(result => {
+                this.role_activities = result.activities             
+                this.loading = false
+            }).catch(error => {
+                this.msg.danger(I18n.t("core.shared.messages_danger_internal_error"))
+            })     
+        }
+    }
+})

data/app/vue/lesli_vault/stores/roles.js

@@ -0,0 +1,89 @@
+/*
+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 Development Platform.
+
+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
+
+// · ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~
+// · 
+*/
+
+
+// · 
+import { defineStore } from "pinia"
+
+
+// · 
+export const useRoles = defineStore("administration.roles", {
+    state: () => {
+        return {
+            list: [],
+            index: {
+                pagination: {},
+                records: []
+            }
+        }
+    },
+    actions: {
+
+        fetchList() {
+            if (!this.list.length > 0) {
+                this.getList()
+            }
+        },
+
+        // Get the list of role user is able to work with
+        // according to object level permissions
+        getList() {
+            this.http.get(this.url.admin("roles/list")).then(result => {
+                this.list = result
+
+                // parse the list of roles to be used in select control
+                /*
+                this.listOptions = []
+                this.listOptions = result.map(role => {
+                    return {
+                        label: role.name,
+                        value: role.id
+                    }
+                })
+                */
+            })
+        },
+
+        fetchRoles() {
+            if (!this.list.length > 0) {
+                this.getRoles()
+            }
+        },
+
+        // Get the list of role user is able to work with
+        // according to object level permissions
+        getRoles() {
+            this.http.get(this.url.admin("roles")).then(result => {
+                this.index = result
+            })
+        },
+    }
+})

data/app/vue/lesli_vault/stores/systemController.js

@@ -0,0 +1,67 @@
+/*
+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 Development Platform.
+
+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
+
+// · ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~
+// · 
+*/
+
+
+// · 
+import { defineStore } from "pinia"
+
+
+// · 
+export const useSystemController = defineStore("administration.systemController", {
+    state: () => {
+        return {
+            options: { categories: []},
+            controllerActions: {},
+        }
+    },
+    actions: {
+
+        fetchControllers() {
+            this.http.get(this.url.admin("system_controllers")).then(result => {
+                result.forEach(controllerAction => {
+                    if (!this.controllerActions[controllerAction.action]) {
+                        this.controllerActions[controllerAction.action] = []
+                    }
+                    controllerAction['active'] = false
+                    this.controllerActions[controllerAction.action].push(controllerAction)
+                })
+            }).catch(error => {
+                console.log(error)
+            })
+        },
+
+        fetchOptions() {
+            this.http.get(this.url.admin("system_controllers/options")).then(result => {
+                this.options = result
+            })
+        }
+    }
+})

data/config/routes.rb

@@ -0,0 +1,52 @@
+=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 platform.
+
+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
+
+LesliVault::Engine.routes.draw do
+    root to: "dashboards#show"
+
+    resources :roles do
+        scope module: :role do
+            resources :privileges
+            resources :descriptors
+            resources :activities
+        end
+    end
+
+    resources :descriptors do
+        scope module: :descriptor do
+            resources :privileges 
+            resources :activities
+        end
+    end
+
+end

data/lib/lesli_vault/engine.rb

@@ -0,0 +1,18 @@
+module LesliVault
+    class Engine < ::Rails::Engine
+        isolate_namespace LesliVault
+
+        initializer :lesli_vault do |app|
+
+            # register assets manifest
+            config.assets.precompile += %w[lesli_vault_manifest.js]
+
+            # register engine migrations path
+            unless app.root.to_s.match root.to_s
+                config.paths["db/migrate"].expanded.each do |expanded_path|
+                    app.config.paths["db/migrate"] << expanded_path
+                end
+            end
+        end
+    end
+end

data/lib/lesli_vault/version.rb

@@ -0,0 +1,3 @@
+module LesliVault
+  VERSION = "0.1.0"
+end

data/lib/lesli_vault.rb

@@ -0,0 +1,6 @@
+require "lesli_vault/version"
+require "lesli_vault/engine"
+
+module LesliVault
+  # Your code goes here...
+end

data/lib/tasks/lesli_vault_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :lesli_vault do
+#   # Task goes here
+# end

data/lib/tasks/system/controllers.rake

@@ -0,0 +1,112 @@
+namespace :lesli_vault do
+    namespace :system do
+
+        desc "Testing"
+        task test: :environment do
+            puts "Testing environment"
+        end
+
+        namespace :controllers do
+    
+            desc "Scan new routes added and create role privileges"
+            task build: :environment do
+    
+                L2.msg("Registering engines, controllers and actions")
+    
+                # get all the engines, controllers and actions
+                engines = scan_for_engine_controllers
+    
+                # Register descriptors and privileges for all the accounts
+                engines.each do |engine, controllers|
+    
+                    controllers.each do |controller_route, controller_actions|
+    
+                        # Build a strig with the standard name of a Rails controller from the standard routes
+                        # Examples: 
+                        #   users converts to Users 
+                        #   cloud_bell/notifications converts to CloudBell::Notifications
+                        # sometimes we need a second split to deal with third level deep of controllers
+                        # Example: "Account::Currency::ExchangeRatesController" from "account/currency/exchange_rates"
+                        reference = controller_route
+                        .split('/')                     # split the controller path by namespace
+                        .collect(&:capitalize)          # uppercase the first letter to match the class name convention of Rails
+                        .join("::")                     # join by ruby class separator for namespaces
+                        .split('_')                     # work with compound words like "exchange_rates"
+                        .collect { |x| x[0] = x[0].upcase; x } # convert ['exchange', 'rates'] to ['Exchange', 'Rates']
+                        .join('')
+    
+                        name = reference.sub('::',' ')
+    
+                        controller = SystemController.create_with({
+                            name: name,
+                            :engine => engine,
+                            :reference => reference
+                        }).find_or_create_by!(route: controller_route)
+                        
+                        controller_actions.each do |action_name|
+                            controller.actions.find_or_create_by!(name: action_name)
+                        end
+                    end
+                end
+            end
+    
+            def scan_for_engine_controllers
+    
+                # Global container
+                controller_list = {
+                    "core" => {}
+                }
+    
+                # Get the name of the instance (builder engine)
+                instance = Rails.configuration.lesli.dig(:instance, :name)
+                
+                # Get the list of controllers and actions of the core
+                Rails.application.routes.routes.each do |route| 
+                    route = route.defaults 
+                    
+                    # filter the non-used core routes
+                    next if route[:controller].blank?
+                    next if route[:controller].include? "rails"
+                    next if route[:controller].include? "action_mailbox"
+                    next if route[:controller].include? "active_storage"
+                    
+                    # create a container for the actions related to a controller
+                    controller_list["core"][route[:controller]] = [] unless controller_list["core"][route[:controller]]
+    
+                    # assign and group all the actions related to the controller
+                    controller_list["core"][route[:controller]].push(route[:action])
+    
+                end
+    
+                # Get the list of controllers and actions from engines
+                Rails.configuration.lesli.dig(:engines).each do |engine|
+    
+                    # load and retrieve the list of controllers and actions from an engine
+                    routes = "#{engine[:name]}::Engine".constantize.routes.routes.each do |route| 
+                        route = route.defaults 
+    
+                        # validate if route has information, some special routes like redirects
+                        # can generate an empty entry in the route hash
+                        next if route.empty?
+    
+                        # get the engine code
+                        engine_code = engine[:name].underscore
+                        
+                        # create a container for the controllers related to the engine
+                        controller_list[engine_code] = {} if controller_list[engine_code].blank?
+    
+                        # assign and group all the actions related to the controller
+                        controller_list[engine_code][route[:controller]] = [] if controller_list[engine_code][route[:controller]].blank?
+                        
+                        # assign and group all the actions related to the controller
+                        controller_list[engine_code][route[:controller]].push(route[:action])
+    
+                    end
+                end
+    
+                return controller_list
+            end
+        end
+    end
+    
+end

data/lib/vue/application.js

@@ -0,0 +1,7 @@
+
+// · 
+import application from "Lesli/application"
+
+
+// · 
+application("LesliVault", [])

data/readme.md

@@ -0,0 +1,19 @@
+<p align="center">
+	<img width="100" alt="LesliBabel logo" src="app/assets/images/lesli_vault/vault-logo.svg" />
+</p>
+
+<h3 align="center">LesliVault</h3>
+
+<hr/>
+
+Version 1
+
+### License  
+------
+Software developed in [Guatemala](http://visitguatemala.com/) by [LesliTech](https://www.lesli.tech) distributed under the *General Public License v 3.0* you can read the full license [here](http://www.gnu.org/licenses/gpl-3.0.html)
+
+<br>
+
+<p align="center">
+    <img alt="Lesli logo" width="100" src="./app/assets/images/lesli/brand/app-icon.svg" />
+</p>