cruds update

rest/controllers/conx_db_controller.go

@@ -0,0 +1,127 @@
+package controllers
+
+import (
+	"math"
+	"strconv"
+
+	"github.com/gofiber/fiber/v2"
+	"github.com/sujit-baniya/fiber-boilerplate/pkg/models"
+)
+
+// RENDER
+func ConxDb(c *fiber.Ctx) error {
+	data := fiber.Map{
+		"user":    c.Locals("user").(map[string]interface{}),
+		"modules": c.Locals("userModules"),
+	}
+
+	if err := c.Render("conx_db", data, "layouts/main"); err != nil {
+		return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{
+			"message": "Error rendering template",
+			"error":   err.Error(),
+		})
+	}
+	return nil
+}
+
+func GetConxDb(c *fiber.Ctx) error {
+	pageStr := c.Query("page", "1")
+	page, err := strconv.Atoi(pageStr)
+	if err != nil || page < 1 {
+		page = 1
+	}
+	searchQuery := c.Query("search", "")
+	limitStr := c.Query("limit", "10")
+	limit, _ := strconv.Atoi(limitStr)
+	offset := (page - 1) * limit
+
+	records, total, err := models.GetAllConxDb(limit, offset, searchQuery)
+	if err != nil {
+		return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{
+			"message": "Error retrieving records",
+			"error":   err.Error(),
+		})
+	}
+	totalPages := int(math.Ceil(float64(total) / float64(limit)))
+	return c.JSON(fiber.Map{
+		"registros":  records,
+		"total":      total,
+		"totalPages": totalPages,
+		"page":       page,
+		"limit":      limit,
+	})
+}
+
+func CreateConxDb(c *fiber.Ctx) error {
+	var m models.ConxDb
+
+	if err := c.BodyParser(&m); err != nil {
+		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
+			"message": "Error parsing request body",
+			"error":   err.Error(),
+		})
+	}
+
+	if err := models.CreateConxDb(m); err != nil {
+		return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{
+			"message": "Error creating conx ssh",
+			"error":   err.Error(),
+		})
+	}
+
+	return c.Status(fiber.StatusCreated).JSON(m)
+}
+
+func UpdateConxDb(c *fiber.Ctx) error {
+	uid, err := strconv.ParseUint(c.Params("id"), 10, 32)
+	if err != nil {
+		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
+			"message": "ID inválido",
+			"error":   err.Error(),
+		})
+	}
+
+	var m models.ConxDb
+
+	if err := c.BodyParser(&m); err != nil {
+		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
+			"message": "Error al parsear el cuerpo de la solicitud",
+			"error":   err.Error(),
+		})
+	}
+
+	m.ID = uint(uid)
+
+	if err := models.UpdateConxDb(m); err != nil {
+		return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{
+			"message": "Error al actualizar el conx ssh",
+			"error":   err.Error(),
+		})
+	}
+
+	return c.Status(fiber.StatusOK).JSON(m)
+}
+
+func DeleteConxDb(c *fiber.Ctx) error {
+	uid, err := strconv.ParseUint(c.Params("id"), 10, 32)
+	if err != nil {
+		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
+			"message": "ID inválido",
+			"error":   err.Error(),
+		})
+	}
+
+	var m models.ConxDb
+	m.ID = uint(uid)
+
+	if err := models.DeleteConxDb(m); err != nil {
+		return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{
+			"message": "Error al eliminar el conx ssh",
+			"error":   err.Error(),
+		})
+	}
+
+	return c.Status(fiber.StatusOK).JSON(fiber.Map{
+		"message": "conx ssh eliminado exitosamente",
+	})
+}

rest/controllers/conx_ssh_controller.go

@@ -0,0 +1,127 @@
+package controllers
+
+import (
+	"math"
+	"strconv"
+
+	"github.com/gofiber/fiber/v2"
+	"github.com/sujit-baniya/fiber-boilerplate/pkg/models"
+)
+
+// RENDER
+func ConxSsh(c *fiber.Ctx) error {
+	data := fiber.Map{
+		"user":    c.Locals("user").(map[string]interface{}),
+		"modules": c.Locals("userModules"),
+	}
+
+	if err := c.Render("conx_ssh", data, "layouts/main"); err != nil {
+		return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{
+			"message": "Error rendering template",
+			"error":   err.Error(),
+		})
+	}
+	return nil
+}
+
+func GetConxSsh(c *fiber.Ctx) error {
+	pageStr := c.Query("page", "1")
+	page, err := strconv.Atoi(pageStr)
+	if err != nil || page < 1 {
+		page = 1
+	}
+	searchQuery := c.Query("search", "")
+	limitStr := c.Query("limit", "10")
+	limit, _ := strconv.Atoi(limitStr)
+	offset := (page - 1) * limit
+
+	records, total, err := models.GetAllConxSsh(limit, offset, searchQuery)
+	if err != nil {
+		return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{
+			"message": "Error retrieving records",
+			"error":   err.Error(),
+		})
+	}
+	totalPages := int(math.Ceil(float64(total) / float64(limit)))
+	return c.JSON(fiber.Map{
+		"registros":  records,
+		"total":      total,
+		"totalPages": totalPages,
+		"page":       page,
+		"limit":      limit,
+	})
+}
+
+func CreateConxSsh(c *fiber.Ctx) error {
+	var m models.ConxSsh
+
+	if err := c.BodyParser(&m); err != nil {
+		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
+			"message": "Error parsing request body",
+			"error":   err.Error(),
+		})
+	}
+
+	if err := models.CreateConxSsh(m); err != nil {
+		return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{
+			"message": "Error creating conx ssh",
+			"error":   err.Error(),
+		})
+	}
+
+	return c.Status(fiber.StatusCreated).JSON(m)
+}
+
+func UpdateConxSsh(c *fiber.Ctx) error {
+	uid, err := strconv.ParseUint(c.Params("id"), 10, 32)
+	if err != nil {
+		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
+			"message": "ID inválido",
+			"error":   err.Error(),
+		})
+	}
+
+	var m models.ConxSsh
+
+	if err := c.BodyParser(&m); err != nil {
+		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
+			"message": "Error al parsear el cuerpo de la solicitud",
+			"error":   err.Error(),
+		})
+	}
+
+	m.ID = uint(uid)
+
+	if err := models.UpdateConxSsh(m); err != nil {
+		return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{
+			"message": "Error al actualizar el conx ssh",
+			"error":   err.Error(),
+		})
+	}
+
+	return c.Status(fiber.StatusOK).JSON(m)
+}
+
+func DeleteConxSsh(c *fiber.Ctx) error {
+	uid, err := strconv.ParseUint(c.Params("id"), 10, 32)
+	if err != nil {
+		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
+			"message": "ID inválido",
+			"error":   err.Error(),
+		})
+	}
+
+	var m models.ConxSsh
+	m.ID = uint(uid)
+
+	if err := models.DeleteConxSsh(m); err != nil {
+		return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{
+			"message": "Error al eliminar el conx ssh",
+			"error":   err.Error(),
+		})
+	}
+
+	return c.Status(fiber.StatusOK).JSON(fiber.Map{
+		"message": "conx ssh eliminado exitosamente",
+	})
+}

rest/controllers/prov_servidor_controller.go

@@ -0,0 +1,117 @@
+package controllers
+
+import (
+	"strconv"
+
+	"github.com/gofiber/fiber/v2"
+	"github.com/sujit-baniya/fiber-boilerplate/pkg/models"
+)
+
+// RENDER
+func ProvServidor(c *fiber.Ctx) error {
+	data := fiber.Map{
+		"user":    c.Locals("user").(map[string]interface{}),
+		"modules": c.Locals("userModules"),
+	}
+
+	if err := c.Render("prov_servidor", data, "layouts/main"); err != nil {
+		return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{
+			"message": "Error rendering template",
+			"error":   err.Error(),
+		})
+	}
+	return nil
+}
+
+func GetProvServidor(c *fiber.Ctx) error {
+	searchQuery := c.Query("search", "")
+
+	records, total, err := models.GetAllProvServidor(searchQuery)
+
+	if err != nil {
+		return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{
+			"message": "Error retrieving records",
+			"error":   err.Error(),
+		})
+	}
+
+	return c.JSON(fiber.Map{
+		"registros":  records,
+		"total":      total,
+		"totalPages": 1,
+	})
+}
+
+func CreateProvServidor(c *fiber.Ctx) error {
+	var m models.ProvServidor
+
+	if err := c.BodyParser(&m); err != nil {
+		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
+			"message": "Error parsing request body",
+			"error":   err.Error(),
+		})
+	}
+
+	if err := models.CreateProvServidor(m); err != nil {
+		return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{
+			"message": "Error creating proveedor de servidor",
+			"error":   err.Error(),
+		})
+	}
+
+	return c.Status(fiber.StatusCreated).JSON(m)
+}
+
+func UpdateProvServidor(c *fiber.Ctx) error {
+	uid, err := strconv.ParseUint(c.Params("id"), 10, 32)
+	if err != nil {
+		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
+			"message": "ID inválido",
+			"error":   err.Error(),
+		})
+	}
+
+	var m models.ProvServidor
+
+	if err := c.BodyParser(&m); err != nil {
+		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
+			"message": "Error al parsear el cuerpo de la solicitud",
+			"error":   err.Error(),
+		})
+	}
+
+	m.ID = uint(uid)
+
+	if err := models.UpdateProvServidor(m); err != nil {
+		return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{
+			"message": "Error al actualizar el proveedor de servidor",
+			"error":   err.Error(),
+		})
+	}
+
+	return c.Status(fiber.StatusOK).JSON(m)
+}
+
+func DeleteProvServidor(c *fiber.Ctx) error {
+	uid, err := strconv.ParseUint(c.Params("id"), 10, 32)
+	if err != nil {
+		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
+			"message": "ID inválido",
+			"error":   err.Error(),
+		})
+	}
+
+	var m models.ProvServidor
+	m.ID = uint(uid)
+
+	if err := models.DeleteProvServidor(m); err != nil {
+		return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{
+			"message": "Error al eliminar el proveedor de servidor",
+			"error":   err.Error(),
+		})
+	}
+
+	return c.Status(fiber.StatusOK).JSON(fiber.Map{
+		"message": "Proveedor de servidor eliminado exitosamente",
+	})
+}

rest/controllers/servidor_controller.go

@@ -0,0 +1,140 @@
+package controllers
+
+import (
+	"math"
+	"strconv"
+
+	"github.com/gofiber/fiber/v2"
+	"github.com/sujit-baniya/fiber-boilerplate/pkg/models"
+)
+
+// RENDER
+func Servidor(c *fiber.Ctx) error {
+	data := fiber.Map{
+		"user":    c.Locals("user").(map[string]interface{}),
+		"modules": c.Locals("userModules"),
+	}
+
+	if err := c.Render("servidor", data, "layouts/main"); err != nil {
+		return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{
+			"message": "Error rendering template",
+			"error":   err.Error(),
+		})
+	}
+	return nil
+}
+
+func GetServidor(c *fiber.Ctx) error {
+	pageStr := c.Query("page", "1")
+	page, err := strconv.Atoi(pageStr)
+	if err != nil || page < 1 {
+		page = 1
+	}
+	searchQuery := c.Query("search", "")
+	limitStr := c.Query("limit", "10")
+	limit, _ := strconv.Atoi(limitStr)
+	offset := (page - 1) * limit
+
+	records, total, err := models.GetAllServidores(limit, offset, searchQuery)
+	if err != nil {
+		return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{
+			"message": "Error retrieving records",
+			"error":   err.Error(),
+		})
+	}
+	totalPages := int(math.Ceil(float64(total) / float64(limit)))
+	return c.JSON(fiber.Map{
+		"registros":  records,
+		"total":      total,
+		"totalPages": totalPages,
+		"page":       page,
+		"limit":      limit,
+	})
+}
+
+func GetServidorSelect(c *fiber.Ctx) error {
+	records, err := models.GetAllServidoresSelect()
+	if err != nil {
+		return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{
+			"message": "Error retrieving records",
+			"error":   err.Error(),
+		})
+	}
+	return c.JSON(fiber.Map{
+		"registros": records,
+	})
+}
+
+func CreateServidor(c *fiber.Ctx) error {
+	var m models.Servidor
+
+	if err := c.BodyParser(&m); err != nil {
+		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
+			"message": "Error parsing request body",
+			"error":   err.Error(),
+		})
+	}
+
+	if err := models.CreateServidor(m); err != nil {
+		return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{
+			"message": "Error creating servidor",
+			"error":   err.Error(),
+		})
+	}
+
+	return c.Status(fiber.StatusCreated).JSON(m)
+}
+
+func UpdateServidor(c *fiber.Ctx) error {
+	uid, err := strconv.ParseUint(c.Params("id"), 10, 32)
+	if err != nil {
+		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
+			"message": "ID inválido",
+			"error":   err.Error(),
+		})
+	}
+
+	var m models.Servidor
+
+	if err := c.BodyParser(&m); err != nil {
+		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
+			"message": "Error al parsear el cuerpo de la solicitud",
+			"error":   err.Error(),
+		})
+	}
+
+	m.ID = uint(uid)
+
+	if err := models.UpdateServidor(m); err != nil {
+		return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{
+			"message": "Error al actualizar el servidor",
+			"error":   err.Error(),
+		})
+	}
+
+	return c.Status(fiber.StatusOK).JSON(m)
+}
+
+func DeleteServidor(c *fiber.Ctx) error {
+	uid, err := strconv.ParseUint(c.Params("id"), 10, 32)
+	if err != nil {
+		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
+			"message": "ID inválido",
+			"error":   err.Error(),
+		})
+	}
+
+	var m models.Servidor
+	m.ID = uint(uid)
+
+	if err := models.DeleteServidor(m); err != nil {
+		return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{
+			"message": "Error al eliminar el servidor",
+			"error":   err.Error(),
+		})
+	}
+
+	return c.Status(fiber.StatusOK).JSON(fiber.Map{
+		"message": "Servidor eliminado exitosamente",
+	})
+}

rest/controllers/tipo_db_controller.go

@@ -0,0 +1,117 @@
+package controllers
+
+import (
+	"strconv"
+
+	"github.com/gofiber/fiber/v2"
+	"github.com/sujit-baniya/fiber-boilerplate/pkg/models"
+)
+
+// RENDER
+func TipoDb(c *fiber.Ctx) error {
+	data := fiber.Map{
+		"user":    c.Locals("user").(map[string]interface{}),
+		"modules": c.Locals("userModules"),
+	}
+
+	if err := c.Render("tipo_db", data, "layouts/main"); err != nil {
+		return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{
+			"message": "Error rendering template",
+			"error":   err.Error(),
+		})
+	}
+	return nil
+}
+
+func GetTipoDb(c *fiber.Ctx) error {
+	searchQuery := c.Query("search", "")
+
+	records, total, err := models.GetAllTipoDb(searchQuery)
+
+	if err != nil {
+		return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{
+			"message": "Error retrieving records",
+			"error":   err.Error(),
+		})
+	}
+
+	return c.JSON(fiber.Map{
+		"registros":  records,
+		"total":      total,
+		"totalPages": 1,
+	})
+}
+
+func CreateTipoDb(c *fiber.Ctx) error {
+	var m models.TipoDb
+
+	if err := c.BodyParser(&m); err != nil {
+		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
+			"message": "Error parsing request body",
+			"error":   err.Error(),
+		})
+	}
+
+	if err := models.CreateTipoDb(m); err != nil {
+		return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{
+			"message": "Error creating tipo de db",
+			"error":   err.Error(),
+		})
+	}
+
+	return c.Status(fiber.StatusCreated).JSON(m)
+}
+
+func UpdateTipoDb(c *fiber.Ctx) error {
+	uid, err := strconv.ParseUint(c.Params("id"), 10, 32)
+	if err != nil {
+		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
+			"message": "ID inválido",
+			"error":   err.Error(),
+		})
+	}
+
+	var m models.TipoDb
+
+	if err := c.BodyParser(&m); err != nil {
+		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
+			"message": "Error al parsear el cuerpo de la solicitud",
+			"error":   err.Error(),
+		})
+	}
+
+	m.ID = uint(uid)
+
+	if err := models.UpdateTipoDb(m); err != nil {
+		return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{
+			"message": "Error al actualizar el tipo de db",
+			"error":   err.Error(),
+		})
+	}
+
+	return c.Status(fiber.StatusOK).JSON(m)
+}
+
+func DeleteTipoDb(c *fiber.Ctx) error {
+	uid, err := strconv.ParseUint(c.Params("id"), 10, 32)
+	if err != nil {
+		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
+			"message": "ID inválido",
+			"error":   err.Error(),
+		})
+	}
+
+	var m models.TipoDb
+	m.ID = uint(uid)
+
+	if err := models.DeleteTipoDb(m); err != nil {
+		return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{
+			"message": "Error al eliminar el tipo de db",
+			"error":   err.Error(),
+		})
+	}
+
+	return c.Status(fiber.StatusOK).JSON(fiber.Map{
+		"message": "Tipo de db eliminado exitosamente",
+	})
+}

rest/controllers/tipo_servidor_controller.go

@@ -0,0 +1,118 @@
+package controllers
+
+import (
+	"strconv"
+
+	"github.com/gofiber/fiber/v2"
+	"github.com/sujit-baniya/fiber-boilerplate/pkg/models"
+)
+
+// RENDER
+func TipoServidor(c *fiber.Ctx) error {
+	data := fiber.Map{
+		"user":    c.Locals("user").(map[string]interface{}),
+		"modules": c.Locals("userModules"),
+	}
+
+	if err := c.Render("tipo_servidor", data, "layouts/main"); err != nil {
+		return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{
+			"message": "Error rendering template",
+			"error":   err.Error(),
+		})
+	}
+	return nil
+}
+
+func GetTipoServidor(c *fiber.Ctx) error {
+	searchQuery := c.Query("search", "")
+
+	records, total, err := models.GetAllTipoServidor(searchQuery)
+
+	if err != nil {
+		return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{
+			"message": "Error retrieving records",
+			"error":   err.Error(),
+		})
+	}
+
+	return c.JSON(fiber.Map{
+		"registros": records,
+		"total":     total,
+		"totalPages": 1,
+	})
+}
+
+
+func CreateTipoServidor(c *fiber.Ctx) error {
+	var m models.TipoServidor
+
+	if err := c.BodyParser(&m); err != nil {
+		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
+			"message": "Error parsing request body",
+			"error":   err.Error(),
+		})
+	}
+
+	if err := models.CreateTipoServidor(m); err != nil {
+		return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{
+			"message": "Error creating Tipo de servidor",
+			"error":   err.Error(),
+		})
+	}
+
+	return c.Status(fiber.StatusCreated).JSON(m)
+}
+
+func UpdateTipoServidor(c *fiber.Ctx) error {
+	uid, err := strconv.ParseUint(c.Params("id"), 10, 32)
+	if err != nil {
+		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
+			"message": "ID inválido",
+			"error":   err.Error(),
+		})
+	}
+
+	var m models.TipoServidor
+
+	if err := c.BodyParser(&m); err != nil {
+		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
+			"message": "Error al parsear el cuerpo de la solicitud",
+			"error":   err.Error(),
+		})
+	}
+
+	m.ID = uint(uid)
+
+	if err := models.UpdateTipoServidor(m); err != nil {
+		return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{
+			"message": "Error al actualizar el Tipo de servidor",
+			"error":   err.Error(),
+		})
+	}
+
+	return c.Status(fiber.StatusOK).JSON(m)
+}
+
+func DeleteTipoServidor(c *fiber.Ctx) error {
+	uid, err := strconv.ParseUint(c.Params("id"), 10, 32)
+	if err != nil {
+		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
+			"message": "ID inválido",
+			"error":   err.Error(),
+		})
+	}
+
+	var m models.TipoServidor
+	m.ID = uint(uid)
+
+	if err := models.DeleteTipoServidor(m); err != nil {
+		return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{
+			"message": "Error al eliminar el Tipo de servidor",
+			"error":   err.Error(),
+		})
+	}
+
+	return c.Status(fiber.StatusOK).JSON(fiber.Map{
+		"message": "Tipo de servidor eliminado exitosamente",
+	})
+}

rest/routes/user.go

@@ -37,6 +37,13 @@ func UserRoutes(app fiber.Router) {
 	protected.Put("/roles/:id", controllers.UpdateRole)                    // Actualizar
 	protected.Delete("/roles/:id", controllers.DeleteRole)                 // Eliminar
 
+	// Rutas de módulos
+	protected.Get("/submodules", middlewares.MenuMiddleware, controllers.Submodules) // Renderizar la vista
+	protected.Get("/loadsubmodules", controllers.GetSubmodules)                      // Obtener todos los módulos
+	protected.Post("/submodules", controllers.CreateSubmodule)                       // Crear un nuevo módulo
+	protected.Put("/submodules/:id", controllers.UpdateSubmodule)                    // Actualizar un módulo existente
+	protected.Delete("/submodules/:id", controllers.DeleteSubmodule)                 // Eliminar un módulo
+
 	// Rutas de usuarios
 	protected.Get("/users", middlewares.MenuMiddleware, controllers.Users) // Renderizar la vista
 	protected.Get("/loadusers", controllers.GetUsers)                      // Obtener
@@ -46,11 +53,47 @@ func UserRoutes(app fiber.Router) {
 	protected.Delete("/users/:id", controllers.DeleteUser)                 // Eliminar
 	protected.Get("/user/:id", controllers.GetUser)                        // Buscar un usuario
 
-	// Rutas de módulos
-	protected.Get("/submodules", middlewares.MenuMiddleware, controllers.Submodules) // Renderizar la vista
-	protected.Get("/loadsubmodules", controllers.GetSubmodules)                      // Obtener todos los módulos
-	protected.Post("/submodules", controllers.CreateSubmodule)                       // Crear un nuevo módulo
-	protected.Put("/submodules/:id", controllers.UpdateSubmodule)                    // Actualizar un módulo existente
-	protected.Delete("/submodules/:id", controllers.DeleteSubmodule)                 // Eliminar un módulo
-              // Eliminar un colaborador por ID
+	// Rutas de conexiones ssh
+	protected.Get("/conexion_ssh", middlewares.MenuMiddleware, controllers.ConxSsh) // Renderizar la vista
+	protected.Get("/loadconexionssh", controllers.GetConxSsh)                      // Obtener
+	protected.Post("/conexionssh", controllers.CreateConxSsh)                      // Crear
+	protected.Put("/conexionssh/:id", controllers.UpdateConxSsh)                   // Actualizar
+	protected.Delete("/conexionssh/:id", controllers.DeleteConxSsh)                // Eliminar
+
+	// Rutas de conexiones db
+	protected.Get("/conexion_db", middlewares.MenuMiddleware, controllers.ConxDb) // Renderizar la vista
+	protected.Get("/loadconexiondb", controllers.GetConxDb)                      // Obtener
+	protected.Post("/conexiondb", controllers.CreateConxDb)                      // Crear
+	protected.Put("/conexiondb/:id", controllers.UpdateConxDb)                   // Actualizar
+	protected.Delete("/conexiondb/:id", controllers.DeleteConxDb)                // Eliminar
+
+	// Rutas de servidor
+	protected.Get("/servidor", middlewares.MenuMiddleware, controllers.Servidor)
+	protected.Get("/loadservidorselect", controllers.GetServidor)                     
+	protected.Get("/loadservidor", controllers.GetServidor)                     
+	protected.Post("/servidor", controllers.CreateServidor)                     
+	protected.Put("/servidor/:id", controllers.UpdateServidor)                  
+	protected.Delete("/servidor/:id", controllers.DeleteServidor)               
+
+	// Rutas de proveedores de servidor
+	protected.Get("/prov_servidor", middlewares.MenuMiddleware, controllers.ProvServidor) 
+	protected.Get("/loadprovservidor", controllers.GetProvServidor)
+	protected.Post("/provservidor", controllers.CreateProvServidor)
+	protected.Put("/provservidor/:id", controllers.UpdateProvServidor)
+	protected.Delete("/provservidor/:id", controllers.DeleteProvServidor)
+
+	// Rutas de tipos de servidor
+	protected.Get("/tipo_servidor", middlewares.MenuMiddleware, controllers.TipoServidor)
+	protected.Get("/loadtiposervidor", controllers.GetTipoServidor)
+	protected.Post("/tiposervidor", controllers.CreateTipoServidor)
+	protected.Put("/tiposervidor/:id", controllers.UpdateTipoServidor)
+	protected.Delete("/tiposervidor/:id", controllers.DeleteTipoServidor)
+
+	// Rutas de tipo db
+	protected.Get("/tipo_db", middlewares.MenuMiddleware, controllers.TipoDb)
+	protected.Get("/loadtipodb", controllers.GetTipoDb)
+	protected.Post("/tipodb", controllers.CreateTipoDb)
+	protected.Put("/tipodb/:id", controllers.UpdateTipoDb)
+	protected.Delete("/tipodb/:id", controllers.DeleteTipoDb)
+
 }