hspguard/internal/admin/sessions.go

package admin

import (
	"encoding/json"
	"log"
	"math"
	"net/http"
	"strconv"

	"gitea.local/admin/hspguard/internal/repository"
	"gitea.local/admin/hspguard/internal/types"
	"gitea.local/admin/hspguard/internal/web"
	"github.com/go-chi/chi/v5"
	"github.com/google/uuid"
)

type GetSessionsParams struct {
	PageSize int `json:"size"`
	Page     int `json:"page"`
	// TODO: More filtering possibilities like onlyActive, expired, not-expired etc.
}

func (h *AdminHandler) GetUserSessions(w http.ResponseWriter, r *http.Request) {
	q := r.URL.Query()

	params := GetSessionsParams{}

	if pageSize, err := strconv.Atoi(q.Get("size")); err == nil {
		params.PageSize = pageSize
	} else {
		params.PageSize = 15
	}

	if page, err := strconv.Atoi(q.Get("page")); err == nil {
		params.Page = page
	} else {
		web.Error(w, "page is required", http.StatusBadRequest)
		return
	}

	sessions, err := h.repo.GetUserSessions(r.Context(), repository.GetUserSessionsParams{
		Limit:  int32(params.PageSize),
		Offset: int32(params.Page-1) * int32(params.PageSize),
	})
	if err != nil {
		log.Println("ERR: Failed to read user sessions from db:", err)
		web.Error(w, "failed to retrieve sessions", http.StatusInternalServerError)
		return
	}

	totalSessions, err := h.repo.GetUserSessionsCount(r.Context())
	if err != nil {
		log.Println("ERR: Failed to get total count of user sessions:", err)
		web.Error(w, "failed to retrieve sessions", http.StatusInternalServerError)
		return
	}

	mapped := make([]*types.UserSessionDTO, 0)

	for _, session := range sessions {
		mapped = append(mapped, types.NewUserSessionDTO(&session))
	}

	type Response struct {
		Items      []*types.UserSessionDTO `json:"items"`
		Page       int                     `json:"page"`
		TotalPages int                     `json:"total_pages"`
	}

	response := Response{
		Items:      mapped,
		Page:       params.Page,
		TotalPages: int(math.Ceil(float64(totalSessions) / float64(params.PageSize))),
	}

	if err := json.NewEncoder(w).Encode(response); err != nil {
		log.Println("ERR: Failed to encode sessions in response:", err)
		web.Error(w, "failed to encode sessions", http.StatusInternalServerError)
		return
	}
}

func (h *AdminHandler) RevokeUserSession(w http.ResponseWriter, r *http.Request) {
	sessionId := chi.URLParam(r, "id")
	parsed, err := uuid.Parse(sessionId)
	if err != nil {
		web.Error(w, "provided service id is not valid", http.StatusBadRequest)
		return
	}

	if err := h.repo.RevokeUserSession(r.Context(), parsed); err != nil {
		log.Println("ERR: Failed to revoke user session:", err)
		web.Error(w, "failed to revoke user session", http.StatusInternalServerError)
		return
	}

	w.WriteHeader(http.StatusOK)
	w.Write([]byte("{\"success\":true}"))
}

func (h *AdminHandler) GetServiceSessions(w http.ResponseWriter, r *http.Request) {
	q := r.URL.Query()

	params := GetSessionsParams{}

	if pageSize, err := strconv.Atoi(q.Get("size")); err == nil {
		params.PageSize = pageSize
	} else {
		params.PageSize = 15
	}

	if page, err := strconv.Atoi(q.Get("page")); err == nil {
		params.Page = page
	} else {
		web.Error(w, "page is required", http.StatusBadRequest)
		return
	}

	sessions, err := h.repo.GetServiceSessions(r.Context(), repository.GetServiceSessionsParams{
		Limit:  int32(params.PageSize),
		Offset: int32(params.Page-1) * int32(params.PageSize),
	})
	if err != nil {
		log.Println("ERR: Failed to read api sessions from db:", err)
		web.Error(w, "failed to retrieve sessions", http.StatusInternalServerError)
		return
	}

	totalSessions, err := h.repo.GetServiceSessionsCount(r.Context())
	if err != nil {
		log.Println("ERR: Failed to get total count of service sessions:", err)
		web.Error(w, "failed to retrieve sessions", http.StatusInternalServerError)
		return
	}

	mapped := make([]*types.ServiceSessionDTO, 0)

	for _, session := range sessions {
		mapped = append(mapped, types.NewServiceSessionDTO(&session))
	}

	type Response struct {
		Items      []*types.ServiceSessionDTO `json:"items"`
		Page       int                        `json:"page"`
		TotalPages int                        `json:"total_pages"`
	}

	response := Response{
		Items:      mapped,
		Page:       params.Page,
		TotalPages: int(math.Ceil(float64(totalSessions) / float64(params.PageSize))),
	}

	if err := json.NewEncoder(w).Encode(response); err != nil {
		log.Println("ERR: Failed to encode sessions in response:", err)
		web.Error(w, "failed to encode sessions", http.StatusInternalServerError)
	}
}