tariffs/internal/controller/tariff_internal/controller.go

package tariff_internal

import (
	"errors"
	"github.com/gofiber/fiber/v2"
	"go.mongodb.org/mongo-driver/bson/primitive"
	"go.uber.org/zap"
	"hub_admin_backend_service/internal/controller/middleware"
	our_errors "hub_admin_backend_service/internal/errors"
	"hub_admin_backend_service/internal/models"
	"hub_admin_backend_service/internal/repository/tariff"
	"hub_admin_backend_service/internal/tools"
)

// todo middleware jwt

type Deps struct {
	Repo       *tariff.Tariff
	Logger     *zap.Logger
	MiddleWare *middleware.MiddleWare
}

type TariffInternal struct {
	repo       *tariff.Tariff
	logger     *zap.Logger
	middleWare *middleware.MiddleWare
}

func NewTariffInternal(deps Deps) *TariffInternal {
	return &TariffInternal{
		repo:       deps.Repo,
		logger:     deps.Logger,
		middleWare: deps.MiddleWare,
	}
}

func (t *TariffInternal) Get(ctx *fiber.Ctx) error {
	tariffID := ctx.Params("id")
	if tariffID == "" {
		return ctx.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "url field id don't be empty"})
	}

	objID, err := primitive.ObjectIDFromHex(tariffID)
	if err != nil {
		return ctx.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "no valid object tariff id"})
	}

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

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

func (t *TariffInternal) GetList(ctx *fiber.Ctx) error {
	page, limit := t.middleWare.GetPaginationParameters(ctx)
	result, err := t.repo.GetList(ctx.Context(), page, limit, "")
	if err != nil {
		return ctx.Status(fiber.StatusInternalServerError).JSON(fiber.Map{"error": err.Error()})
	}

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

func (t *TariffInternal) Create(ctx *fiber.Ctx) error {
	var req models.Tariff
	if err := ctx.BodyParser(&req); err != nil {
		return ctx.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "Invalid request payload"})
	}

	err := tools.ValidateTariff(req)
	if err != nil {
		return ctx.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": err.Error()})
	}

	result, err := t.repo.Create(ctx.Context(), req)
	if err != nil {
		return ctx.Status(fiber.StatusInternalServerError).JSON(fiber.Map{"error": err.Error()})
	}

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

func (t *TariffInternal) Delete(ctx *fiber.Ctx) error {
	var req struct {
		ID string `json:"id"`
	}

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

	if req.ID == "" {
		return ctx.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "Tariff id don't be nil"})
	}

	objID, err := primitive.ObjectIDFromHex(req.ID)
	if err != nil {
		return ctx.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "no valid object tariff id"})
	}

	result, err := t.repo.SoftDelete(ctx.Context(), objID)
	if err != nil {
		switch {
		case errors.Is(err, our_errors.ErrNotFound):
			return ctx.Status(fiber.StatusNotFound).JSON(fiber.Map{"error": "Tariff not found"})
		default:
			return ctx.Status(fiber.StatusInternalServerError).JSON(fiber.Map{"error": err.Error()})
		}
	}

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

func (t *TariffInternal) Update(ctx *fiber.Ctx) error {
	var req models.Tariff
	if err := ctx.BodyParser(&req); err != nil {
		return ctx.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "Invalid request payload"})
	}

	err := tools.ValidateTariff(req)
	if err != nil {
		return ctx.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": err.Error()})
	}

	id := ctx.Params("id")
	objID, err := primitive.ObjectIDFromHex(id)
	if err != nil {
		return ctx.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "no valid object tariff id"})
	}

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

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

func (t *TariffInternal) Restore(ctx *fiber.Ctx) error {
	var req struct {
		ID string `json:"id"`
	}
	if err := ctx.BodyParser(&req); err != nil {
		return ctx.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "Invalid request payload"})
	}

	if req.ID == "" {
		return ctx.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "id don`t be empty"})
	}

	objID, err := primitive.ObjectIDFromHex(req.ID)
	if err != nil {
		return ctx.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "no valid object tariff id"})
	}

	result, err := t.repo.Restore(ctx.Context(), objID)
	if err != nil {
		switch {
		case errors.Is(err, our_errors.ErrNotFound):
			return ctx.Status(fiber.StatusNotFound).JSON(fiber.Map{"error": "Tariff not found"})
		default:
			return ctx.Status(fiber.StatusInternalServerError).JSON(fiber.Map{"error": err.Error()})
		}
	}

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