tariffs/internal/controller/privilege_internal/controller.go

package privilege_internal

import (
	"errors"
	"github.com/gofiber/fiber/v2"
	"go.uber.org/zap"
	our_errors "hub_admin_backend_service/internal/errors"
	"hub_admin_backend_service/internal/models"
	"hub_admin_backend_service/internal/repository/privilege"
	"hub_admin_backend_service/internal/tools"
)

type Deps struct {
	Repo   *privilege.Privilege
	Logger *zap.Logger
}

type PrivilegeInternal struct {
	repo   *privilege.Privilege
	logger *zap.Logger
}

func NewPrivilegeInternal(deps Deps) *PrivilegeInternal {
	return &PrivilegeInternal{
		repo:   deps.Repo,
		logger: deps.Logger,
	}
}

// хаб нода getAllPrivileges
func (p *PrivilegeInternal) Get(c *fiber.Ctx) error {
	privileges, err := p.repo.GetAllPrivileges(c.Context())
	if err != nil {
		switch {
		case errors.Is(err, our_errors.ErrNotFound):
			return c.Status(fiber.StatusNotFound).JSON(fiber.Map{"error": "Privileges not found"})
		default:
			return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{"error": err.Error()})
		}
	}

	return c.Status(fiber.StatusOK).JSON(privileges)
}

// хаб нода registerPrivilege
func (p *PrivilegeInternal) Create(c *fiber.Ctx) error {
	var req models.CreateUpdateReq
	if err := c.BodyParser(&req); err != nil {
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "Invalid request payload"})
	}

	if !tools.ValidatePrivilege(req) {
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "Missing required fields"})
	}

	result, err := p.repo.Create(c.Context(), req)
	if err != nil {
		switch {
		case errors.Is(err, our_errors.ErrAlreadyExist):
			return c.Status(fiber.StatusConflict).JSON(fiber.Map{"error": "Privilege already exist"})
		default:
			return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{"error": err.Error()})
		}
	}

	return c.Status(fiber.StatusOK).JSON(result)
}

// хаб нода replacePrivilege
func (p *PrivilegeInternal) Update(c *fiber.Ctx) error {
	var req models.CreateUpdateReq
	if err := c.BodyParser(&req); err != nil {
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "Invalid request payload"})
	}

	if !tools.ValidatePrivilege(req) {
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "Missing required fields"})
	}

	result, err := p.repo.Update(c.Context(), req)
	if err != nil {
		switch {
		case errors.Is(err, our_errors.ErrNotFound):
			return c.Status(fiber.StatusNotFound).JSON(fiber.Map{"error": "Privilege not found"})
		default:
			return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{"error": err.Error()})
		}
	}

	return c.Status(fiber.StatusOK).JSON(result)
}

// хаб нода removePrivilege
func (p *PrivilegeInternal) Delete(c *fiber.Ctx) error {
	var req struct {
		ID string `json:"privilegeId"`
	}

	if err := c.BodyParser(&req); err != nil {
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "Invalid request payload"})
	}

	if req.ID == "" {
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "PrivilegeID is required"})
	}

	result, err := p.repo.Delete(c.Context(), req.ID)
	if err != nil {
		switch {
		case errors.Is(err, our_errors.ErrNotFound):
			return c.Status(fiber.StatusNotFound).JSON(fiber.Map{"error": "Privilege not found"})
		default:
			return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{"error": err.Error()})
		}
	}

	return c.Status(fiber.StatusOK).JSON(result)
}

// хаб нода getPrivilege
func (p *PrivilegeInternal) GetByID(c *fiber.Ctx) error {
	privilegeID := c.Params("privilegeId")
	if privilegeID == "" {
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "Privilege ID is required"})
	}

	result, err := p.repo.GetByID(c.Context(), privilegeID)
	if err != nil {
		switch {
		case errors.Is(err, our_errors.ErrNotFound):
			return c.Status(fiber.StatusNotFound).JSON(fiber.Map{"error": "Privilege not found"})
		default:
			return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{"error": err.Error()})
		}
	}

	return c.Status(fiber.StatusOK).JSON(result)
}

// хаб нода getServicePrivileges
func (p *PrivilegeInternal) GetByService(c *fiber.Ctx) error {
	serviceKey := c.Params("serviceKey")
	if serviceKey == "" {
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "Service key is required"})
	}
	result, err := p.repo.GetByServiceKey(c.Context(), serviceKey)
	if err != nil {
		switch {
		case errors.Is(err, our_errors.ErrNotFound):
			return c.Status(fiber.StatusNotFound).JSON(fiber.Map{"error": "Privileges not found"})
		default:
			return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{"error": err.Error()})
		}
	}

	return c.Status(fiber.StatusOK).JSON(result)
}

// хаб нода registerPrivileges
func (p *PrivilegeInternal) PostMany(c *fiber.Ctx) error {
	var req models.ManyCreateUpdate
	if err := c.BodyParser(&req); err != nil {
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "Invalid request payload"})
	}

	if len(req.Privileges) == 0 {
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "len array dont be 0"})
	}

	for _, priv := range req.Privileges {
		if !tools.ValidatePrivilege(priv) {
			return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "Missing required fields"})
		}
	}

	result, err := p.repo.PostMany(c.Context(), req)
	if err != nil {
		switch {
		case errors.Is(err, our_errors.ErrAlreadyExist):
			return c.Status(fiber.StatusConflict).JSON(fiber.Map{"error": "One is privilege already exist"})
		default:
			return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{"error": err.Error()})
		}
	}

	return c.Status(fiber.StatusOK).JSON(result)
}

// хаб нода replacePrivileges
func (p *PrivilegeInternal) UpdateMany(c *fiber.Ctx) error {
	var req models.ManyCreateUpdate
	if err := c.BodyParser(&req); err != nil {
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "Invalid request payload"})
	}

	if len(req.Privileges) == 0 {
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "len array dont be 0"})
	}

	for _, priv := range req.Privileges {
		if !tools.ValidatePrivilege(priv) {
			return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "Missing required fields"})
		}
	}

	result, err := p.repo.UpdateMany(c.Context(), req)
	if err != nil {
		switch {
		case errors.Is(err, our_errors.ErrNotFound):
			return c.Status(fiber.StatusNotFound).JSON(fiber.Map{"error": "One is privilege not found"})
		default:
			return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{"error": err.Error()})
		}
	}

	return c.Status(fiber.StatusOK).JSON(result)
}

// хаб нода restorePrivilege
func (p *PrivilegeInternal) Restore(c *fiber.Ctx) error {
	var req struct {
		ID string `json:"privilegeId"`
	}

	if err := c.BodyParser(&req); err != nil {
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "Invalid request payload"})
	}

	if req.ID == "" {
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "PrivilegeID is required"})
	}

	result, err := p.repo.RestorePrivilege(c.Context(), req.ID)
	if err != nil {
		switch {
		case errors.Is(err, our_errors.ErrNotFound):
			return c.Status(fiber.StatusNotFound).JSON(fiber.Map{"error": "Privilege not found"})
		default:
			return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{"error": err.Error()})
		}
	}

	return c.Status(fiber.StatusOK).JSON(result)
}