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

server/internal/api/handler/user.go
639 строк27 KB
Maxim Malchevsky
чет там фиксанул уже не помню что
12 май 2025, 13:04
12 май 2025, 13:047a99e30
package handler

import (
	"bytes"
	"context"
	"encoding/json"
	"fmt"
	"io/ioutil"
	"net/http"
	"strings"
	"time"
	"vuzplus/internal/shared/entities"
	"vuzplus/internal/shared/log"
	"vuzplus/util"

	"github.com/gofiber/fiber/v2"
	"github.com/google/uuid"
)

// SignUp
// @Tags         Auth
// @Summary      Регистрация пользователя
// @Accept       json
// @Produce      json
// @Param        request body entities.CreateUserRequest true "Данные пользователя"
// @Success      200 {object} entities.CreateUserResponse "Пользователь успешно зарегистрирован"
// @Failure      400 {object} entities.Error "Некорректный запрос"
// @Failure      500 {object} entities.Error "Ошибка на стороне сервера"
// @Router       /sign-up [post]
func (h *Handler) SignUp(c *fiber.Ctx) error {
	var u entities.CreateUserRequest
	if err := c.BodyParser(&u); 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.DBUserExists")
	exists, err := h.repository.DB.DBUserExists(u.Email)
	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("user already exists")
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "user already exists"})
	}

	var user entities.User
	user.Email = u.Email
	user.PhoneNumber = u.PhoneNumber
	user.Course = u.Course
	user.GPA = u.GPA
	user.About = u.About

	if u.ProgramID != 0 {
		user.ProgramID = u.ProgramID
	}

	if u.UniversityID != 0 {
		user.UniversityID = u.UniversityID
	}

	fullName := strings.Split(u.FIO, " ")
	if len(fullName) < 2 || len(fullName) > 3 {
		logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Error", Method: c.Method(),
			Url: c.OriginalURL(), Status: fiber.StatusBadRequest})
		logEvent.Msg("invalid full name")
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "invalid full name"})
	}
	user.LastName = fullName[0]
	user.FirstName = fullName[1]

	if len(fullName) == 3 {
		user.MiddleName = fullName[2]
	}

	hashedPassword, err := util.HashPassword(u.Password)
	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()})
	}
	user.PasswordHash = hashedPassword

	h.logger.Debug().Msg("call h.repository.DB.DBCreateStudent")
	r, err := h.repository.DB.DBCreateStudent(&user)
	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()})
	}

	res := &entities.CreateUserResponse{
		ID: r.ID,
	}

	logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Info", Method: c.Method(),
		Url: c.OriginalURL(), Status: fiber.StatusOK})
	logEvent.Msg("success")
	return c.Status(fiber.StatusOK).JSON(res)

}

// SignUpDelegate
// @Tags         Auth
// @Summary      Регистрация представителя университета
// @Accept       json
// @Produce      json
// @Param        request body entities.CreateDelegateRequest true "Данные представителя"
// @Success      200 {object} entities.CreateUserResponse "Представитель успешно зарегистрирован"
// @Failure      400 {object} entities.Error "Некорректный запрос"
// @Failure      500 {object} entities.Error "Ошибка на стороне сервера"
// @Router       /sign-up/delegate [post]
func (h *Handler) SignUpDelegate(c *fiber.Ctx) error {
	var u entities.CreateDelegateRequest
	if err := c.BodyParser(&u); 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.DBUserExists")
	exists, err := h.repository.DB.DBUserExists(u.Email)
	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("user already exists")
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "user already exists"})
	}

	var user entities.User
	user.Email = u.Email
	user.PhoneNumber = u.PhoneNumber
	user.Role = "delegate"

	hashedPassword, err := util.HashPassword(u.Password)
	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()})
	}
	user.PasswordHash = hashedPassword

	fullName := strings.Split(u.FIO, " ")
	if len(fullName) < 2 || len(fullName) > 3 {
		logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Error", Method: c.Method(),
			Url: c.OriginalURL(), Status: fiber.StatusBadRequest})
		logEvent.Msg("invalid full name")
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "invalid full name"})
	}
	user.LastName = fullName[0]
	user.FirstName = fullName[1]

	if len(fullName) == 3 {
		user.MiddleName = fullName[2]
	}

	if u.UniversityID != 0 {
		user.UniversityID = u.UniversityID
	}

	h.logger.Debug().Msg("call h.repository.DB.DBCreateDelegate")
	r, err := h.repository.DB.DBCreateDelegate(&user)
	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()})
	}

	res := &entities.CreateUserResponse{
		ID: r.ID,
	}

	logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Info", Method: c.Method(),
		Url: c.OriginalURL(), Status: fiber.StatusOK})
	logEvent.Msg("success")
	return c.Status(fiber.StatusOK).JSON(res)

}

// Login
// @Tags         Auth
// @Summary      Аутентификация пользователя
// @Description  Вход пользователя в систему с выдачей токенов доступа и обновления
// @Accept       json
// @Produce      json
// @Param        request body entities.LoginUserRequest true "Данные для входа"
// @Success      200 {object} entities.LoginUserResponse "Успешная аутентификация"
// @Failure      400 {object} entities.Error "Некорректные данные для входа"
// @Failure      500 {object} entities.Error "Ошибка на стороне сервера"
// @Router       /login [post]
func (h *Handler) Login(c *fiber.Ctx) error {
	var user entities.LoginUserRequest
	if err := c.BodyParser(&user); 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.DBUserGetByEmail")
	u, err := h.repository.DB.DBUserGetByEmail(user.Email)
	if err != nil {
		logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Error", Method: c.Method(),
			Url: c.OriginalURL(), Status: fiber.StatusBadRequest})
		logEvent.Msg("wrong data")
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "wrong data"})
	}

	h.logger.Debug().Msg("call util.CheckPassword")
	err = util.CheckPassword(user.Password, u.PasswordHash)
	if err != nil {
		logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Error", Method: c.Method(),
			Url: c.OriginalURL(), Status: fiber.StatusBadRequest})
		logEvent.Msg("wrong data")
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "wrong data"})
	}

	TokenExpiration := 100
	h.logger.Debug().Msg("call pkg.GenerateAccessToken")
	accessToken, err := h.GenerateAccessToken(u.ID, TokenExpiration)
	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()})
	}

	h.logger.Debug().Msg("call pkg.GenerateRefreshToken")
	refreshToken, err := h.GenerateRefreshToken(u.ID)
	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()})
	}

	res := entities.LoginUserResponse{
		AccessToken:  accessToken,
		RefreshToken: refreshToken,
	}

	logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Info", Method: c.Method(),
		Url: c.OriginalURL(), Status: fiber.StatusOK})
	logEvent.Msg("success")
	return c.Status(fiber.StatusOK).JSON(res)
}

// GetProfileInfo
// @Tags         Profile
// @Summary      Получение информации о профиле
// @Description  Возвращает информацию о профиле пользователя
// @Accept       json
// @Produce      json
// @Success      200 {object} entities.UserInfo "Информация о пользователе"
// @Failure      400 {object} entities.Error "Ошибка в запросе"
// @Failure      403 {object} entities.Error "Недостаточно прав"
// @Failure      500 {object} entities.Error "Ошибка на стороне сервера"
// @Router       /auth/profile [get]
// @Security ApiKeyAuth
func (h *Handler) GetProfileInfo(c *fiber.Ctx) error {
	adminId, 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(adminId)
	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.DBGetUserInfo")
	userInfo, err := h.repository.DB.DBGetUserInfo(adminId, userStatus.Role)
	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()})
	}

	logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Info", Method: c.Method(),
		Url: c.OriginalURL(), Status: fiber.StatusOK})
	logEvent.Msg("success")
	return c.Status(fiber.StatusOK).JSON(userInfo)
}

// UpdateProfileInfo
// @Tags         Profile
// @Summary      Обновление информации профиля
// @Description  Обновляет данные профиля пользователя
// @Accept       json
// @Produce      json
// @Param        request body entities.UpdateUserInfoRequest true "Данные для обновления профиля"
// @Success      200 {object} entities.Response "Успешное обновление профиля"
// @Failure      400 {object} entities.Error "Ошибка в запросе"
// @Failure      403 {object} entities.Error "Недостаточно прав"
// @Failure      500 {object} entities.Error "Ошибка на стороне сервера"
// @Router       /auth/profile [put]
// @Security ApiKeyAuth
func (h *Handler) UpdateProfileInfo(c *fiber.Ctx) error {
	adminId, 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(adminId)
	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.UpdateUserInfoRequest
	if err := c.BodyParser(&req); 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 userInfo entities.UpdateUserInfo
	userInfo.ID = adminId
	userInfo.PhoneNumber = req.PhoneNumber

	if userStatus.Role == "student" {
		userInfo.GetNotifications = req.GetNotifications
		userInfo.ReadyForExchange = req.ReadyForExchange
		userInfo.About = req.About
	}

	h.logger.Debug().Msg("call h.repository.DB.DBUpdateProfileInfo")
	err = h.repository.DB.DBUpdateProfileInfo(&userInfo)
	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()})
	}

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

// UpdatePassword
// @Tags         Profile
// @Summary      Обновление пароля пользователя
// @Description  Позволяет пользователю изменить пароль, указав старый и новый пароль
// @Accept       json
// @Produce      json
// @Param        request body entities.UpdatePasswordRequest true "Данные для смены пароля"
// @Success      200 {object} entities.Response "Пароль успешно изменён"
// @Failure      400 {object} entities.Error "Ошибка в запросе или неправильный старый пароль"
// @Failure      500 {object} entities.Error "Ошибка на стороне сервера"
// @Router       /auth/profile/password [put]
// @Security ApiKeyAuth
func (h *Handler) UpdatePassword(c *fiber.Ctx) error {
	adminId, 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"})
	}

	var req entities.UpdatePasswordRequest
	if err := c.BodyParser(&req); 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.DBUserGetByEmail")
	u, err := h.repository.DB.DBUserGetById(adminId)
	if err != nil {
		logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Error", Method: c.Method(),
			Url: c.OriginalURL(), Status: fiber.StatusBadRequest})
		logEvent.Msg("wrong data")
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "wrong data"})
	}

	h.logger.Debug().Msg("call util.CheckPassword")
	err = util.CheckPassword(req.OldPassword, u.PasswordHash)
	if err != nil {
		logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Error", Method: c.Method(),
			Url: c.OriginalURL(), Status: fiber.StatusBadRequest})
		logEvent.Msg("old password is wrong")
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "old password is wrong"})
	}

	hashedPassword, err := util.HashPassword(req.NewPassword)
	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()})
	}

	updatePassword := &entities.UpdatePassword{
		ID:          u.ID,
		NewPassword: hashedPassword,
	}

	h.logger.Debug().Msg("call h.repository.DB.DBUpdateUserPassword")
	err = h.repository.DB.DBUpdateUserPassword(updatePassword)
	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("success")
	return c.Status(fiber.StatusOK).JSON(fiber.Map{"status": "success"})
}

// ConnectTelegram
// @Summary     Привязка Telegram аккаунта
// @Description Проверяет, привязан ли Telegram к пользователю. Если нет — отправляет запрос на привязку.
// @Tags        Profile
// @Accept      json
// @Produce     json
// @Success     200 {object} entities.RegisterTelegramResponse
// @Failure     400 {object} entities.Error "error: cant get id from token"
// @Failure     409 {object} entities.Error "error: telegram already verified"
// @Failure     500 {object} entities.Error "error: internal error"
// @Router      /auth/profile/telegram/connect [post]
// @Security    ApiKeyAuth
func (h *Handler) ConnectTelegram(c *fiber.Ctx) error {
	adminId, 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(adminId)
	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" {
		logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Error", Method: c.Method(),
			Url: c.OriginalURL(), Status: fiber.StatusBadRequest})
		logEvent.Msg("invalid role")
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "invalid role"})
	}

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

		logEvent.Msg("account is not verified")
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "account is not verified"})
	}

	h.logger.Debug().Msg("call h.repository.DB.DBIsTelegramVerified")
	flag, err := h.repository.DB.DBIsTelegramVerified(adminId)
	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.StatusInternalServerError).JSON(fiber.Map{"error": err.Error()})
	}
	if flag {
		logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Error", Method: c.Method(),
			Url: c.OriginalURL(), Status: fiber.StatusBadRequest})
		logEvent.Msg("telegram already verified")
		return c.Status(fiber.StatusConflict).JSON(fiber.Map{"error": "telegram already verified"})
	}

	uid := uuid.New()

	jsonData, err := json.Marshal(entities.TelegramServiceRegisterRequest{
		UserID: adminId,
		Token:  uid.String(),
	})
	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.StatusInternalServerError).JSON(fiber.Map{"error": err.Error()})
	}

	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()

	url := fmt.Sprintf("%s/register", h.conf.Application.TgBotService)
	fmt.Println(url)
	req, err := http.NewRequestWithContext(ctx, "POST", url, bytes.NewBuffer(jsonData))
	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.StatusInternalServerError).JSON(fiber.Map{"error": err.Error()})
	}

	req.Header.Set("Content-Type", "application/json")

	client := &http.Client{}
	resp, err := client.Do(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.StatusInternalServerError).JSON(fiber.Map{"error": err.Error()})
	}
	defer resp.Body.Close()

	body, err := ioutil.ReadAll(resp.Body)
	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.StatusInternalServerError).JSON(fiber.Map{"error": err.Error()})
	}

	if resp.StatusCode != http.StatusOK {
		var errResponse map[string]string
		if json.Unmarshal(body, &errResponse) == nil {
			logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Error", Method: c.Method(),
				Url: c.OriginalURL(), Status: fiber.StatusBadRequest})
			logEvent.Msg(fmt.Errorf("%s", errResponse["error"]).Error())
			return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{"error": errResponse["error"]})
		}
		logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Error", Method: c.Method(),
			Url: c.OriginalURL(), Status: fiber.StatusBadRequest})
		logEvent.Msg("unknown error from telegram service")
		return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{"error": "unknown error from telegram service"})
	}

	var registerResp entities.RegisterTelegramResponse
	if err := json.Unmarshal(body, &registerResp); 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.StatusInternalServerError).JSON(fiber.Map{"error": err.Error()})
	}

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

// GetStudentsByUniversityID
// @Tags         Profile
// @Summary      Получение всех студентов университета
// @Description  Возвращает всех студентов университета
// @Accept       json
// @Produce      json
// @Success      200 {object} []entities.User "Информация о пользователе"
// @Failure      400 {object} entities.Error "Ошибка в запросе"
// @Failure      403 {object} entities.Error "Недостаточно прав"
// @Failure      500 {object} entities.Error "Ошибка на стороне сервера"
// @Router       /auth/students [get]
// @Security ApiKeyAuth
func (h *Handler) GetStudentsByUniversityID(c *fiber.Ctx) error {
	adminId, 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(adminId)
	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(adminId)
	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.DBGetUserInfo")
	users, err := h.repository.DB.GetStudentsByUniversityID(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()})
	}

	logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Info", Method: c.Method(),
		Url: c.OriginalURL(), Status: fiber.StatusOK})
	logEvent.Msg("success")
	return c.Status(fiber.StatusOK).JSON(users)
}