feat: initial implementation of container management platform

2026-06-03 20:12:58 +00:00 · 2026-02-16 10:18:05 +01:00
commit ffa5489dc1
167 changed files with 55910 additions and 0 deletions
@@ -0,0 +1,458 @@
+package api
+
+import (
+	"containr/internal/database"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"strconv"
+
+	"github.com/gin-gonic/gin"
+	"github.com/google/uuid"
+)
+
+// GitProvider represents a Git provider (GitHub, GitLab, Bitbucket)
+type GitProvider struct {
+	ID          string `json:"id" db:"id"`
+	Name        string `json:"name" db:"name"`        // github, gitlab, bitbucket
+	DisplayName string `json:"display_name" db:"display_name"`
+	APIUrl      string `json:"api_url" db:"api_url"`
+	WebhookUrl  string `json:"webhook_url" db:"webhook_url"`
+	UserID      string `json:"user_id" db:"user_id"`
+	AccessToken string `json:"-" db:"access_token"` // Hidden in JSON responses
+	CreatedAt   string `json:"created_at" db:"created_at"`
+	UpdatedAt   string `json:"updated_at" db:"updated_at"`
+}
+
+// GitRepository represents a connected Git repository
+type GitRepository struct {
+	ID           string `json:"id" db:"id"`
+	ProviderID   string `json:"provider_id" db:"provider_id"`
+	Name         string `json:"name" db:"name"`
+	FullName     string `json:"full_name" db:"full_name"`
+	Description  string `json:"description" db:"description"`
+	CloneURL     string `json:"clone_url" db:"clone_url"`
+	WebhookURL   string `json:"webhook_url" db:"webhook_url"`
+	DefaultBranch string `json:"default_branch" db:"default_branch"`
+	IsPrivate    bool   `json:"is_private" db:"is_private"`
+	UserID       string `json:"user_id" db:"user_id"`
+	CreatedAt    string `json:"created_at" db:"created_at"`
+	UpdatedAt    string `json:"updated_at" db:"updated_at"`
+}
+
+// GitWebhook represents a webhook configuration
+type GitWebhook struct {
+	ID         string `json:"id" db:"id"`
+	RepoID     string `json:"repo_id" db:"repo_id"`
+	ProviderID string `json:"provider_id" db:"provider_id"`
+	Events     string `json:"events" db:"events"`     // JSON array of events
+	Secret     string `json:"-" db:"webhook_secret"` // Hidden in JSON responses
+	Active     bool   `json:"active" db:"active"`
+	CreatedAt  string `json:"created_at" db:"created_at"`
+	UpdatedAt  string `json:"updated_at" db:"updated_at"`
+}
+
+// CreateGitProviderRequest represents a request to create a Git provider
+type CreateGitProviderRequest struct {
+	Name        string `json:"name" binding:"required,oneof=github gitlab bitbucket"`
+	DisplayName string `json:"display_name" binding:"required"`
+	AccessToken string `json:"access_token" binding:"required"`
+}
+
+// CreateGitRepoRequest represents a request to connect a Git repository
+type CreateGitRepoRequest struct {
+	ProviderID   string `json:"provider_id" binding:"required"`
+	RepoFullName string `json:"repo_full_name" binding:"required"`
+}
+
+// CreateWebhookRequest represents a request to create a webhook
+type CreateWebhookRequest struct {
+	RepoID    string   `json:"repo_id" binding:"required"`
+	Events    []string `json:"events" binding:"required"`
+	Branch    string   `json:"branch"`
+}
+
+func handleGetGitProviders(c *gin.Context) {
+	userID := c.MustGet("user_id").(string)
+	db := c.MustGet("db").(*database.DB)
+
+	rows, err := db.Query(`
+		SELECT id, name, display_name, api_url, webhook_url, user_id, created_at, updated_at
+		FROM git_providers 
+		WHERE user_id = $1 
+		ORDER BY created_at DESC
+	`, userID)
+
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "Database error"})
+		return
+	}
+	defer rows.Close()
+
+	var providers []GitProvider
+	for rows.Next() {
+		var provider GitProvider
+		if err := rows.Scan(&provider.ID, &provider.Name, &provider.DisplayName, &provider.APIUrl, 
+			&provider.WebhookUrl, &provider.UserID, &provider.CreatedAt, &provider.UpdatedAt); err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": "Database error"})
+			return
+		}
+		providers = append(providers, provider)
+	}
+
+	c.JSON(http.StatusOK, gin.H{"providers": providers})
+}
+
+func handleCreateGitProvider(c *gin.Context) {
+	userID := c.MustGet("user_id").(string)
+	db := c.MustGet("db").(*database.DB)
+
+	var req CreateGitProviderRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	// Validate the access token by making a test API call
+	if !validateGitToken(req.Name, req.AccessToken) {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid access token for " + req.Name})
+		return
+	}
+
+	provider := GitProvider{
+		ID:          uuid.New().String(),
+		Name:        req.Name,
+		DisplayName: req.DisplayName,
+		AccessToken: req.AccessToken,
+		UserID:      userID,
+	}
+
+	// Set provider-specific URLs
+	switch req.Name {
+	case "github":
+		provider.APIUrl = "https://api.github.com"
+		provider.WebhookUrl = "https://api.github.com"
+	case "gitlab":
+		provider.APIUrl = "https://gitlab.com/api/v4"
+		provider.WebhookUrl = "https://gitlab.com"
+	case "bitbucket":
+		provider.APIUrl = "https://api.bitbucket.org/2.0"
+		provider.WebhookUrl = "https://api.bitbucket.org/2.0"
+	}
+
+	_, err := db.Exec(`
+		INSERT INTO git_providers (id, name, display_name, api_url, webhook_url, access_token, user_id, created_at, updated_at)
+		VALUES ($1, $2, $3, $4, $5, $6, $7, NOW(), NOW())
+	`, provider.ID, provider.Name, provider.DisplayName, provider.APIUrl, 
+		provider.WebhookUrl, provider.AccessToken, provider.UserID)
+
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to create Git provider"})
+		return
+	}
+
+	// Return provider without access token
+	provider.AccessToken = ""
+	c.JSON(http.StatusCreated, provider)
+}
+
+func handleGetGitRepositories(c *gin.Context) {
+	userID := c.MustGet("user_id").(string)
+	db := c.MustGet("db").(*database.DB)
+	providerID := c.Param("providerId")
+
+	// Validate UUID
+	if _, err := uuid.Parse(providerID); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid provider ID"})
+		return
+	}
+
+	// Get provider info
+	var provider GitProvider
+	err := db.QueryRow(`
+		SELECT id, name, access_token, api_url
+		FROM git_providers 
+		WHERE id = $1 AND user_id = $2
+	`, providerID, userID).Scan(&provider.ID, &provider.Name, &provider.AccessToken, &provider.APIUrl)
+
+	if err != nil {
+		c.JSON(http.StatusNotFound, gin.H{"error": "Git provider not found"})
+		return
+	}
+
+	// Fetch repositories from the Git provider
+	repos, err := fetchGitRepositories(provider.Name, provider.AccessToken, provider.APIUrl)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to fetch repositories"})
+		return
+	}
+
+	c.JSON(http.StatusOK, gin.H{"repositories": repos})
+}
+
+func handleConnectGitRepository(c *gin.Context) {
+	userID := c.MustGet("user_id").(string)
+	db := c.MustGet("db").(*database.DB)
+
+	var req CreateGitRepoRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	// Validate UUID
+	if _, err := uuid.Parse(req.ProviderID); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid provider ID"})
+		return
+	}
+
+	// Get provider info
+	var provider GitProvider
+	err := db.QueryRow(`
+		SELECT id, name, access_token, api_url
+		FROM git_providers 
+		WHERE id = $1 AND user_id = $2
+	`, req.ProviderID, userID).Scan(&provider.ID, &provider.Name, &provider.AccessToken, &provider.APIUrl)
+
+	if err != nil {
+		c.JSON(http.StatusNotFound, gin.H{"error": "Git provider not found"})
+		return
+	}
+
+	// Fetch repository details from Git provider
+	repoDetails, err := fetchGitRepositoryDetails(provider.Name, req.RepoFullName, provider.AccessToken, provider.APIUrl)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to fetch repository details"})
+		return
+	}
+
+	// Check if repository is already connected
+	var existingID string
+	err = db.QueryRow(`
+		SELECT id FROM git_repositories 
+		WHERE provider_id = $1 AND full_name = $2
+	`, req.ProviderID, req.RepoFullName).Scan(&existingID)
+
+	if err == nil {
+		c.JSON(http.StatusConflict, gin.H{"error": "Repository already connected", "repository_id": existingID})
+		return
+	}
+
+	// Create repository record
+	repo := GitRepository{
+		ID:            uuid.New().String(),
+		ProviderID:    req.ProviderID,
+		Name:          repoDetails["name"].(string),
+		FullName:      req.RepoFullName,
+		Description:   repoDetails["description"].(string),
+		CloneURL:      repoDetails["clone_url"].(string),
+		DefaultBranch: repoDetails["default_branch"].(string),
+		IsPrivate:     repoDetails["private"].(bool),
+		UserID:        userID,
+	}
+
+	_, err = db.Exec(`
+		INSERT INTO git_repositories (id, provider_id, name, full_name, description, clone_url, 
+			default_branch, is_private, user_id, created_at, updated_at)
+		VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, NOW(), NOW())
+	`, repo.ID, repo.ProviderID, repo.Name, repo.FullName, repo.Description, 
+		repo.CloneURL, repo.DefaultBranch, repo.IsPrivate, repo.UserID)
+
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to connect repository"})
+		return
+	}
+
+	c.JSON(http.StatusCreated, repo)
+}
+
+func handleCreateWebhook(c *gin.Context) {
+	userID := c.MustGet("user_id").(string)
+	db := c.MustGet("db").(*database.DB)
+
+	var req CreateWebhookRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	// Validate UUIDs
+	if _, err := uuid.Parse(req.RepoID); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid repository ID"})
+		return
+	}
+
+	// Get repository and provider info
+	var repo GitRepository
+	var provider GitProvider
+	err := db.QueryRow(`
+		SELECT r.id, r.provider_id, r.full_name, r.user_id,
+			   p.id, p.name, p.access_token, p.webhook_url
+		FROM git_repositories r
+		JOIN git_providers p ON r.provider_id = p.id
+		WHERE r.id = $1 AND r.user_id = $2
+	`, req.RepoID, userID).Scan(&repo.ID, &repo.ProviderID, &repo.FullName, &repo.UserID,
+		&provider.ID, &provider.Name, &provider.AccessToken, &provider.WebhookUrl)
+
+	if err != nil {
+		c.JSON(http.StatusNotFound, gin.H{"error": "Repository not found"})
+		return
+	}
+
+	// Convert events to JSON
+	eventsJSON, _ := json.Marshal(req.Events)
+	webhookSecret := generateWebhookSecret()
+
+	// Create webhook on Git provider
+	webhookURL := fmt.Sprintf("%s/api/v1/webhooks/git/%s", "https://your-domain.com", req.RepoID)
+	remoteWebhookID, err := createGitWebhook(provider.Name, repo.FullName, provider.AccessToken, 
+		provider.WebhookUrl, webhookURL, req.Events, webhookSecret)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to create webhook on Git provider"})
+		return
+	}
+
+	// Create webhook record
+	webhook := GitWebhook{
+		ID:         uuid.New().String(),
+		RepoID:     req.RepoID,
+		ProviderID: provider.ID,
+		Events:     string(eventsJSON),
+		Secret:     webhookSecret,
+		Active:     true,
+	}
+
+	_, err = db.Exec(`
+		INSERT INTO git_webhooks (id, repo_id, provider_id, events, webhook_secret, active, created_at, updated_at)
+		VALUES ($1, $2, $3, $4, $5, $6, NOW(), NOW())
+	`, webhook.ID, webhook.RepoID, webhook.ProviderID, webhook.Events, webhook.Secret, webhook.Active)
+
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to create webhook"})
+		return
+	}
+
+	c.JSON(http.StatusCreated, gin.H{
+		"webhook": webhook,
+		"remote_webhook_id": remoteWebhookID,
+	})
+}
+
+func handleGetConnectedRepositories(c *gin.Context) {
+	userID := c.MustGet("user_id").(string)
+	db := c.MustGet("db").(*database.DB)
+
+	page, _ := strconv.Atoi(c.DefaultQuery("page", "1"))
+	limit, _ := strconv.Atoi(c.DefaultQuery("limit", "10"))
+	offset := (page - 1) * limit
+
+	rows, err := db.Query(`
+		SELECT r.id, r.provider_id, r.name, r.full_name, r.description, r.clone_url,
+			   r.default_branch, r.is_private, r.user_id, r.created_at, r.updated_at,
+			   p.name as provider_name, p.display_name
+		FROM git_repositories r
+		JOIN git_providers p ON r.provider_id = p.id
+		WHERE r.user_id = $1
+		ORDER BY r.updated_at DESC
+		LIMIT $2 OFFSET $3
+	`, userID, limit, offset)
+
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "Database error"})
+		return
+	}
+	defer rows.Close()
+
+	var repositories []map[string]interface{}
+	for rows.Next() {
+		var repo GitRepository
+		var providerName, providerDisplayName string
+		if err := rows.Scan(&repo.ID, &repo.ProviderID, &repo.Name, &repo.FullName, &repo.Description, 
+			&repo.CloneURL, &repo.DefaultBranch, &repo.IsPrivate, &repo.UserID, &repo.CreatedAt, &repo.UpdatedAt,
+			&providerName, &providerDisplayName); err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": "Database error"})
+			return
+		}
+
+		repositories = append(repositories, map[string]interface{}{
+			"id":            repo.ID,
+			"provider_id":   repo.ProviderID,
+			"name":          repo.Name,
+			"full_name":     repo.FullName,
+			"description":   repo.Description,
+			"clone_url":     repo.CloneURL,
+			"default_branch": repo.DefaultBranch,
+			"is_private":    repo.IsPrivate,
+			"created_at":    repo.CreatedAt,
+			"updated_at":    repo.UpdatedAt,
+			"provider": map[string]string{
+				"name":         providerName,
+				"display_name": providerDisplayName,
+			},
+		})
+	}
+
+	// Get total count
+	var total int
+	err = db.QueryRow(`
+		SELECT COUNT(*) FROM git_repositories WHERE user_id = $1
+	`, userID).Scan(&total)
+
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "Database error"})
+		return
+	}
+
+	c.JSON(http.StatusOK, gin.H{
+		"repositories": repositories,
+		"pagination": gin.H{
+			"page":  page,
+			"limit": limit,
+			"total": total,
+		},
+	})
+}
+
+// Helper functions (these would need to be implemented with actual Git provider API calls)
+
+func validateGitToken(provider, token string) bool {
+	// TODO: Implement actual validation with Git provider APIs
+	// For now, just check if token is not empty
+	return token != ""
+}
+
+func fetchGitRepositories(provider, token, apiUrl string) ([]map[string]interface{}, error) {
+	// TODO: Implement actual API calls to fetch repositories
+	// For now, return mock data
+	return []map[string]interface{}{
+		{
+			"name":         "example-repo",
+			"full_name":    "user/example-repo",
+			"description":  "An example repository",
+			"clone_url":    "https://github.com/user/example-repo.git",
+			"default_branch": "main",
+			"private":      false,
+		},
+	}, nil
+}
+
+func fetchGitRepositoryDetails(provider, repoFullName, token, apiUrl string) (map[string]interface{}, error) {
+	// TODO: Implement actual API call to fetch repository details
+	return map[string]interface{}{
+		"name":           "example-repo",
+		"description":    "An example repository",
+		"clone_url":      "https://github.com/user/example-repo.git",
+		"default_branch": "main",
+		"private":        false,
+	}, nil
+}
+
+func createGitWebhook(provider, repoFullName, token, webhookUrl, apiUrl string, events []string, secret string) (string, error) {
+	// TODO: Implement actual webhook creation
+	return uuid.New().String(), nil
+}
+
+func generateWebhookSecret() string {
+	// TODO: Generate a proper secret
+	return "webhook-secret-" + uuid.New().String()
+}