feat(add): updated artifacts logic

Author: CodeMeAPixel

internal/handlers/artifacts.go

@@ -54,19 +54,16 @@ func GetArtifacts(c *fiber.Ctx) error {
 	query.Limit = limit
 	query.Offset = offset
 
-	artifacts, err := artifactsService.GetArtifacts(query)
+	result, err := artifactsService.GetArtifacts(query)
 	if err != nil {
 		return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{
 			"error":  err.Error(),
 			"status": fiber.StatusInternalServerError,
 		})
 	}
 
-	// Calculate total (assuming all artifacts match without offset)
-	total := len(artifacts) + offset
-	if len(artifacts) < limit {
-		total = offset + len(artifacts)
-	}
+	artifacts := result.Data
+	totalFiltered := result.Total
 
 	// Get unique platforms and support statuses for metadata
 	platformsMap := make(map[string]bool)
@@ -88,10 +85,10 @@ func GetArtifacts(c *fiber.Ctx) error {
 	return c.JSON(fiber.Map{
 		"data": artifacts,
 		"metadata": fiber.Map{
-			"total":           total,
+			"total":           totalFiltered,
 			"limit":           limit,
 			"offset":          offset,
-			"hasMore":         len(artifacts) == limit,
+			"hasMore":         offset+len(artifacts) < totalFiltered,
 			"platforms":       platforms,
 			"supportStatuses": statuses,
 			"query": fiber.Map{
@@ -133,23 +130,23 @@ func GetArtifactByVersion(c *fiber.Ctx) error {
 		IncludeEOL: true,
 	}
 
-	artifacts, err := artifactsService.GetArtifacts(query)
+	result, err := artifactsService.GetArtifacts(query)
 	if err != nil {
 		return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{
 			"error": err.Error(),
 		})
 	}
 
-	if len(artifacts) == 0 {
+	if len(result.Data) == 0 {
 		return c.Status(fiber.StatusNotFound).JSON(fiber.Map{
 			"error": "Artifact version not found",
 		})
 	}
 
 	return c.JSON(fiber.Map{
 		"success": true,
-		"count":   len(artifacts),
-		"data":    artifacts,
+		"count":   len(result.Data),
+		"data":    result.Data,
 	})
 }
 
@@ -176,14 +173,14 @@ func CheckArtifact(c *fiber.Ctx) error {
 		IncludeEOL: true,
 	}
 
-	artifacts, err := artifactsService.GetArtifacts(query)
+	result, err := artifactsService.GetArtifacts(query)
 	if err != nil {
 		return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{
 			"error": err.Error(),
 		})
 	}
 
-	if len(artifacts) == 0 {
+	if len(result.Data) == 0 {
 		return c.Status(fiber.StatusNotFound).JSON(fiber.Map{
 			"error":   "Artifact version not found",
 			"version": version,
@@ -194,8 +191,8 @@ func CheckArtifact(c *fiber.Ctx) error {
 		"success":       true,
 		"version":       version,
 		"available":     true,
-		"platformCount": len(artifacts),
-		"platforms":     artifacts,
+		"platformCount": len(result.Data),
+		"platforms":     result.Data,
 	})
 }
 
@@ -223,15 +220,15 @@ func GetArtifactChanges(c *fiber.Ctx) error {
 	baseQuery := services.ArtifactsQuery{Version: base, IncludeEOL: true}
 	headQuery := services.ArtifactsQuery{Version: head, IncludeEOL: true}
 
-	baseArtifacts, err := artifactsService.GetArtifacts(baseQuery)
-	if err != nil || len(baseArtifacts) == 0 {
+	baseResult, err := artifactsService.GetArtifacts(baseQuery)
+	if err != nil || len(baseResult.Data) == 0 {
 		return c.Status(fiber.StatusNotFound).JSON(fiber.Map{
 			"error": "Base version not found",
 		})
 	}
 
-	headArtifacts, err := artifactsService.GetArtifacts(headQuery)
-	if err != nil || len(headArtifacts) == 0 {
+	headResult, err := artifactsService.GetArtifacts(headQuery)
+	if err != nil || len(headResult.Data) == 0 {
 		return c.Status(fiber.StatusNotFound).JSON(fiber.Map{
 			"error": "Head version not found",
 		})
@@ -243,11 +240,11 @@ func GetArtifactChanges(c *fiber.Ctx) error {
 		"base":    base,
 		"head":    head,
 		"comparison": map[string]interface{}{
-			"base_hash": baseArtifacts[0].Hash,
-			"head_hash": headArtifacts[0].Hash,
-			"base_date": baseArtifacts[0].Date,
-			"head_date": headArtifacts[0].Date,
-			"platforms": len(headArtifacts),
+			"base_hash": baseResult.Data[0].Hash,
+			"head_hash": headResult.Data[0].Hash,
+			"base_date": baseResult.Data[0].Date,
+			"head_date": headResult.Data[0].Date,
+			"platforms": len(headResult.Data),
 		},
 		"message": "Use GitHub API to fetch detailed commit history",
 	})

internal/services/artifacts.go

@@ -79,6 +79,7 @@ type ArtifactsQuery struct {
 
 type ArtifactEntry struct {
 	Version       string
+	FullVersion   string // Full version string like v1.0.0.12345 for Pterodactyl
 	Hash          string
 	Platform      PlatformType
 	Date          string
@@ -87,6 +88,13 @@ type ArtifactEntry struct {
 	Size          int64
 }
 
+// ArtifactsResult holds paginated results with metadata
+type ArtifactsResult struct {
+	Data       []ArtifactEntry
+	Total      int
+	FilteredBy string
+}
+
 // Cache structures
 type cacheEntry struct {
 	data      interface{}
@@ -371,7 +379,7 @@ func (s *ArtifactsService) PaginateArtifacts(artifacts []ArtifactEntry, limit, o
 }
 
 // GetArtifacts returns the full list of artifacts with filtering and pagination
-func (s *ArtifactsService) GetArtifacts(query ArtifactsQuery) ([]ArtifactEntry, error) {
+func (s *ArtifactsService) GetArtifacts(query ArtifactsQuery) (*ArtifactsResult, error) {
 	tags, err := s.FetchGitHubTags(true)
 	if err != nil {
 		return nil, err
@@ -384,6 +392,7 @@ func (s *ArtifactsService) GetArtifacts(query ArtifactsQuery) ([]ArtifactEntry,
 	for version, artifact := range processedData.Windows {
 		artifacts = append(artifacts, ArtifactEntry{
 			Version:       version,
+			FullVersion:   s.generateFullVersion(version),
 			Hash:          artifact.Hash,
 			Platform:      Windows,
 			Date:          artifact.Date,
@@ -395,6 +404,7 @@ func (s *ArtifactsService) GetArtifacts(query ArtifactsQuery) ([]ArtifactEntry,
 	for version, artifact := range processedData.Linux {
 		artifacts = append(artifacts, ArtifactEntry{
 			Version:       version,
+			FullVersion:   s.generateFullVersion(version),
 			Hash:          artifact.Hash,
 			Platform:      Linux,
 			Date:          artifact.Date,
@@ -407,6 +417,9 @@ func (s *ArtifactsService) GetArtifacts(query ArtifactsQuery) ([]ArtifactEntry,
 	// Apply filtering
 	filtered := s.FilterArtifacts(artifacts, query)
 
+	// Store total count after filtering but before pagination
+	totalFiltered := len(filtered)
+
 	// Apply sorting
 	sorted := s.SortArtifacts(filtered, query.SortBy, query.SortOrder)
 
@@ -416,7 +429,10 @@ func (s *ArtifactsService) GetArtifacts(query ArtifactsQuery) ([]ArtifactEntry,
 	}
 	paginated := s.PaginateArtifacts(sorted, query.Limit, query.Offset)
 
-	return paginated, nil
+	return &ArtifactsResult{
+		Data:  paginated,
+		Total: totalFiltered,
+	}, nil
 }
 
 // Helper methods
@@ -447,6 +463,12 @@ func (s *ArtifactsService) determineSupportStatus(version int) SupportStatus {
 	}
 }
 
+// generateFullVersion creates the full version string for hosting panels like Pterodactyl
+// Format: v1.0.0.{build_number} (e.g., v1.0.0.12345)
+func (s *ArtifactsService) generateFullVersion(version string) string {
+	return fmt.Sprintf("v1.0.0.%s", version)
+}
+
 func (s *ArtifactsService) estimateSize(version string, platform string) int64 {
 	// Rough estimates in MB
 	if platform == "windows" {