server/internal/api/handler/application.go - master - gnomdeployer/VUZPlus

server/internal/api/handler/application.go
770 строк37 KB
maximmalchevsky
fix for stepik
13 май 2025, 13:01
13 май 2025, 13:01b083a19
package handler

import (
	"context"
	"fmt"
	"github.com/gofiber/fiber/v2"
	"os"
	"strconv"
	"time"
	"vuzplus/internal/shared/entities"
	"vuzplus/internal/shared/log"
	"vuzplus/util"
)

// CreateStudentProgramApplication
// @Tags         Application
// @Summary      Создание заявки на обмен по цифровой кафедре студентом
// @Description  Студент отправляет заявку на участие в обмене по цифровой кафедре в другой университет
// @Accept       json
// @Produce      json
// @Param        target_university_id query int true "ID целевого университета" example(2)
// @Param        program_id        query int true "ID цифровой кафедры" example(5)
// @Success      200 {object} entities.Response "ID созданной заявки"
// @Failure      400 {object} entities.Error "Ошибка в запросе или данные не получены"
// @Failure      403 {object} entities.Error "Недостаточно прав"
// @Failure      500 {object} entities.Error "Внутренняя ошибка сервера"
// @Router       /auth/application/student [post]
// @Security ApiKeyAuth
func (h *Handler) CreateStudentProgramApplication(c *fiber.Ctx) error {
	userID, ok := c.Locals("id").(int)
	if !ok {
		logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Error", Method: c.Method(),
			Url: c.OriginalURL(), Status: fiber.StatusBadRequest})
		logEvent.Msg("error: cant get id from token")
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "cant get id from token"})
	}

	h.logger.Debug().Msg("call h.repository.DB.DBGetRoleById")
	userStatus, err := h.repository.DB.DBGetRoleById(userID)
	if err != nil {
		logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Error", Method: c.Method(),
			Url: c.OriginalURL(), Status: fiber.StatusBadRequest})
		logEvent.Msg(err.Error())
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": err.Error()})
	}

	if userStatus.Role != "student" && userStatus.Status != "verified" {
		logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Error", Method: c.Method(), Url: c.OriginalURL(), Status: fiber.StatusForbidden})
		logEvent.Msg("there are not enough rights for this action")
		return c.Status(fiber.StatusForbidden).JSON(fiber.Map{"error": "there are not enough rights for this action"})
	}

	h.logger.Debug().Msg("call h.repository.DB.DBGetUniversityIdByUserId")
	universityID, err := h.repository.DB.DBGetUniversityIdByUserId(userID)
	if err != nil {
		logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Error", Method: c.Method(),
			Url: c.OriginalURL(), Status: fiber.StatusBadRequest})
		logEvent.Msg(err.Error())
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": err.Error()})
	}

	targetUniversityID := c.QueryInt("target_university_id")
	departmentID := c.QueryInt("program_id")

	var req entities.ProgramApplication
	req.StudentID = userID
	req.Type = "student"
	req.FromUniversityID = universityID
	req.TargetUniversityID = targetUniversityID
	req.ProgramID = departmentID
	req.Status = "sent"

	h.logger.Debug().Msg("call h.repository.DB.DBCreateDepartmentApplication")
	id, err := h.repository.DB.DBCreateProgramApplication(&req)
	if err != nil {
		logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Error", Method: c.Method(),
			Url: c.OriginalURL(), Status: fiber.StatusBadRequest})
		logEvent.Msg(err.Error())
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": err.Error()})
	}

	h.logger.Debug().Msg("call h.repository.DB.DBGetTelegramIDByUserID")
	strTgID, err := h.repository.DB.DBGetTelegramIDByUserID(userID)
	if err != nil {
		logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Error", Method: c.Method(),
			Url: c.OriginalURL(), Status: fiber.StatusBadRequest})
		logEvent.Msg(err.Error())
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": err.Error()})
	}

	tgID, _ := strconv.ParseInt(strTgID, 10, 64)

	h.logger.Debug().Msg("call h.repository.DB.DBGetUniversityByID")
	university, err := h.repository.DB.DBGetUniversityByID(universityID)
	if err != nil {
		logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Error", Method: c.Method(),
			Url: c.OriginalURL(), Status: fiber.StatusBadRequest})
		logEvent.Msg(err.Error())
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": err.Error()})
	}

	h.logger.Debug().Msg("call h.repository.DB.DBGetDigitalDepartmentByID")
	digitalDepartment, err := h.repository.DB.DBGetProgramByID(departmentID)
	if err != nil {
		logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Error", Method: c.Method(),
			Url: c.OriginalURL(), Status: fiber.StatusBadRequest})
		logEvent.Msg(err.Error())
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": err.Error()})
	}

	_, err = util.SendTgServiceMessage(entities.SendRequestToTelegramService{
		TelegramServiceRegisterHost: h.conf.Application.TgBotService,
		TelegramServiceSendRequest: entities.TelegramServiceSendRequest{
			TelegramUserID: tgID,
			Code:           "student_send_application",
			Payload:        []string{digitalDepartment.Name, university.Name},
		},
	})

	if err != nil {
		logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Error", Method: c.Method(),
			Url: c.OriginalURL(), Status: fiber.StatusBadRequest})
		logEvent.Msg(err.Error())

	}

	logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Info", Method: c.Method(), Url: c.OriginalURL(), Status: fiber.StatusOK})
	logEvent.Msg("successful creating student application")
	return c.Status(fiber.StatusOK).JSON(fiber.Map{"id": id})
}

// CreateByDelegateProgramApplication
// @Tags         Application
// @Summary      Создание заявки на обмен по цифровой кафедре представителем
// @Description  Представитель отправляет заявку с данными студента на участие в обмене по цифровой кафедре в другой университет
// @Accept       json
// @Produce      json
// @Param        req body entities.CreateByDelegateProgramApplicationReq true "Данные заявки"
// @Success      200 {object} entities.Response "ID созданной заявки"
// @Failure      400 {object} entities.Error "Ошибка в запросе или данные не получены"
// @Failure      403 {object} entities.Error "Недостаточно прав"
// @Failure      500 {object} entities.Error "Внутренняя ошибка сервера"
// @Router       /auth/application/delegate [post]
// @Security ApiKeyAuth
func (h *Handler) CreateByDelegateProgramApplication(c *fiber.Ctx) error {
	userID, ok := c.Locals("id").(int)
	if !ok {
		logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Error", Method: c.Method(),
			Url: c.OriginalURL(), Status: fiber.StatusBadRequest})
		logEvent.Msg("error: cant get id from token")
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "cant get id from token"})
	}

	h.logger.Debug().Msg("call h.repository.DB.DBGetRoleById")
	userStatus, err := h.repository.DB.DBGetRoleById(userID)
	if err != nil {
		logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Error", Method: c.Method(),
			Url: c.OriginalURL(), Status: fiber.StatusBadRequest})
		logEvent.Msg(err.Error())
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": err.Error()})
	}

	if userStatus.Role != "delegate" && userStatus.Status != "verified" {
		logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Error", Method: c.Method(), Url: c.OriginalURL(), Status: fiber.StatusForbidden})
		logEvent.Msg("there are not enough rights for this action")
		return c.Status(fiber.StatusForbidden).JSON(fiber.Map{"error": "there are not enough rights for this action"})
	}

	var d entities.CreateByDelegateProgramApplicationReq
	err = c.BodyParser(&d)
	if err != nil {
		logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Error", Method: c.Method(), Url: c.OriginalURL(), Status: fiber.StatusBadRequest})
		logEvent.Msg(err.Error())
		return c.Status(fiber.StatusBadRequest).JSON(entities.Error{Error: err.Error()})
	}

	h.logger.Debug().Msg("call h.repository.DB.DBGetUniversityIdByUserId")
	universityID, err := h.repository.DB.DBGetUniversityIdByUserId(userID)
	if err != nil {
		logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Error", Method: c.Method(),
			Url: c.OriginalURL(), Status: fiber.StatusBadRequest})
		logEvent.Msg(err.Error())
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": err.Error()})
	}

	var req entities.ProgramApplication
	req.StudentID = d.StudentID
	req.Type = "university"
	req.FromUniversityID = universityID
	req.TargetUniversityID = d.TargetUniversityID
	req.ProgramID = d.ProgramID
	req.Status = "sent"

	h.logger.Debug().Msg("call h.repository.DB.DBCreateDepartmentApplication")
	id, err := h.repository.DB.DBCreateProgramApplication(&req)
	if err != nil {
		logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Error", Method: c.Method(),
			Url: c.OriginalURL(), Status: fiber.StatusBadRequest})
		logEvent.Msg(err.Error())
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": err.Error()})
	}

	h.logger.Debug().Msg("call h.repository.DB.DBGetTelegramIDByUserID")
	strTgID, err := h.repository.DB.DBGetTelegramIDByUserID(d.StudentID)
	if err != nil {
		logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Error", Method: c.Method(),
			Url: c.OriginalURL(), Status: fiber.StatusBadRequest})
		logEvent.Msg(err.Error())
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": err.Error()})
	}

	tgID, _ := strconv.ParseInt(strTgID, 10, 64)

	h.logger.Debug().Msg("call h.repository.DB.DBGetUniversityByID")
	university, err := h.repository.DB.DBGetUniversityByID(universityID)
	if err != nil {
		logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Error", Method: c.Method(),
			Url: c.OriginalURL(), Status: fiber.StatusBadRequest})
		logEvent.Msg(err.Error())
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": err.Error()})
	}

	h.logger.Debug().Msg("call h.repository.DB.DBGetDigitalDepartmentByID")
	digitalDepartment, err := h.repository.DB.DBGetProgramByID(d.ProgramID)
	if err != nil {
		logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Error", Method: c.Method(),
			Url: c.OriginalURL(), Status: fiber.StatusBadRequest})
		logEvent.Msg(err.Error())
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": err.Error()})
	}

	_, err = util.SendTgServiceMessage(entities.SendRequestToTelegramService{
		TelegramServiceRegisterHost: h.conf.Application.TgBotService,
		TelegramServiceSendRequest: entities.TelegramServiceSendRequest{
			TelegramUserID: tgID,
			Code:           "university_send_application",
			Payload:        []string{digitalDepartment.Name, university.Name},
		},
	})

	if err != nil {
		logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Error", Method: c.Method(),
			Url: c.OriginalURL(), Status: fiber.StatusBadRequest})
		logEvent.Msg(err.Error())

	}

	logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Info", Method: c.Method(), Url: c.OriginalURL(), Status: fiber.StatusOK})
	logEvent.Msg("successful creating student application by delegate")
	return c.Status(fiber.StatusOK).JSON(fiber.Map{"id": id})
}

// GetStudentOutgoingApplications
// @Tags         Application
// @Summary      Получение исходящих заявок студента
// @Description  Возвращает список заявок на обмен, отправленных студентом (по направлениям и цифровым кафедрам)
// @Accept       json
// @Produce      json
// @Success      200 {object} []entities.ProgramApplication "Список исходящих заявок студента"
// @Failure      400 {object} entities.Error "Ошибка в запросе или данные не получены"
// @Failure      403 {object} entities.Error "Недостаточно прав"
// @Failure      500 {object} entities.Error "Внутренняя ошибка сервера"
// @Router       /auth/application/outgoing/student [get]
// @Security ApiKeyAuth
func (h *Handler) GetStudentOutgoingApplications(c *fiber.Ctx) error {
	userID, ok := c.Locals("id").(int)
	if !ok {
		logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Error", Method: c.Method(),
			Url: c.OriginalURL(), Status: fiber.StatusBadRequest})
		logEvent.Msg("error: cant get id from token")
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "cant get id from token"})
	}

	h.logger.Debug().Msg("call h.repository.DB.DBGetRoleById")
	userStatus, err := h.repository.DB.DBGetRoleById(userID)
	if err != nil {
		logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Error", Method: c.Method(),
			Url: c.OriginalURL(), Status: fiber.StatusBadRequest})
		logEvent.Msg(err.Error())
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": err.Error()})
	}

	if userStatus.Role != "student" && userStatus.Status != "verified" {
		logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Error", Method: c.Method(), Url: c.OriginalURL(), Status: fiber.StatusForbidden})
		logEvent.Msg("there are not enough rights for this action")
		return c.Status(fiber.StatusForbidden).JSON(fiber.Map{"error": "there are not enough rights for this action"})
	}

	h.logger.Debug().Msg("call h.repository.DB.DBGetUniversityIdByUserId")
	universityID, err := h.repository.DB.DBGetUniversityIdByUserId(userID)
	if err != nil {
		logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Error", Method: c.Method(),
			Url: c.OriginalURL(), Status: fiber.StatusBadRequest})
		logEvent.Msg(err.Error())
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": err.Error()})
	}

	h.logger.Debug().Msg("call h.repository.DB.DBGetStudentDepartmentApplications")
	dd, err := h.repository.DB.DBGetStudentProgramApplications(userID, universityID, "student")
	if err != nil {
		logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Error", Method: c.Method(),
			Url: c.OriginalURL(), Status: fiber.StatusBadRequest})
		logEvent.Msg(err.Error())
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": err.Error()})
	}

	for i := range *dd {
		url, _ := h.repository.S3.PresignedGetObject(context.Background(), "university-media", (*dd)[i].UniversityLogo, 7*24*time.Hour)
		if url != nil {
			(*dd)[i].UniversityLogo = url.String()
		}
	}

	logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Info", Method: c.Method(), Url: c.OriginalURL(), Status: fiber.StatusOK})
	logEvent.Msg("successful getting student outgoing application")
	return c.Status(fiber.StatusOK).JSON(dd)
}

// GetStudentIngoingApplications
// @Tags         Application
// @Summary      Получение входящих заявок студента
// @Description  Возвращает список заявок на обмен, отправленных студенту (по направлениям и цифровым кафедрам)
// @Accept       json
// @Produce      json
// @Success      200 {object} []entities.ProgramApplicationWithLogo "Список входящих заявок студента"
// @Failure      400 {object} entities.Error "Ошибка в запросе или данные не получены"
// @Failure      403 {object} entities.Error "Недостаточно прав"
// @Failure      500 {object} entities.Error "Внутренняя ошибка сервера"
// @Router       /auth/application/ingoing/student [get]
// @Security ApiKeyAuth
func (h *Handler) GetStudentIngoingApplications(c *fiber.Ctx) error {
	userID, ok := c.Locals("id").(int)
	if !ok {
		logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Error", Method: c.Method(),
			Url: c.OriginalURL(), Status: fiber.StatusBadRequest})
		logEvent.Msg("error: cant get id from token")
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "cant get id from token"})
	}

	h.logger.Debug().Msg("call h.repository.DB.DBGetRoleById")
	userStatus, err := h.repository.DB.DBGetRoleById(userID)
	if err != nil {
		logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Error", Method: c.Method(),
			Url: c.OriginalURL(), Status: fiber.StatusBadRequest})
		logEvent.Msg(err.Error())
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": err.Error()})
	}

	if userStatus.Role != "student" && userStatus.Status != "verified" {
		logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Error", Method: c.Method(), Url: c.OriginalURL(), Status: fiber.StatusForbidden})
		logEvent.Msg("there are not enough rights for this action")
		return c.Status(fiber.StatusForbidden).JSON(fiber.Map{"error": "there are not enough rights for this action"})
	}

	h.logger.Debug().Msg("call h.repository.DB.DBGetUniversityIdByUserId")
	universityID, err := h.repository.DB.DBGetUniversityIdByUserId(userID)
	if err != nil {
		logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Error", Method: c.Method(),
			Url: c.OriginalURL(), Status: fiber.StatusBadRequest})
		logEvent.Msg(err.Error())
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": err.Error()})
	}

	h.logger.Debug().Msg("call h.repository.DB.DBGetStudentDepartmentApplications")
	dd, err := h.repository.DB.DBGetStudentProgramApplications(userID, universityID, "university")
	if err != nil {
		logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Error", Method: c.Method(),
			Url: c.OriginalURL(), Status: fiber.StatusBadRequest})
		logEvent.Msg(err.Error())
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": err.Error()})
	}

	for i := range *dd {
		url, _ := h.repository.S3.PresignedGetObject(context.Background(), "university-media", (*dd)[i].UniversityLogo, 7*24*time.Hour)
		if url != nil {
			(*dd)[i].UniversityLogo = url.String()
		}
	}

	logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Info", Method: c.Method(), Url: c.OriginalURL(), Status: fiber.StatusOK})
	logEvent.Msg("successful getting student ingoing application")
	return c.Status(fiber.StatusOK).JSON(dd)
}

// GetUniversityOutgoingApplications
// @Tags         Application
// @Summary      Получение исходящих заявок вуза
// @Description  Возвращает список заявок на обмен, отправленных представителями вуза (по направлениям и цифровым кафедрам)
// @Accept       json
// @Produce      json
// @Success      200 {object} []entities.ProgramApplication "Список исходящих заявок студента"
// @Failure      400 {object} entities.Error "Ошибка в запросе или данные не получены"
// @Failure      403 {object} entities.Error "Недостаточно прав"
// @Failure      500 {object} entities.Error "Внутренняя ошибка сервера"
// @Router       /auth/application/outgoing/university [get]
// @Security ApiKeyAuth
func (h *Handler) GetUniversityOutgoingApplications(c *fiber.Ctx) error {
	userID, ok := c.Locals("id").(int)
	if !ok {
		logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Error", Method: c.Method(),
			Url: c.OriginalURL(), Status: fiber.StatusBadRequest})
		logEvent.Msg("error: cant get id from token")
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "cant get id from token"})
	}

	h.logger.Debug().Msg("call h.repository.DB.DBGetRoleById")
	userStatus, err := h.repository.DB.DBGetRoleById(userID)
	if err != nil {
		logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Error", Method: c.Method(),
			Url: c.OriginalURL(), Status: fiber.StatusBadRequest})
		logEvent.Msg(err.Error())
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": err.Error()})
	}

	if userStatus.Role != "delegate" && userStatus.Status != "verified" {
		logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Error", Method: c.Method(), Url: c.OriginalURL(), Status: fiber.StatusForbidden})
		logEvent.Msg("there are not enough rights for this action")
		return c.Status(fiber.StatusForbidden).JSON(fiber.Map{"error": "there are not enough rights for this action"})
	}

	h.logger.Debug().Msg("call h.repository.DB.DBGetUniversityIdByUserId")
	universityID, err := h.repository.DB.DBGetUniversityIdByUserId(userID)
	if err != nil {
		logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Error", Method: c.Method(),
			Url: c.OriginalURL(), Status: fiber.StatusBadRequest})
		logEvent.Msg(err.Error())
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": err.Error()})
	}

	h.logger.Debug().Msg("call h.repository.DB.DBGetUniversityDepartmentApplicationsOutgoing")
	dd, err := h.repository.DB.DBGetUniversityProgramApplicationsOutgoing(universityID)
	if err != nil {
		logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Error", Method: c.Method(),
			Url: c.OriginalURL(), Status: fiber.StatusBadRequest})
		logEvent.Msg(err.Error())
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": err.Error()})
	}

	for i := range *dd {
		url, _ := h.repository.S3.PresignedGetObject(context.Background(), "university-media", (*dd)[i].UniversityLogo, 7*24*time.Hour)
		if url != nil {
			(*dd)[i].UniversityLogo = url.String()
		}
	}

	logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Info", Method: c.Method(), Url: c.OriginalURL(), Status: fiber.StatusOK})
	logEvent.Msg("successful getting university outgoing application")
	return c.Status(fiber.StatusOK).JSON(dd)
}

// GetUniversityIngoingApplications
// @Tags         Application
// @Summary      Получение входящих заявок вуза
// @Description  Возвращает список заявок на обмен, отправленных вузу (по направлениям и цифровым кафедрам)
// @Accept       json
// @Produce      json
// @Success      200 {object} []entities.ProgramApplicationWithLogo "Список входящих заявок студента"
// @Failure      400 {object} entities.Error "Ошибка в запросе или данные не получены"
// @Failure      403 {object} entities.Error "Недостаточно прав"
// @Failure      500 {object} entities.Error "Внутренняя ошибка сервера"
// @Router       /auth/application/ingoing/university [get]
// @Security ApiKeyAuth
func (h *Handler) GetUniversityIngoingApplications(c *fiber.Ctx) error {
	userID, ok := c.Locals("id").(int)
	if !ok {
		logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Error", Method: c.Method(),
			Url: c.OriginalURL(), Status: fiber.StatusBadRequest})
		logEvent.Msg("error: cant get id from token")
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "cant get id from token"})
	}

	h.logger.Debug().Msg("call h.repository.DB.DBGetRoleById")
	userStatus, err := h.repository.DB.DBGetRoleById(userID)
	if err != nil {
		logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Error", Method: c.Method(),
			Url: c.OriginalURL(), Status: fiber.StatusBadRequest})
		logEvent.Msg(err.Error())
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": err.Error()})
	}

	if userStatus.Role != "delegate" && userStatus.Status != "verified" {
		logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Error", Method: c.Method(), Url: c.OriginalURL(), Status: fiber.StatusForbidden})
		logEvent.Msg("there are not enough rights for this action")
		return c.Status(fiber.StatusForbidden).JSON(fiber.Map{"error": "there are not enough rights for this action"})
	}

	h.logger.Debug().Msg("call h.repository.DB.DBGetUniversityIdByUserId")
	universityID, err := h.repository.DB.DBGetUniversityIdByUserId(userID)
	if err != nil {
		logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Error", Method: c.Method(),
			Url: c.OriginalURL(), Status: fiber.StatusBadRequest})
		logEvent.Msg(err.Error())
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": err.Error()})
	}

	h.logger.Debug().Msg("call h.repository.DB.DBGetUniversityDepartmentApplicationsIngoing")
	dd, err := h.repository.DB.DBGetUniversityProgramApplicationsIngoing(universityID)
	if err != nil {
		logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Error", Method: c.Method(),
			Url: c.OriginalURL(), Status: fiber.StatusBadRequest})
		logEvent.Msg(err.Error())
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": err.Error()})
	}

	for i := range *dd {
		url, _ := h.repository.S3.PresignedGetObject(context.Background(), "university-media", (*dd)[i].UniversityLogo, 7*24*time.Hour)
		if url != nil {
			(*dd)[i].UniversityLogo = url.String()
		}
	}

	logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Info", Method: c.Method(), Url: c.OriginalURL(), Status: fiber.StatusOK})
	logEvent.Msg("successful getting university ingoing application")
	return c.Status(fiber.StatusOK).JSON(dd)
}

// UploadStudentDocuments
// @Tags         Application
// @Summary      Загрузка документов для заявки
// @Description  Представитель или администратор загружает документы к заявке студента
// @Accept       multipart/form-data
// @Produce      json
// @Param        application_id query    int                      true  "ID заявки"
// @Param        file_name      formData []file                   true  "Документы (можно несколько)"
// @Success      200            {object} entities.Response        "ID загруженной записи"
// @Failure      400            {object} entities.Error           "Ошибка запроса / неверные данные"
// @Failure      403            {object} entities.Error           "Недостаточно прав"
// @Failure      500            {object} entities.Error           "Внутренняя ошибка сервера"
// @Router       /auth/application/documents [post]
// @Security ApiKeyAuth
func (h *Handler) UploadStudentDocuments(c *fiber.Ctx) error {
	userID, ok := c.Locals("id").(int)
	if !ok {
		logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Error", Method: c.Method(),
			Url: c.OriginalURL(), Status: fiber.StatusBadRequest})
		logEvent.Msg("error: cant get id from token")
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "cant get id from token"})
	}

	h.logger.Debug().Msg("call h.repository.DB.DBGetRoleById")
	userStatus, err := h.repository.DB.DBGetRoleById(userID)
	if err != nil {
		logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Error", Method: c.Method(),
			Url: c.OriginalURL(), Status: fiber.StatusInternalServerError})
		logEvent.Msg(err.Error())
		return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{"error": err.Error()})
	}

	if (userStatus.Role != "delegate" && userStatus.Role != "admin") || userStatus.Status != "verified" {
		logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Error", Method: c.Method(),
			Url: c.OriginalURL(), Status: fiber.StatusForbidden})
		logEvent.Msg("error: not enough rights for this action")
		return c.Status(fiber.StatusForbidden).JSON(fiber.Map{"error": "not enough rights for this action"})
	}

	applicationID := c.QueryInt("application_id")

	exists, err := h.repository.DB.DBCheckApplicationExists(applicationID)
	if err != nil {
		logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Error", Method: c.Method(),
			Url: c.OriginalURL(), Status: fiber.StatusInternalServerError})
		logEvent.Msg(err.Error())
		return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{"error": err.Error()})
	}

	if !exists {
		logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Error", Method: c.Method(),
			Url: c.OriginalURL(), Status: fiber.StatusBadRequest})
		logEvent.Msg("application not found")
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "application not found"})
	}

	var req entities.ApplicationDocuments
	req.ApplicationID = applicationID

	form, err := c.MultipartForm()
	if err != nil {
		logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Error", Method: c.Method(), Url: c.OriginalURL(), Status: fiber.StatusBadRequest})
		logEvent.Msg(err.Error())
		return c.Status(fiber.StatusBadRequest).JSON(entities.Error{Error: err.Error()})
	}

	files := form.File["file_name"]
	for _, file := range files {
		req.FileName = append(req.FileName, file.Filename)
		filePath := fmt.Sprintf("./tmp/%s", file.Filename)
		c.SaveFile(file, filePath)
		err = h.repository.S3.FPutObject(context.Background(), "application-media", file.Filename, filePath, file.Header.Get("Content-Type"))
		if err != nil {
			logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Error", Method: c.Method(), Url: c.OriginalURL(), Status: fiber.StatusBadRequest})
			logEvent.Msg(fmt.Sprintf("error creating file %s in minio: %s", file.Filename, err.Error()))
			return c.Status(fiber.StatusBadRequest).JSON(entities.Error{Error: fmt.Sprintf("error creating file %s in minio: %s", file.Filename, err.Error())})
		}
		err = os.Remove(filePath)
		if err != nil {
			logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Error", Method: c.Method(), Url: c.OriginalURL(), Status: fiber.StatusBadRequest})
			logEvent.Msg(fmt.Sprintf("error removing file %s: %s", file.Filename, err.Error()))
			return c.Status(fiber.StatusBadRequest).JSON(entities.Error{Error: fmt.Sprintf("error removing file %s: %s", file.Filename, err.Error())})
		}
	}

	id, err := h.repository.DB.DBCreateApplicationDocuments(&req)
	if err != nil {
		logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Error", Method: c.Method(),
			Url: c.OriginalURL(), Status: fiber.StatusInternalServerError})
		logEvent.Msg(err.Error())
		return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{"error": err.Error()})
	}

	logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Info", Method: c.Method(), Url: c.OriginalURL(), Status: fiber.StatusOK})
	logEvent.Msg("successful uploading application documents")
	return c.Status(fiber.StatusOK).JSON(fiber.Map{"id": id})
}

// UpdateApplicationStatus
// @Tags         Application
// @Summary      Обновить статус заявки
// @Description  Представитель или администратор может обновить статус заявки студента
// @Accept       json
// @Produce      json
// @Param        application_id query     int     true  "ID заявки"
// @Param        status         query     string  true  "Новый статус (rejected, approved, vuz data required, student data required, student data received)"
// @Success      200            {object}  entities.Response        "Сообщение об успешном обновлении"
// @Failure      400            {object}  entities.Error           "Ошибка запроса / неверные данные"
// @Failure      403            {object}  entities.Error           "Недостаточно прав"
// @Failure      500            {object}  entities.Error           "Внутренняя ошибка сервера"
// @Router       /auth/application/status [put]
// @Security ApiKeyAuth
func (h *Handler) UpdateApplicationStatus(c *fiber.Ctx) error {
	userID, ok := c.Locals("id").(int)
	if !ok {
		logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Error", Method: c.Method(),
			Url: c.OriginalURL(), Status: fiber.StatusBadRequest})
		logEvent.Msg("error: cant get id from token")
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "cant get id from token"})
	}

	h.logger.Debug().Msg("call h.repository.DB.DBGetRoleById")
	userStatus, err := h.repository.DB.DBGetRoleById(userID)
	if err != nil {
		logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Error", Method: c.Method(),
			Url: c.OriginalURL(), Status: fiber.StatusInternalServerError})
		logEvent.Msg(err.Error())
		return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{"error": err.Error()})
	}

	if (userStatus.Role != "delegate" && userStatus.Role != "admin") || userStatus.Status != "verified" {
		logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Error", Method: c.Method(),
			Url: c.OriginalURL(), Status: fiber.StatusForbidden})
		logEvent.Msg("error: not enough rights for this action")
		return c.Status(fiber.StatusForbidden).JSON(fiber.Map{"error": "not enough rights for this action"})
	}

	applicationID := c.QueryInt("application_id")
	status := c.Query("status")

	if status != "rejected" && status != "approved" && status != "vuz data required" && status != "student data required" && status != "student data received" {
		logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Error", Method: c.Method(),
			Url: c.OriginalURL(), Status: fiber.StatusBadRequest})
		logEvent.Msg("error: invalid status")
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "invalid status"})
	}

	err = h.repository.DB.DBUpdateApplicationStatus(applicationID, status)
	if err != nil {
		logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Error", Method: c.Method(),
			Url: c.OriginalURL(), Status: fiber.StatusInternalServerError})
		logEvent.Msg(err.Error())
		return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{"error": err.Error()})
	}

	code := ""

	if status == "rejected" {
		code = "application_reject"
	} else if code == "approved" {
		code = "application_approve"
	} else if code == "vuz data required" {
		code = "data_waiting_university"
	} else if code == "student data required" {
		code = "data_waiting_student"
	}

	if code != "" {
		h.logger.Debug().Msg("call h.repository.DB.DBGetDigitalDepartmentByID")
		details, err := h.repository.DB.DBGetApplicationDetails(applicationID)
		if err != nil {
			logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Error", Method: c.Method(),
				Url: c.OriginalURL(), Status: fiber.StatusBadRequest})
			logEvent.Msg(err.Error())
			return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": err.Error()})
		}

		payload := details.ProgramName

		h.logger.Debug().Msg("call h.repository.DB.DBGetTelegramIDByUserID")
		strTgID, err := h.repository.DB.DBGetTelegramIDByUserID(details.StudentID)
		if err != nil {
			logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Error", Method: c.Method(),
				Url: c.OriginalURL(), Status: fiber.StatusBadRequest})
			logEvent.Msg(err.Error())
			return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": err.Error()})
		}

		tgID, _ := strconv.ParseInt(strTgID, 10, 64)

		_, err = util.SendTgServiceMessage(entities.SendRequestToTelegramService{
			TelegramServiceRegisterHost: h.conf.Application.TgBotService,
			TelegramServiceSendRequest: entities.TelegramServiceSendRequest{
				TelegramUserID: tgID,
				Code:           code,
				Payload:        []string{details.UniversityName, payload},
			},
		})

		if err != nil {
			logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Error", Method: c.Method(),
				Url: c.OriginalURL(), Status: fiber.StatusBadRequest})
			logEvent.Msg(err.Error())
		}
	}

	logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Info", Method: c.Method(), Url: c.OriginalURL(), Status: fiber.StatusOK})
	logEvent.Msgf("status of application with id = %v successfully updated", applicationID)
	return c.Status(fiber.StatusOK).JSON(fiber.Map{"message": fmt.Sprintf("status of application with id = %v successfully updated", applicationID)})
}

// CheckUserParticipation
// @Tags         Program
// @Summary      Проверить участие пользователя в программе
// @Description  Подтверждённый студент может проверить, добавлен ли он в указанную образовательную программу
// @Accept       json
// @Produce      json
// @Param        program_id  query     int     true  "ID программы"
// @Success      200         {object}  entities.Response  "Статус проверки: ok"
// @Failure      400         {object}  entities.Error     "Ошибка запроса / неверные данные"
// @Failure      403         {object}  entities.Error     "Недостаточно прав"
// @Failure      500         {object}  entities.Error     "Внутренняя ошибка сервера"
// @Router       /auth/program/participation [get]
// @Security     ApiKeyAuth
func (h *Handler) CheckUserParticipation(c *fiber.Ctx) error {
	userId := c.Locals("id").(int)
	uStatus, err := h.repository.DB.DBGetRoleById(userId)
	if err != nil {
		logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Error", Method: c.Method(), Url: c.OriginalURL(), Status: fiber.StatusBadRequest})
		logEvent.Msg(fmt.Sprintf("error getting user role: %s", err.Error()))
		return c.Status(fiber.StatusBadRequest).JSON(entities.Error{Error: fmt.Sprintf("error getting user role: %s", err.Error())})
	}
	if uStatus.Role == "student" && uStatus.Status == "verified" {
		programID := c.QueryInt("program_id")
		h.logger.Debug().Msg("calling h.repository.DB.DBCheckUserParticipation")
		ok, err := h.repository.DB.DBCheckUserParticipation(userId, programID)
		if err != nil {
			logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Error", Method: c.Method(),
				Url: c.OriginalURL(), Status: fiber.StatusBadRequest})
			logEvent.Msg(err.Error())
		}

		if !ok {
			return c.Status(fiber.StatusOK).JSON(fiber.Map{"status": "false"})
		}

		return c.Status(fiber.StatusOK).JSON(fiber.Map{"status": "true"})

	}

	logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Error", Method: c.Method(), Url: c.OriginalURL(), Status: fiber.StatusForbidden})
	logEvent.Msg("there are not enough rights for this action")
	return c.Status(fiber.StatusForbidden).JSON(entities.Error{Error: "there are not enough rights for this action"})
}