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

server/internal/api/handler/analytics.go
395 строк21 KB
Gewinn
Добавлена аналитика в docx
18 май 2025, 13:26
18 май 2025, 13:26231652f
package handler

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

// GetSemesterAveragesDirection
// @Tags         Analytics
// @Summary      Получение средних баллов по семестрам для дисциплины
// @Accept json
// @Produce      json
// @Param id path int true "ID направления" example(1)
// @Success      200 {object} []entities.SemesterAverage "Аналитика получены"
// @Failure      400 {object} entities.Error "Некорректный запрос"
// @Failure      401 {object} entities.Error "Пользователь не авторизован"
// @Failure      403 {object} entities.Error "Недостаточно прав для запроса"
// @Failure      500 {object} entities.Error "Ошибка на стороне сервера"
// @Router       /auth/analytics/semester/averages/{id} [get]
// @Security ApiKeyAuth
func (h *Handler) GetSemesterAveragesDirection(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 == "delegate" || uStatus.Role == "admin") && uStatus.Status == "verified" {
		id, err := c.ParamsInt("id")
		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("calling h.repository.DB.GetSemesterAveragesDirection")
		semesterAverages, err := h.repository.DB.GetSemesterAveragesDirection(id)
		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 discipline: %s", err.Error()))
			return c.Status(fiber.StatusBadRequest).JSON(entities.Error{Error: fmt.Sprintf("error creating discipline: %s", err.Error())})
		}

		logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Info", Method: c.Method(), Url: c.OriginalURL(), Status: fiber.StatusOK})
		logEvent.Msg("successful getting semester average discipline")
		return c.Status(fiber.StatusOK).JSON(semesterAverages)
	}

	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"})
}

// GetSemesterAveragesUniversity
// @Tags         Analytics
// @Summary      Получение средних баллов по семестрам для университета
// @Accept json
// @Produce      json
// @Param id path int true "ID университета" example(1)
// @Success      200 {object} []entities.SemesterAverage "Аналитика получены"
// @Failure      400 {object} entities.Error "Некорректный запрос"
// @Failure      401 {object} entities.Error "Пользователь не авторизован"
// @Failure      403 {object} entities.Error "Недостаточно прав для запроса"
// @Failure      500 {object} entities.Error "Ошибка на стороне сервера"
// @Router       /auth/analytics/semester/averages/university/{id} [get]
// @Security ApiKeyAuth
func (h *Handler) GetSemesterAveragesUniversity(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 == "delegate" || uStatus.Role == "admin") && uStatus.Status == "verified" {
		id, err := c.ParamsInt("id")
		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("calling h.repository.DB.GetSemesterAveragesUniversity")
		semesterAverages, err := h.repository.DB.GetSemesterAveragesUniversity(id)
		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 discipline: %s", err.Error()))
			return c.Status(fiber.StatusBadRequest).JSON(entities.Error{Error: fmt.Sprintf("error creating discipline: %s", err.Error())})
		}

		logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Info", Method: c.Method(), Url: c.OriginalURL(), Status: fiber.StatusOK})
		logEvent.Msg("successful getting semester average discipline")
		return c.Status(fiber.StatusOK).JSON(semesterAverages)
	}

	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"})
}

// GetUniversityAnalyticsJSON
// @Tags         Analytics
// @Summary      Получение аналтики по университету в json
// @Accept json
// @Produce      json
// @Success      200 {object} entities.UniversityAnalytics "Аналитика получена"
// @Failure      400 {object} entities.Error "Некорректный запрос"
// @Failure      401 {object} entities.Error "Пользователь не авторизован"
// @Failure      403 {object} entities.Error "Недостаточно прав для запроса"
// @Failure      500 {object} entities.Error "Ошибка на стороне сервера"
// @Router       /auth/analytics/university/json [get]
// @Security ApiKeyAuth
func (h *Handler) GetUniversityAnalyticsJSON(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 == "delegate" || uStatus.Role == "admin") && uStatus.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(entities.Error{Error: "there are not enough rights for this action"})
	}

	uID, 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(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())})
	}

	h.logger.Debug().Msg("calling h.getUniversityAnalytics")
	universityAnalytics, err := h.getUniversityAnalytics(uID)
	if err != nil {
		logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Error", Method: c.Method(), Url: c.OriginalURL(), Status: fiber.StatusInternalServerError})
		logEvent.Msg(fmt.Sprintf("error getting university analytics: %s", err.Error()))
		return c.Status(fiber.StatusInternalServerError).JSON(entities.Error{Error: fmt.Sprintf("error getting university analytics: %s", err.Error())})
	}

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

	return nil
}

// GetUniversityAnalyticsFile
// @Tags         Analytics
// @Summary      Получение аналтики по университету в файле
// @Accept json
// @Produce      octet-stream
// @Param        ext path string true "Расширение файла (docx, csv)" Enums(docx, csv) example(docx)
// @Success      200 {file}   byte    "Файл с аналитикой"
// @Success      200 {object} entities.UniversityAnalytics "Аналитика получена"
// @Failure      400 {object} entities.Error "Некорректный запрос"
// @Failure      401 {object} entities.Error "Пользователь не авторизован"
// @Failure      403 {object} entities.Error "Недостаточно прав для запроса"
// @Failure      500 {object} entities.Error "Ошибка на стороне сервера"
// @Router       /auth/analytics/university/file/{ext} [get]
// @Security ApiKeyAuth
func (h *Handler) GetUniversityAnalyticsFile(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 == "delegate" || uStatus.Role == "admin") && uStatus.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(entities.Error{Error: "there are not enough rights for this action"})
	}

	responseType := c.Params("ext")
	if !(responseType == "docx" || responseType == "csv") {
		logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Error", Method: c.Method(), Url: c.OriginalURL(), Status: fiber.StatusBadRequest})
		logEvent.Msg("invalid field 'type'")
		return c.Status(fiber.StatusBadRequest).JSON(entities.Error{Error: "invalid field 'type'"})
	}

	uID, 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(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())})
	}

	h.logger.Debug().Msg("calling h.getUniversityAnalytics")
	universityAnalytics, err := h.getUniversityAnalytics(uID)
	if err != nil {
		logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Error", Method: c.Method(), Url: c.OriginalURL(), Status: fiber.StatusInternalServerError})
		logEvent.Msg(fmt.Sprintf("error getting university analytics: %s", err.Error()))
		return c.Status(fiber.StatusInternalServerError).JSON(entities.Error{Error: fmt.Sprintf("error getting university analytics: %s", err.Error())})
	}

	filepath := "tmp/"

	if responseType == "csv" {
		filepath += "university_analytics.csv"
		err = util.SaveUniversityAnalyticsToCSV(*universityAnalytics, filepath)
		if err != nil {
			logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Error", Method: c.Method(), Url: c.OriginalURL(), Status: fiber.StatusInternalServerError})
			logEvent.Msg(fmt.Sprintf("error creating university_analytics.csv: %s", err.Error()))
			return c.Status(fiber.StatusInternalServerError).JSON(entities.Error{Error: fmt.Sprintf("error creating university_analytics.csv: %s", err.Error())})
		}

		c.Set("Content-Type", "text/csv")
		c.Set("Content-Disposition", "attachment; filename=university_analytics.csv")

		logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Info", Method: c.Method(), Url: c.OriginalURL(), Status: fiber.StatusOK})
		logEvent.Msg("successful getting university analytics")
	} else if responseType == "docx" {
		filepath += "university_analytics.docx"
		err = util.SaveUniversityAnalyticsToDOCX(*universityAnalytics, filepath)
		if err != nil {
			logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Error", Method: c.Method(), Url: c.OriginalURL(), Status: fiber.StatusInternalServerError})
			logEvent.Msg(fmt.Sprintf("error creating university_analytics.docx: %s", err.Error()))
			return c.Status(fiber.StatusInternalServerError).JSON(entities.Error{Error: fmt.Sprintf("error creating university_analytics.docx: %s", err.Error())})
		}

		c.Set("Content-Type", "application/vnd.openxmlformats-officedocument.wordprocessingml.document")
		c.Set("Content-Disposition", "attachment; filename=university_analytics.docx")

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

	err = c.SendFile(filepath)
	if err != nil {
		logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Info", Method: c.Method(), Url: c.OriginalURL(), Status: fiber.StatusOK})
		logEvent.Msg(fmt.Sprintf("error sending file with university analytics: %s", err.Error()))
		return c.Status(fiber.StatusInternalServerError).SendString(fmt.Sprintf("error sending file with university analytics: %s", err.Error()))
	}

	if f, err := os.Open(filepath); err == nil {
		f.Close()
	}

	defer func() {
		err = os.Remove(filepath)
		if err != nil {
			logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Info", Method: c.Method(), Url: c.OriginalURL(), Status: fiber.StatusOK})
			logEvent.Msg(fmt.Sprintf("error deleting file with university analytics: %s", err.Error()))
		} else {
			logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Info", Method: c.Method(), Url: c.OriginalURL(), Status: fiber.StatusOK})
			logEvent.Msg("successfully deleting file with university analytics")
		}
	}()

	return nil
}

func (h *Handler) getUniversityAnalytics(universityID int) (*entities.UniversityAnalytics, error) {
	h.logger.Debug().Msg("calling h.getUserAnalytics")
	userAnalytics, err := h.getUserAnalytics(universityID)
	if err != nil {
		logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Error"})
		logEvent.Msg(fmt.Sprintf("error getting user analytics: %s", err.Error()))
		return nil, fmt.Errorf("error getting user analytics: %s", err.Error())
	}

	h.logger.Debug().Msg("calling h.getApplicationAnalytics")
	applicationAnalytics, err := h.getApplicationAnalytics(universityID)
	if err != nil {
		logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Error"})
		logEvent.Msg(fmt.Sprintf("error getting application analytics: %s", err.Error()))
		return nil, fmt.Errorf("error getting application analytics: %s", err.Error())
	}

	h.logger.Debug().Msg("calling h.getProgramAnalytics")
	programAnalytics, err := h.getProgramAnalytics(universityID)
	if err != nil {
		logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Error"})
		logEvent.Msg(fmt.Sprintf("error getting program analytics: %s", err.Error()))
		return nil, fmt.Errorf("error getting program analytics: %s", err.Error())
	}

	universityAnalytics := entities.UniversityAnalytics{
		UserAnalytics:        *userAnalytics,
		ApplicationAnalytics: *applicationAnalytics,
		ProgramAnalytics:     *programAnalytics,
	}

	return &universityAnalytics, nil
}

func (h *Handler) getUserAnalytics(universityID int) (*entities.UserAnalytics, error) {
	h.logger.Debug().Msg("calling h.repository.DB.DBGetUserRoleCountsByUniversity")
	studentDelegateCount, err := h.repository.DB.DBGetUserRoleCountsByUniversity(universityID)
	if err != nil {
		logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Error"})
		logEvent.Msg(fmt.Sprintf("error getting UserRoleCountsByUniversity: %s", err.Error()))
		return nil, fmt.Errorf("error getting UserRoleCountsByUniversity: %s", err.Error())
	}

	h.logger.Debug().Msg("calling h.repository.DB.DBGetMonthlyStudentCountsByUniversity")
	monthlyStudentsCounts, err := h.repository.DB.DBGetMonthlyStudentCountsByUniversity(universityID)
	if err != nil {
		logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Error"})
		logEvent.Msg(fmt.Sprintf("error getting MonthlyStudentCountsByUniversity: %s", err.Error()))
		return nil, fmt.Errorf("error getting MonthlyStudentCountsByUniversity: %s", err.Error())
	}

	h.logger.Debug().Msg("calling h.repository.DB.DBGetAverageGPAForStudentsWithApprovedApplications")
	avgGPAApprovedApp, err := h.repository.DB.DBGetAverageGPAForStudentsWithApprovedApplications(universityID)
	if err != nil {
		logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Error"})
		logEvent.Msg(fmt.Sprintf("error getting AverageGPAForStudentsWithApprovedApplications: %s", err.Error()))
		return nil, fmt.Errorf("error getting AverageGPAForStudentsWithApprovedApplications: %s", err.Error())
	}

	h.logger.Debug().Msg("calling h.repository.DB.DBGetAverageGPAForApprovedStudentsByTargetUniversity")
	avgGPAApprovedAppTargetUniversity, err := h.repository.DB.DBGetAverageGPAForApprovedStudentsByTargetUniversity(universityID)
	if err != nil {
		logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Error"})
		logEvent.Msg(fmt.Sprintf("error getting AverageGPAForApprovedStudentsByTargetUniversity: %s", err.Error()))
		return nil, fmt.Errorf("error getting AverageGPAForApprovedStudentsByTargetUniversity: %s", err.Error())
	}

	userAnalytics := entities.UserAnalytics{
		StudentDelegateCount:              studentDelegateCount,
		MonthlyStudentsCounts:             monthlyStudentsCounts,
		AvgGPAApprovedApp:                 avgGPAApprovedApp,
		AvgGPAApprovedAppTargetUniversity: avgGPAApprovedAppTargetUniversity,
	}

	return &userAnalytics, nil
}

func (h *Handler) getApplicationAnalytics(universityID int) (*entities.ApplicationAnalytics, error) {
	h.logger.Debug().Msg("calling h.repository.DB.DBGetApplicationStatsByFromUniversity")
	statsFromUniversity, err := h.repository.DB.DBGetApplicationStatsByFromUniversity(universityID)
	if err != nil {
		logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Error"})
		logEvent.Msg(fmt.Sprintf("error getting ApplicationStatsByFromUniversity: %s", err.Error()))
		return nil, fmt.Errorf("error getting ApplicationStatsByFromUniversity: %s", err.Error())
	}

	h.logger.Debug().Msg("calling h.repository.DB.DBGetApplicationStatsByTargetUniversity")
	statsTargetUniversity, err := h.repository.DB.DBGetApplicationStatsByTargetUniversity(universityID)
	if err != nil {
		logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Error"})
		logEvent.Msg(fmt.Sprintf("error getting ApplicationStatsByTargetUniversity: %s", err.Error()))
		return nil, fmt.Errorf("error getting ApplicationStatsByTargetUniversity: %s", err.Error())
	}

	applicationAnalytics := entities.ApplicationAnalytics{
		StatsFromUniversity:   statsFromUniversity,
		StatsTargetUniversity: statsTargetUniversity,
	}

	return &applicationAnalytics, nil
}

func (h *Handler) getProgramAnalytics(universityID int) (*entities.ProgramAnalytics, error) {
	h.logger.Debug().Msg("calling h.repository.DB.DBGetDirectionStats")
	statsDirection, err := h.repository.DB.DBGetDirectionStats(universityID)
	if err != nil {
		logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Error"})
		logEvent.Msg(fmt.Sprintf("error getting DirectionStats: %s", err.Error()))
		return nil, fmt.Errorf("error getting DirectionStats: %s", err.Error())
	}

	h.logger.Debug().Msg("calling h.repository.DB.DBGetDigitalDepartmentStats")
	statsDigitalDepartment, err := h.repository.DB.DBGetDigitalDepartmentStats(universityID)
	if err != nil {
		logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Error"})
		logEvent.Msg(fmt.Sprintf("error getting DigitalDepartmentStats: %s", err.Error()))
		return nil, fmt.Errorf("error getting DigitalDepartmentStats: %s", err.Error())
	}

	h.logger.Debug().Msg("calling h.repository.DB.DBGetSberProgramsStats")
	statsSberProgram, err := h.repository.DB.DBGetSberProgramsStats(universityID)
	if err != nil {
		logEvent := log.CreateLog(h.logger, log.LogsField{Level: "Error"})
		logEvent.Msg(fmt.Sprintf("error getting SberProgramsStats: %s", err.Error()))
		return nil, fmt.Errorf("error getting SberProgramsStats: %s", err.Error())
	}

	programAnalytics := entities.ProgramAnalytics{
		StatsDirection:         statsDirection,
		StatsDigitalDepartment: statsDigitalDepartment,
		StatsSberProgram:       statsSberProgram,
	}

	return &programAnalytics, nil
}