Initial commit

pkg/auth/user.go

@@ -0,0 +1,110 @@
+package auth
+
+import (
+	"errors"
+	"fmt"
+
+	"github.com/sujit-baniya/fiber-boilerplate/config"
+
+	"github.com/gofiber/fiber/v2"
+	"github.com/gofiber/session/v2"
+	"github.com/sujit-baniya/fiber-boilerplate/app"
+	"github.com/sujit-baniya/fiber-boilerplate/pkg/models"
+)
+
+func User(c *fiber.Ctx) (*models.Users, error) {
+	store := app.Http.Session.Get(c)
+	userID := store.Get("user_id")
+	if userID == nil {
+		return nil, errors.New("User Not Logged In")
+	}
+
+	user, err := models.FindUserByID(userID)
+	if err != nil {
+		return nil, err
+	}
+	return user, nil
+}
+
+func IsAdmin(c *fiber.Ctx) bool {
+	user, err := User(c)
+	if err != nil {
+		return false
+	}
+	return user.IsAdmin
+}
+
+func UserID(c *fiber.Ctx) uint {
+	store := app.Http.Session.Get(c)
+	return store.Get("user_id").(uint)
+}
+
+func IsLoggedIn(c *fiber.Ctx) bool {
+	store := app.Http.Session.Get(c)
+	userID := store.Get("user_id")
+	if userID == nil {
+		DeleteSession(store)
+		c.ClearCookie()
+		return false
+	}
+	token := c.Cookies("Verify-Rest-Token")
+	if token == "" {
+		tokenHash := store.Get("user_token")
+		c.Cookie(&fiber.Cookie{
+			Name:     "Verify-Rest-Token",
+			Value:    fmt.Sprintf("%s", tokenHash),
+			Secure:   false,
+			HTTPOnly: true,
+		})
+	}
+
+	return true
+}
+
+func Login(c *fiber.Ctx, userID uint, secret string) (*config.Token, error) {
+	// Obtener o crear una nueva sesión
+	store := app.Http.Session.Get(c) // get/create new session
+
+	// Regenerar la sesión para evitar compartirla
+	if err := store.Regenerate(); err != nil {
+		return nil, fmt.Errorf("failed to regenerate session: %v", err)
+	}
+
+	// Guardar el user_id en la sesión
+	store.Set("user_id", userID)
+	c.Locals("user_id", userID) // Establecer el user_id en el contexto
+
+	// Crear el token JWT
+	token, err := app.Http.Token.CreateToken(c, userID, secret)
+	if err != nil {
+		return nil, err
+	}
+
+	// Guardar el token en la sesión
+	store.Set("user_token", token.Hash)
+	store.Set("token_expiry", token.Expire)
+	store.Save() // Guardar la sesión de manera persistente
+
+	return token, nil
+}
+
+func Logout(c *fiber.Ctx) error {
+	store := app.Http.Session.Get(c)
+	DeleteSession(store)
+	c.ClearCookie()
+	return nil
+}
+
+func AuthCookie(c *fiber.Ctx) error {
+	IsLoggedIn(c)
+	return c.Next()
+}
+
+func DeleteSession(store *session.Store) {
+	store.Delete("user_id")
+	store.Delete("user_token")
+	err := store.Save()
+	if err != nil {
+		panic(err)
+	}
+}

pkg/models/casbin_rule.go

@@ -0,0 +1,39 @@
+package models
+
+import (
+	"gorm.io/gorm"
+	"time"
+)
+
+type RoleAndPermission struct {
+	ID        uint `gorm:"primaryKey;autoIncrement"`
+	CreatedAt time.Time
+	UpdatedAt time.Time
+	DeletedAt gorm.DeletedAt `gorm:"index"`
+	Ptype     string         `gorm:"size:100;uniqueIndex:unique_index"`
+	V0        string         `gorm:"size:100;uniqueIndex:unique_index"`
+	V1        string         `gorm:"size:100;uniqueIndex:unique_index"`
+	V2        string         `gorm:"size:100;uniqueIndex:unique_index"`
+	V3        string         `gorm:"size:100;uniqueIndex:unique_index"`
+	V4        string         `gorm:"size:100;uniqueIndex:unique_index"`
+	V5        string         `gorm:"size:100;uniqueIndex:unique_index"`
+	Category  string         `gorm:"category" json:"category"`
+}
+
+type RoleRequest struct {
+	UserID  uint   `json:"user_id"`
+	Role    string `json:"role"`
+	OldRole string `json:"old_role"`
+}
+
+type PermissionRequest struct {
+	Role   string `json:"role"`
+	Module string `json:"module"`
+	Action string `json:"action"`
+	Route  string `json:"route"`
+	Method string `json:"method"`
+}
+
+func (RoleAndPermission) TableName() string {
+	return "casbin_rule"
+}

pkg/models/file.go

@@ -0,0 +1,37 @@
+package models
+
+import (
+	"time"
+
+	"github.com/sujit-baniya/fiber-boilerplate/app"
+	"gorm.io/gorm"
+)
+
+type File struct {
+	*gorm.Model
+	ModifiedAt time.Time
+	FileName   string `json:"file_name" gorm:"file_name"` //nolint:gofmt
+	Title      string `json:"title" gorm:"title"`         //nolint:gofmt
+	MimeType   string `json:"mime_type" gorm:"mime_type"` //nolint:gofmt
+	Size       string `json:"size" gorm:"size"`           //nolint:gofmt
+	Extension  string `json:"extension" gorm:"extension"` //nolint:gofmt
+	RowCount   int64  `json:"row_count" gorm:"row_count"` //nolint:gofmt
+}
+
+type UserFile struct {
+	FileID   uint `json:"file_id" gorm:"file_id"` //nolint:gofmt
+	UserID   uint `json:"user_id" gorm:"user_id"` //nolint:gofmt
+	IsActive bool `json:"is_active" gorm:"is_active"`
+}
+
+func (UserFile) TableName() string {
+	return "user_files"
+}
+
+func GetFileByName(name string) (*File, error) {
+	var file File
+	if err := app.Http.Database.DB.Where(&File{FileName: name}).First(&file).Error; err != nil {
+		return nil, err
+	}
+	return &file, nil //nolint:wsl
+}

pkg/models/inicio.go

@@ -0,0 +1,82 @@
+package models
+
+import (
+	"time"
+
+	"github.com/sujit-baniya/fiber-boilerplate/app"
+	"gorm.io/gorm"
+)
+
+type Inicio struct {
+	gorm.Model            // Embedding gorm.Model to inherit fields like ID, CreatedAt, UpdatedAt, DeletedAt
+	ID          uint      `gorm:"primarykey"`
+	ModifiedAt  time.Time `json:"modified_at" gorm:"column:modified_at"`
+	Description string    `json:"description" gorm:"column:description"`
+	Enlace      string    `json:"enlace" gorm:"column:enlace"`
+	Ruta        string    `json:"ruta" gorm:"column:ruta"`
+}
+
+// TableName overrides the table name used by Inicio to Inicio
+func (Inicio) TableName() string {
+	return "inicio"
+}
+
+// AllInicios recupera todos los registros con búsqueda
+func AllInicios(limit, offset int, search string) ([]Inicio, int64, error) {
+	var items []Inicio
+	var total int64
+	db := app.Http.Database.DB.Model(&Inicio{})
+
+	// Filtrar por término de búsqueda si se proporciona
+	if search != "" {
+		db = db.Where("title LIKE ? OR description LIKE ?", "%"+search+"%", "%"+search+"%")
+	}
+
+	// Obtener el total de registros
+	if err := db.Count(&total).Error; err != nil {
+		return nil, 0, err
+	}
+
+	// Obtener los registros con paginación
+	if err := db.Order("created_at DESC").Limit(limit).Offset(offset).Find(&items).Error; err != nil {
+		return nil, 0, err
+	}
+
+	return items, total, nil
+}
+
+// AllIniciosSelect recupera todos los registros sin paginación
+func AllIniciosSelect() ([]Inicio, error) {
+	var items []Inicio
+
+	// Realizar la consulta para obtener todos los registros
+	if err := app.Http.Database.DB.Model(&Inicio{}).Find(&items).Error; err != nil {
+		return nil, err
+	}
+
+	return items, nil
+}
+
+// CreateInicio creates a new record
+func CreateInicio(item Inicio) error {
+	if err := app.Http.Database.DB.Create(&item).Error; err != nil {
+		return err
+	}
+	return nil
+}
+
+// UpdateInicio updates an existing record
+func UpdateInicio(item Inicio) error {
+	if err := app.Http.Database.DB.Save(&item).Error; err != nil {
+		return err
+	}
+	return nil
+}
+
+// Delete%!s(MISSING) deletes a record by its ID
+func DeleteInicio(id uint) error {
+	if err := app.Http.Database.DB.Delete(&Inicio{}, id).Error; err != nil {
+		return err
+	}
+	return nil
+}

pkg/models/login.go

@@ -0,0 +1,47 @@
+package models
+
+import (
+	"errors"
+
+	"github.com/gookit/validate"
+	"github.com/sujit-baniya/fiber-boilerplate/app"
+)
+
+type Login struct {
+	NombreUsuario string `json:"nombre_usuario" gorm:"nombre_usuario" form:"nombre_usuario" validate:"required"`
+	Password      string `json:"password" gorm:"password" form:"password" validate:"required"`
+}
+
+// Messages you can custom validator error messages.
+func (l Login) Messages() map[string]string {
+	return validate.MS{
+		"required":       "oh! the {field} is required",
+		"nombre_usuario": "Is required",
+	}
+}
+
+func (Login) TableName() string {
+	return "users"
+}
+
+func (l *Login) CheckLogin() (*Users, error) {
+
+	user, err := GetUserByUsuario(l.NombreUsuario)
+	if err != nil {
+		return nil, errors.New("Usuario inactivo o correo no verificado, Contacte con soporte")
+	}
+
+	if user.Password == "" {
+		return nil, errors.New("no_password")
+	}
+
+	match, err := app.Http.Hash.Match(l.Password, user.Password)
+	if err != nil {
+		return nil, errors.New("Contraseña incorrecta")
+	}
+	if !match {
+		return nil, errors.New("Usuario o contraseña incorrectos")
+	}
+
+	return user, nil
+}

pkg/models/modules.go

@@ -0,0 +1,90 @@
+package models
+
+import (
+	"time"
+
+	"github.com/sujit-baniya/fiber-boilerplate/app"
+	"gorm.io/gorm"
+)
+
+type Modules struct {
+	gorm.Model               // Embedding gorm.Model to inherit fields like ID, CreatedAt, UpdatedAt, DeletedAt
+	ID          uint         `gorm:"primarykey"`
+	ModifiedAt  time.Time    `json:"modified_at" gorm:"column:modified_at"` // Specify the DB column name
+	Description string       `json:"description" gorm:"column:description"` // Specify the DB column name
+	Title       string       `json:"title" gorm:"column:title"`             // Specify the DB column name
+	Submodules  []Submodules `json:"submodules" gorm:"foreignKey:ModuleId"`
+}
+
+// TableName overrides the table name used by Modules to `modules`
+func (Modules) TableName() string {
+	return "modules"
+}
+
+// AllModules recupera todos los módulos con búsqueda
+func AllModules(limit, offset int, search string) ([]Modules, int64, error) {
+	var modules []Modules
+	var total int64
+	db := app.Http.Database.DB.Model(&Modules{})
+
+	// Filtrar por término de búsqueda si se proporciona
+	if search != "" {
+		db = db.Where("title LIKE ? OR description LIKE ?", "%"+search+"%", "%"+search+"%")
+	}
+
+	// Obtener el total de módulos
+	if err := db.Count(&total).Error; err != nil {
+		return nil, 0, err
+	}
+
+	// Obtener los módulos con paginación
+	if err := db.Order("created_at DESC").Limit(limit).Offset(offset).Find(&modules).Error; err != nil {
+		return nil, 0, err
+	}
+
+	return modules, total, nil
+}
+
+// AllRolesSelect recupera todos los roles sin paginación
+func AllModulesSelect() ([]Modules, error) {
+	var modules []Modules
+
+	// Realizar la consulta para obtener todos los roles
+	if err := app.Http.Database.DB.Model(&Modules{}).Preload("Submodules").Find(&modules).Error; err != nil {
+		return nil, err
+	}
+
+	return modules, nil
+}
+
+// CreateModule creates a new module
+func CreateModule(module Modules) error {
+	if err := app.Http.Database.DB.Create(&module).Error; err != nil {
+		return err
+	}
+	return nil
+}
+
+// UpdateModule updates an existing module
+func UpdateModule(module Modules) error {
+	if err := app.Http.Database.DB.Save(&module).Error; err != nil {
+		return err
+	}
+	return nil
+}
+
+// DeleteModule deletes a module by its ID
+func DeleteModule(id uint) error {
+	if err := app.Http.Database.DB.Delete(&Modules{}, id).Error; err != nil {
+		return err
+	}
+	return nil
+}
+
+func AllModulesWithSubmodules() ([]Modules, error) {
+	var modules []Modules
+	if err := app.Http.Database.DB.Model(&Modules{}).Preload("Submodules").Find(&modules).Error; err != nil {
+		return nil, err
+	}
+	return modules, nil
+}

pkg/models/register.go

@@ -0,0 +1,51 @@
+package models
+
+import (
+	"errors"
+
+	"github.com/sujit-baniya/fiber-boilerplate/app"
+	"gorm.io/gorm"
+)
+
+type RegisterForm struct {
+	gorm.Model
+	DeletedAt     gorm.DeletedAt `gorm:"index"`
+	Name          string         `json:"name" gorm:"name"`
+	Email         string         `json:"email" gorm:"email"`
+	Password      string         `json:"password,omitempty" gorm:"password"`
+	EmailVerified bool           `json:"email_verified" gorm:"email_verified"`
+	IsAdmin       bool           `json:"is_admin" gorm:"is_admin"`
+	RoleID        uint           `json:"role_id" gorm:"role_id"`
+	Role          Roles          `gorm:"foreignKey:RoleID"` // Establecer relación con Roles
+
+	NombreUsuario    string `json:"nombre_usuario" gorm:"nombre_usuario"`
+	Documento        string `json:"documento" gorm:"documento"`
+	Estado           *bool  `json:"estado" gorm:"estado"`
+	TipoUsuario      string `json:"tipo" gorm:"tipo_usuario"`
+	CogidoUsuarioGas string `json:"cogido_usuario_gas" gorm:"cogido_usuario_gas"`
+	NumeroMedidor    string `json:"numero_medidor" gorm:"numero_medidor"`
+	TelefonoFijo     string `json:"telefono_fijo" gorm:"telefono_fijo"`
+	Celular          string `json:"celular" gorm:"celular"`
+	AceptoInfo       bool   `json:"acepto_info" gorm:"acepto_info"`
+}
+
+func (RegisterForm) TableName() string {
+	return "users"
+}
+
+func (l *RegisterForm) Signup() (*RegisterForm, error) {
+
+	user, _ := GetUserByUsuario(l.NombreUsuario)
+	if user != nil {
+		return nil, errors.New("User Already Exists")
+	}
+	l.Password, _ = app.Http.Hash.Create(l.Password)
+	app.Http.Database.DB.Create(l)
+	return l, nil
+}
+
+func (l *RegisterForm) ResetPassword() (*RegisterForm, error) {
+	l.Password, _ = app.Http.Hash.Create(l.Password)
+	app.Http.Database.DB.Updates(&l)
+	return l, nil
+}

pkg/models/roles.go

@@ -0,0 +1,90 @@
+package models
+
+import (
+	"time"
+
+	"github.com/sujit-baniya/fiber-boilerplate/app"
+	"gorm.io/gorm"
+)
+
+type Roles struct {
+	gorm.Model
+	ID          uint         `gorm:"primarykey"`
+	CreatedAt   time.Time    `json:"created_at" gorm:"column:created_at"`
+	Description string       `json:"description" gorm:"column:description"`
+	Name        string       `json:"name" gorm:"column:name"`
+	Submodules  []Submodules `json:"submodules" gorm:"many2many:roles_submodules"` // Asegúrate de que Submodules esté definido
+}
+
+// TableName overrides the table name used by Modules to `modules`
+func (Roles) TableName() string {
+	return "roles"
+}
+
+// AllModules recupera todos los módulos con búsqueda
+func AllRoles(limit, offset int, search string) ([]Roles, int64, error) {
+	var roles []Roles
+	var total int64
+	db := app.Http.Database.DB.Model(&Roles{})
+
+	// Filtrar por término de búsqueda si se proporciona
+	if search != "" {
+		db = db.Where("name LIKE ? OR description LIKE ?", "%"+search+"%", "%"+search+"%")
+	}
+
+	// Obtener el total de módulos
+	if err := db.Count(&total).Error; err != nil {
+		return nil, 0, err
+	}
+
+	// Obtener los módulos con paginación
+	if err := db.Order("id DESC").Limit(limit).Offset(offset).Preload("Submodules").Find(&roles).Error; err != nil {
+		return nil, 0, err
+	}
+
+	return roles, total, nil
+}
+
+// AllRolesSelect recupera todos los roles sin paginación
+func AllRolesSelect() ([]Roles, error) {
+	var roles []Roles
+
+	// Realizar la consulta para obtener todos los roles
+	if err := app.Http.Database.DB.Model(&Roles{}).Find(&roles).Error; err != nil {
+		return nil, err
+	}
+
+	return roles, nil
+}
+
+// CreateModule creates a new rol
+func CreateRole(role Roles) error {
+	if err := app.Http.Database.DB.Create(&role).Error; err != nil {
+		return err
+	}
+	return nil
+}
+
+// UpdateModule updates an existing module
+func UpdateRole(role Roles) error {
+	if err := app.Http.Database.DB.Save(&role).Error; err != nil {
+		return err
+	}
+	return nil
+}
+
+// DeleteModule deletes a module by its ID
+func DeleteRole(id uint) error {
+	if err := app.Http.Database.DB.Delete(&Roles{}, id).Error; err != nil {
+		return err
+	}
+	return nil
+}
+
+func FindRoleByName(name string) (Roles, error) {
+	var role Roles
+	if err := app.Http.Database.DB.Where("name = ?", name).First(&role).Error; err != nil {
+		return role, err
+	}
+	return role, nil
+}

pkg/models/submodules.go

@@ -0,0 +1,84 @@
+package models
+
+import (
+	"time"
+
+	"github.com/sujit-baniya/fiber-boilerplate/app"
+	"gorm.io/gorm"
+)
+
+type Submodules struct {
+	gorm.Model            // Hereda campos como ID, CreatedAt, UpdatedAt, DeletedAt
+	ModifiedAt  time.Time `json:"modified_at" gorm:"column:modified_at"`
+	Description string    `json:"description" gorm:"column:description"`
+	Title       string    `json:"title" gorm:"column:title"`
+	Url         string    `json:"url" gorm:"column:url"`
+	ModuleId    uint      `json:"module_id" gorm:"column:module_id"` // ID del módulo
+	Module      Modules   `json:"module" gorm:"foreignKey:ModuleId"` // Módulo al que pertenece
+	Roles       []Roles   `gorm:"many2many:roles_submodules"`
+}
+
+// TableName overrides the table name used by Modulos to `modules`
+func (Submodules) TableName() string {
+	return "submodules"
+}
+
+// AllModules recupera todos los módulos con búsqueda
+func AllSubmodules(limit, offset int, search string) ([]Submodules, int64, error) {
+	var submodules []Submodules
+	var total int64
+	db := app.Http.Database.DB.Model(&Submodules{})
+
+	// Filtrar por término de búsqueda si se proporciona
+	if search != "" {
+		db = db.Where("title LIKE ? OR description LIKE ?", "%"+search+"%", "%"+search+"%")
+	}
+
+	// Obtener el total de módulos
+	if err := db.Count(&total).Error; err != nil {
+		return nil, 0, err
+	}
+
+	// Obtener los módulos con paginación
+	if err := db.Order("created_at DESC").Limit(limit).Offset(offset).Preload("Module").Preload("Roles").Find(&submodules).Error; err != nil {
+		return nil, 0, err
+	}
+
+	return submodules, total, nil
+}
+
+// Allsubmodulesselect recupera todos los roles sin paginación
+func AllSubmodulesSelect() ([]Submodules, error) {
+	var submodules []Submodules
+
+	// Realizar la consulta para obtener todos los roles
+	if err := app.Http.Database.DB.Model(&Submodules{}).Find(&submodules).Error; err != nil {
+		return nil, err
+	}
+
+	return submodules, nil
+}
+
+// CreateModule creates a new module
+func CreateSubmodule(submodule Submodules) error {
+	if err := app.Http.Database.DB.Create(&submodule).Error; err != nil {
+		return err
+	}
+	return nil
+}
+
+// UpdateModule updates an existing module
+func UpdateSubmodule(submodule Submodules) error {
+	if err := app.Http.Database.DB.Save(&submodule).Error; err != nil {
+		return err
+	}
+	return nil
+}
+
+// DeleteModule deletes a module by its ID
+func DeleteSumodule(id uint) error {
+	if err := app.Http.Database.DB.Delete(&Submodules{}, id).Error; err != nil {
+		return err
+	}
+	return nil
+}

pkg/models/user.go

@@ -0,0 +1,105 @@
+package models
+
+import (
+	"fmt"
+	"strconv"
+	"time"
+
+	"github.com/sujit-baniya/fiber-boilerplate/config"
+
+	"github.com/sujit-baniya/fiber-boilerplate/app"
+	"gorm.io/gorm"
+)
+
+type User struct {
+	ID            uint `gorm:"primarykey"`
+	CreatedAt     time.Time
+	UpdatedAt     time.Time
+	DeletedAt     gorm.DeletedAt `gorm:"index"`
+	FirstName     string         `json:"first_name" gorm:"first_name"` //nolint:gofmt
+	LastName      string         `json:"last_name" gorm:"last_name"`   //nolint:gofmt
+	Email         string         `json:"email" gorm:"email"`
+	Password      string         `json:"-" gorm:"password"`
+	EmailVerified bool           `json:"email_verified" gorm:"email_verified"`
+	IsAdmin       bool           `json:"is_admin" gorm:"is_admin"`
+	Balance       float32        `json:"balance" gorm:"balance"`
+	UserSetting   UserSetting    `json:"user_setting" gorm:"-"`
+	RoleID        uint           `json:"role_id" gorm:"role_id"`
+	Role          Roles          `gorm:"foreignKey:RoleID"` // Establecer relación con Roles
+
+}
+
+type Role struct {
+	ID          uint   `gorm:"primarykey"`
+	Name        string `json:"name" gorm:"name"`               //nolint:gofmt
+	Description string `json:"description" gorm:"description"` //nolint:gofmt
+	CreatedAt   time.Time
+	UpdatedAt   time.Time
+	DeletedAt   gorm.DeletedAt `gorm:"index"`
+}
+
+func GetUserByEmail(email string) (*Users, error) {
+	var user Users
+	if err := app.Http.Database.Where(&Users{Email: email}).First(&user).Error; err != nil {
+		return nil, err
+	}
+	return &user, nil //nolint:wsl
+}
+
+func GetVerifiedUserByEmail(usuario string) (*Users, error) {
+	var user Users
+	if err := app.Http.Database.Where(&Users{NombreUsuario: usuario}).First(&user).Error; err != nil {
+		return nil, err
+	}
+	return &user, nil //nolint:wsl
+}
+
+func GetUserById(id interface{}) (*Users, error) {
+	var user Users
+	if err := app.Http.Database.Where("id = ? ", id).First(&user).Error; err != nil {
+		return nil, err
+	}
+
+	return &user, nil
+}
+
+func (u *User) Update() error {
+	if u.ID != 0 {
+		if err := app.Http.Database.Updates(&u).Error; err != nil {
+			return err
+		}
+	} else {
+		if err := app.Http.Database.Where(&User{Email: u.Email}).Updates(&u).Error; err != nil {
+			return err
+		}
+	}
+	app.Http.Database.First(&u)
+	u.Settings()
+	return nil
+}
+
+func (u *User) AddAmount(amount string, AlreadyAdded bool) {
+	if AlreadyAdded {
+		return
+	}
+	value, err := strconv.ParseFloat(amount, 32)
+	if err != nil {
+		// do something sensible
+	}
+	u.Balance += float32(value)
+	app.Http.Database.Updates(&u)
+}
+
+func (u *User) Settings() (UserSetting, error) {
+	userSettings := UserSetting{UserID: u.ID}
+	err := userSettings.Get()
+	if err != nil {
+		return UserSetting{}, err
+	}
+	u.UserSetting = userSettings
+	return userSettings, nil
+}
+
+func (u *User) Can(permission string) bool {
+	return app.Http.Auth.Casbin.Can(fmt.Sprintf("%d", u.ID), permission, config.MatchAll)
+}

pkg/models/user_meta.go

@@ -0,0 +1,12 @@
+package models
+
+import (
+	"gorm.io/gorm"
+)
+
+type UserMeta struct {
+	*gorm.Model
+	UserID uint `gorm:"user_id" json:"user_id"`
+	Key    uint `gorm:"key" json:"key"`
+	Value  uint `gorm:"value" json:"value"`
+}

pkg/models/user_settings.go

@@ -0,0 +1,29 @@
+package models
+
+import (
+	"github.com/sujit-baniya/fiber-boilerplate/app"
+	"gorm.io/gorm"
+)
+
+type UserSetting struct {
+	*gorm.Model
+	UserID      uint   `gorm:"user_id" json:"user_id"`
+	PhoneRegion string `gorm:"phone_region" json:"phone_region"`
+	SenderID    string `gorm:"sender_id" json:"sender_id"`
+	QueueType   string `gorm:"queue_type" json:"queue_type"` // SHARED | ACCOUNT | CAMPAIGN
+}
+
+func (u *UserSetting) UpdateOrCreate() {
+	if u.UserID != 0 {
+		if app.Http.Database.Where(&UserSetting{UserID: u.UserID}).Updates(&u).RowsAffected == 0 {
+			app.Http.Database.Create(&u)
+		}
+	}
+}
+
+func (u *UserSetting) Get() error {
+	if err := app.Http.Database.Where(&UserSetting{UserID: u.UserID}).First(&u).Error; err != nil {
+		return err
+	}
+	return nil
+}

pkg/models/users.go

@@ -0,0 +1,227 @@
+package models
+
+import (
+	"errors"
+	"fmt"
+	"time"
+
+	"github.com/sujit-baniya/fiber-boilerplate/app"
+	"gorm.io/gorm"
+)
+
+type Users struct {
+	ID            uint `gorm:"primarykey"`
+	CreatedAt     time.Time
+	UpdatedAt     time.Time
+	DeletedAt     gorm.DeletedAt `gorm:"index"`
+	Name          string         `json:"name" gorm:"name"`
+	Email         string         `json:"email" gorm:"email"`
+	Password      string         `json:"password,omitempty" gorm:"password"`
+	EmailVerified bool           `json:"email_verified" gorm:"email_verified"`
+	IsAdmin       bool           `json:"is_admin" gorm:"is_admin"`
+	RoleID        uint           `json:"role_id" gorm:"role_id"`
+	Role          Roles          `gorm:"foreignKey:RoleID"` // Establecer relación con Roles
+
+	NombreUsuario    string `json:"nombre_usuario" gorm:"nombre_usuario"`
+	Documento        string `json:"documento" gorm:"documento"`
+	Estado           *bool  `json:"estado" gorm:"estado"`
+	TipoUsuario      string `json:"tipo" gorm:"tipo_usuario"`
+	CogidoUsuarioGas string `json:"cogido_usuario_gas" gorm:"cogido_usuario_gas"`
+	NumeroMedidor    string `json:"numero_medidor" gorm:"numero_medidor"`
+	TelefonoFijo     string `json:"telefono_fijo" gorm:"telefono_fijo"`
+	Celular          string `json:"celular" gorm:"celular"`
+	AceptoInfo       bool   `json:"acepto_info" gorm:"acepto_info"`
+}
+
+// TableName overrides the table name used by Modules to `modules`
+func (Users) TableName() string {
+	return "users"
+}
+
+// AllModules recupera todos los módulos con búsqueda
+func AllUsersGas(limit, offset int, search string) ([]Users, int64, error) {
+	var users []Users
+	var total int64
+	db := app.Http.Database.DB.Model(&Users{})
+
+	// Filtrar por término de búsqueda si se proporciona
+	if search != "" {
+		db = db.Where("name LIKE ? OR nombre_usuario LIKE ?", "%"+search+"%", "%"+search+"%")
+	}
+	// Filtrar por tipo_usuario = 'gas'
+	db = db.Where("tipo_usuario = ?", "gas")
+
+	// Obtener el total de usuarios
+	if err := db.Count(&total).Error; err != nil {
+		return nil, 0, err
+	}
+
+	// Obtener los usuarios con paginación y precargar los roles
+	if err := db.Order("id DESC").Limit(limit).Offset(offset).
+		Preload("Role"). // Precargar la relación Role
+		Find(&users).Error; err != nil {
+		return nil, 0, err
+	}
+
+	return users, total, nil
+}
+
+func AllUsersSistema(limit, offset int, search string) ([]Users, int64, error) {
+	var users []Users
+	var total int64
+	db := app.Http.Database.DB.Model(&Users{})
+
+	// Filtrar por término de búsqueda si se proporciona
+	if search != "" {
+		db = db.Where("name LIKE ? OR nombre_usuario LIKE ?", "%"+search+"%", "%"+search+"%")
+	}
+
+	// Filtrar por tipo_usuario = 'sistema'
+	db = db.Where("tipo_usuario = ?", "sistema")
+
+	// Obtener el total de usuarios
+	if err := db.Count(&total).Error; err != nil {
+		return nil, 0, err
+	}
+
+	// Obtener los usuarios con paginación y precargar los roles
+	if err := db.Order("id DESC").Limit(limit).Offset(offset).
+		Preload("Role"). // Precargar la relación Role
+		Find(&users).Error; err != nil {
+		return nil, 0, err
+	}
+
+	return users, total, nil
+}
+
+// CreateModule creates a new module
+func CreateUser(User Users) error {
+	if err := app.Http.Database.DB.Create(&User).Error; err != nil {
+		return err
+	}
+	return nil
+}
+
+// UpdateUser updates an existing user
+func UpdateUser(userID uint, Name string, NombreUsuario string, Email string, RoleID int) error {
+	// Crea un mapa con los campos a actualizar
+	updates := map[string]interface{}{
+		"name":           Name,
+		"nombre_usuario": NombreUsuario,
+		"email":          Email,
+		"role_id":        RoleID,
+	}
+
+	// Realiza la actualización de los campos en la base de datos
+	if err := app.Http.Database.DB.Model(&Users{}).Where("id = ?", userID).Updates(updates).Error; err != nil {
+		return err
+	}
+	return nil
+}
+
+// UpdateUser updates an existing user
+func UpdateUserGas(userID uint, Name string, NombreUsuario string, Email string, Celular string) error {
+	// Crea un mapa con los campos a actualizar
+	updates := map[string]interface{}{
+		"name":           Name,
+		"nombre_usuario": NombreUsuario,
+		"email":          Email,
+		"celular":        Celular,
+	}
+
+	// Realiza la actualización de los campos en la base de datos
+	if err := app.Http.Database.DB.Model(&Users{}).Where("id = ?", userID).Updates(updates).Error; err != nil {
+		return err
+	}
+	return nil
+}
+
+// UpdateUserPassword actualiza solo la contraseña de un usuario existente
+func UpdateUserPassword(userID uint, newPassword string) error {
+	// Utiliza `Model` para especificar el modelo de Users y `Where` para buscar el usuario
+	if err := app.Http.Database.DB.Model(&Users{}).Where("id = ?", userID).Update("password", newPassword).Error; err != nil {
+		return err
+	}
+	return nil
+}
+
+// UpdateUser updates an existing user
+func UpdateUserEstado(userID uint, Estado bool) error {
+	// Crea un mapa con los campos a actualizar
+	updates := map[string]interface{}{
+		"estado": Estado,
+	}
+
+	// Realiza la actualización de los campos en la base de datos
+	if err := app.Http.Database.DB.Model(&Users{}).Where("id = ?", userID).Updates(updates).Error; err != nil {
+		return err
+	}
+	return nil
+}
+
+// DeleteModule deletes a module by its ID
+func DeleteUser(id uint) error {
+	if err := app.Http.Database.DB.Delete(&Users{}, id).Error; err != nil {
+		return err
+	}
+	return nil
+}
+
+// FindUserByID recupera un solo usuario por su ID
+func FindUserByID(id interface{}) (*Users, error) {
+	var user Users
+
+	// Asumimos que 'db' está correctamente inicializado en otro lugar de tu aplicación
+	db := app.Http.Database.DB.Model(&Users{})
+
+	// Buscar el usuario por ID
+	if err := db.Where("id = ?", id).Preload("Role.Submodules.Module").First(&user).Error; err != nil {
+		// Manejar el error si el registro no se encuentra
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return nil, fmt.Errorf("usuario no encontrado con ID: %d", id)
+		}
+		return nil, fmt.Errorf("error al buscar usuario: %v", err)
+	}
+
+	return &user, nil
+}
+
+func GetUserByUsuario(usuario string) (*Users, error) {
+	var user Users
+	fmt.Println(usuario) // Verifica el usuario recibido
+	db := app.Http.Database.DB.Model(&Users{})
+	// Usamos 1 explícitamente para indicar que el estado debe ser "activo"
+	if err := db.Where("nombre_usuario = ? AND email_verified = ? AND estado = ?", usuario, true, 1).First(&user).Error; err != nil {
+		return nil, err
+	}
+
+	fmt.Println(user) // Verifica el resultado
+	return &user, nil
+}
+
+func GetUserByUsuarioVerify(usuario string) (*Users, error) {
+	var user Users
+	if err := app.Http.Database.Where(&Users{NombreUsuario: usuario}).First(&user).Error; err != nil {
+		return nil, err
+	}
+	fmt.Println(user)
+	return &user, nil //nolint:wsl
+}
+func CheckUsernameExists(username string) (bool, error) {
+	var user Users
+	// Busca un registro en la base de datos
+	err := app.Http.Database.Where("nombre_usuario = ?", username).First(&user).Error
+
+	// Si no se encontró el registro, no es un error real
+	if err == gorm.ErrRecordNotFound {
+		return false, nil
+	}
+
+	// Retorna verdadero si no hubo error y falso si ocurrió un error
+	if err != nil {
+		return false, err
+	}
+
+	// Si no hubo error, significa que el usuario existe
+	return true, nil
+}

pkg/models/view.go

@@ -0,0 +1 @@
+package models

pkg/services/mail_service.go

@@ -0,0 +1,79 @@
+package services
+
+import (
+	"fmt"
+	"log"
+	"time"
+
+	"github.com/gofiber/fiber/v2"
+	"github.com/sujit-baniya/fiber-boilerplate/app"
+	"github.com/sujit-baniya/fiber-boilerplate/utils"
+)
+
+func SendPasswordResetEmail(email string, baseURL string) {
+	// Generar un identificador único para el correo de restablecimiento
+	resetEmail := fmt.Sprintf("%s-reset-%d", email, time.Now().Unix())
+	// Generar la URL de restablecimiento
+	resetLink := GeneratePasswordResetURL(resetEmail, baseURL)
+
+	// Preparar el cuerpo HTML del correo utilizando la plantilla
+	htmlBody := app.Http.Mail.PrepareHtml("emails/password-reset", fiber.Map{
+		"reset_link": resetLink,
+	})
+
+	// Canal para recibir errores de la goroutine
+	errChan := make(chan error)
+
+	// Ejecutar la goroutine para enviar el correo de manera asíncrona
+	go func() {
+		err := app.Http.Mail.Send(email, "Solicitud de restablecimiento de contraseña - Gases del oriente", htmlBody, "")
+		errChan <- err // Enviar el error (o nil si no hay error) al canal
+	}()
+
+	// Esperar el resultado de la goroutine
+	err := <-errChan
+	if err != nil {
+		log.Printf("Error enviando el correo de restablecimiento: %s", err)
+	} else {
+		log.Println("Correo de restablecimiento enviado con éxito")
+	}
+}
+func SendConfirmationEmail(email string, baseURL string, nombreUsuario string) {
+	// Generar el enlace de confirmación
+	confirmLink := GenerateConfirmURL(nombreUsuario, baseURL)
+	// Preparar el cuerpo HTML del correo utilizando la plantilla
+	htmlBody := app.Http.Mail.PrepareHtml("emails/confirm", fiber.Map{
+		"confirm_link": confirmLink,
+	})
+
+	// Canal para recibir errores de la goroutine
+	errChan := make(chan error)
+
+	// Ejecutar la goroutine para enviar el correo de manera asíncrona
+	go func() {
+		err := app.Http.Mail.Send(email, "✅ ¡Confirma tu registro en la Oficina Virtual de Gases del Oriente!", htmlBody, "")
+		errChan <- err // Enviar el error (o nil si no hay error) al canal
+	}()
+
+	// Esperar el resultado de la goroutine
+	err := <-errChan
+	if err != nil {
+		// Manejar el error si ocurrió
+		log.Printf("Error enviando el correo de confirmación: %s", err)
+	} else {
+		// Imprimir en consola si el correo se envió con éxito
+		log.Println("Correo electrónico de confirmación enviado a:", email)
+	}
+}
+
+func GenerateConfirmURL(nombreUsuario string, baseURL string) string {
+	token := utils.Encrypt(nombreUsuario, app.Http.Server.Key)
+	uri := fmt.Sprintf("%s/do/verify-email?t=%s", baseURL, token)
+	return uri
+}
+
+func GeneratePasswordResetURL(email string, baseURL string) string {
+	token := utils.Encrypt(email, app.Http.Server.Key)
+	uri := fmt.Sprintf("%s/reset-password?t=%s", baseURL, token)
+	return uri
+}

pkg/services/user_service.go

@@ -0,0 +1 @@
+package services