verification/internal/controllers/verification.go

package controllers

import (
	"errors"
	"mime/multipart"

	"github.com/gofiber/fiber/v2"
	"github.com/valyala/fasthttp"
	"penahub.gitlab.yandexcloud.net/backend/verification/internal/client"
	"penahub.gitlab.yandexcloud.net/backend/verification/internal/models"
	"penahub.gitlab.yandexcloud.net/backend/verification/internal/repository"
)

type VerificationController struct {
	repository *repository.VerificationRepository
	telegram   *client.Telegram
	customer   *client.Customer
}

func NewVerificationController(rep *repository.VerificationRepository, telegram *client.Telegram, customer *client.Customer) *VerificationController {
	return &VerificationController{repository: rep, telegram: telegram, customer: customer}
}

func (r *VerificationController) GetRoutes() []Route {
	return []Route{
		{"GET", "/verification/:userID", "GetVerification", r.GetVerification},
		{"POST", "/verification", "CreateVerification", r.CreateVerification},
		{"PATCH", "/verification", "SetVerificationStatus", r.SetVerificationStatus},
		{Method: "PATCH", Path: "/verification/file", Name: "SetVerificationFile", Handler: r.SetVerificationFile},
	}
}

func (r *VerificationController) GetVerification(c *fiber.Ctx) error {
	userID := c.Params("userID")

	if userID == "" {
		userID = c.Locals("userID").(string)
		if userID == "" {
			return fiber.NewError(fiber.StatusUnauthorized)
		}
	}

	resp, err := r.repository.GetByUserID(c.Context(), userID)
	if err != nil {
		return c.Status(fiber.StatusInternalServerError).SendString(err.Error())
	}

	if resp == nil {
		return c.SendStatus(fiber.StatusNotFound)
	}

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

func (r *VerificationController) CreateVerification(c *fiber.Ctx) error {
	var req models.ReqCreateVerification

	userID := c.Params("userID")

	if userID == "" {
		userID = c.Locals("userID").(string)
		if userID == "" {
			return fiber.NewError(fiber.StatusUnauthorized)
		}
	}

	err := c.BodyParser(&req)
	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, err.Error())
	}

	errValidate := validateStruct(&req)
	if errValidate != nil {
		return c.Status(fiber.StatusBadRequest).JSON(errValidate)
	}

	// INN FILE
	innFH, err := c.FormFile("inn")

	if err != nil || innFH.Size == 0 || innFH == nil {
		return fiber.NewError(fiber.StatusBadRequest, "inn file required")
	}

	// RULE FILE
	ruleFH, err := c.FormFile("rule")

	if err != nil || ruleFH.Size == 0 || ruleFH == nil {
		return fiber.NewError(fiber.StatusBadRequest, "rule file required")
	}

	// EGRULE FILE
	egruleFH, err := c.FormFile("egrule")

	if err != nil || egruleFH.Size == 0 || egruleFH == nil {
		return fiber.NewError(fiber.StatusBadRequest, "egrule file required")
	}

	// CERTIFICATE FILE
	var certFH *multipart.FileHeader
	if req.Status == "nko" {
		certFH, err = c.FormFile("certificate")
		if err != nil || certFH.Size == 0 || certFH == nil {
			return fiber.NewError(fiber.StatusBadRequest, "certificate file required")
		}
	} else {
		certFH = nil
	}

	result, err := r.repository.Insert(c.Context(), userID, &models.Verification{
		UserID:   userID,
		Accepted: false,
		Status:   req.Status,
		Comment:  "",
	}, innFH, ruleFH, egruleFH, certFH)
	if err != nil {
		return fiber.NewError(fiber.StatusInternalServerError, err.Error())
	}

	err = r.telegram.SendVerification(result, false)
	if err != nil {
		return fiber.NewError(fiber.StatusInternalServerError, err.Error())
	}

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

func (r *VerificationController) SetVerificationStatus(c *fiber.Ctx) error {
	var req models.ReqSetVerification

	err := c.BodyParser(&req)
	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, err.Error())
	}

	errValidate := validateStruct(&req)
	if errValidate != nil {
		return c.Status(fiber.StatusBadRequest).JSON(errValidate)
	}

	_, err = r.repository.Update(c.Context(), &models.Verification{
		ID:       req.ID,
		Accepted: req.Accepted,
		Status:   req.Status,
		Comment:  req.Comment,
	})

	if err != nil {
		return fiber.NewError(fiber.StatusInternalServerError, err.Error())
	}

	return c.SendStatus(fiber.StatusOK)
}

func (r *VerificationController) SetVerificationFile(c *fiber.Ctx) error {
	userID := c.Params("userID")

	if userID == "" {
		userID = c.Locals("userID").(string)
		if userID == "" {
			return fiber.NewError(fiber.StatusUnauthorized)
		}
	}

	availableFiles := []string{"inn", "rule", "egrule", "certificate"}
	var err error
	var fileHeader *multipart.FileHeader
	var result *models.Verification

	for _, fileName := range availableFiles {
		fileHeader, err = c.FormFile(fileName)

		if errors.Is(err, fasthttp.ErrMissingFile) {
			continue
		}

		if err != nil {
			return fiber.NewError(fiber.StatusInternalServerError, err.Error())
		}

		result, err = r.repository.UpdateFile(c.Context(), userID, fileName, fileHeader)
		if err != nil {
			return fiber.NewError(fiber.StatusInternalServerError, err.Error())
		}
	}

	err = r.telegram.SendVerification(result, true)
	if err != nil {
		return fiber.NewError(fiber.StatusInternalServerError, err.Error())
	}

	return c.SendStatus(fiber.StatusOK)
}