initial commit

migration/users.go

@@ -0,0 +1,203 @@
+// users.go
+
+// Package migration handles the migration of data from GitLab to Gitea
+package migration
+
+import (
+	"fmt"
+	"math/rand"
+	"strings"
+	"time"
+
+	"github.com/xanzy/go-gitlab"
+
+	"github.com/go-i2p/gitlab-to-gitea/utils"
+)
+
+// userCreateRequest represents the data needed to create a user in Gitea
+type userCreateRequest struct {
+	Email      string `json:"email"`
+	FullName   string `json:"full_name"`
+	LoginName  string `json:"login_name"`
+	Password   string `json:"password"`
+	SendNotify bool   `json:"send_notify"`
+	SourceID   int    `json:"source_id"`
+	Username   string `json:"username"`
+}
+
+// ImportUser imports a single GitLab user to Gitea
+func (m *Manager) ImportUser(user *gitlab.User, notify bool) error {
+	// Normalize username
+	cleanUsername := utils.NormalizeUsername(user.Username)
+
+	// Check if user already exists
+	if exists, err := m.userExists(cleanUsername); err != nil {
+		return fmt.Errorf("failed to check if user exists: %w", err)
+	} else if exists {
+		utils.PrintWarning(fmt.Sprintf("User %s already exists as %s in Gitea, skipping!", user.Username, cleanUsername))
+		return nil
+	}
+
+	// Generate temporary password
+	tmpPassword := generateTempPassword()
+
+	// Determine email (use placeholder if not available)
+	email := fmt.Sprintf("%s@placeholder-migration.local", cleanUsername)
+	if user.Email != "" {
+		email = user.Email
+	}
+
+	// Create user request
+	userReq := userCreateRequest{
+		Email:      email,
+		FullName:   user.Name,
+		LoginName:  cleanUsername,
+		Password:   tmpPassword,
+		SendNotify: notify,
+		SourceID:   0, // local user
+		Username:   cleanUsername,
+	}
+
+	// Debug what endpoint we're calling and with what method
+	fmt.Printf("Attempting to create user via: POST /admin/users\n")
+
+	var result map[string]interface{}
+	err := m.giteaClient.Post("/admin/users", userReq, &result)
+	if err != nil {
+		// Try the alternative user creation endpoint if the first one failed
+		fmt.Printf("First attempt failed, trying alternative endpoint\n")
+		err = m.giteaClient.Post("/api/v1/admin/users", userReq, &result)
+		if err != nil {
+			return fmt.Errorf("failed to create user %s: %w", user.Username, err)
+		}
+	}
+
+	utils.PrintInfo(fmt.Sprintf("User %s created as %s, temporary password: %s", user.Username, cleanUsername, tmpPassword))
+
+	// Import user's SSH keys
+	keys, err := m.gitlabClient.GetUserKeys(user.ID)
+	if err != nil {
+		utils.PrintWarning(fmt.Sprintf("Failed to fetch keys for user %s: %v", user.Username, err))
+	} else {
+		for _, key := range keys {
+			if err := m.importUserKey(cleanUsername, key); err != nil {
+				utils.PrintWarning(fmt.Sprintf("Failed to import key for user %s: %v", user.Username, err))
+			}
+		}
+	}
+
+	return nil
+}
+
+// ImportPlaceholderUser creates a placeholder user when mentioned user doesn't exist
+func (m *Manager) ImportPlaceholderUser(username string) error {
+	cleanUsername := utils.NormalizeUsername(username)
+
+	exists, err := m.userExists(cleanUsername)
+	if err != nil {
+		return fmt.Errorf("failed to check if user exists: %w", err)
+	}
+
+	if exists {
+		utils.PrintWarning(fmt.Sprintf("User %s already exists as %s in Gitea, skipping placeholder creation", username, cleanUsername))
+		return nil
+	}
+
+	tmpPassword := generateTempPassword()
+
+	// Create user request
+	userReq := userCreateRequest{
+		Email:      fmt.Sprintf("%s@placeholder-migration.local", cleanUsername),
+		FullName:   username, // Keep original name for display
+		LoginName:  cleanUsername,
+		Password:   tmpPassword,
+		SendNotify: false,
+		SourceID:   0, // local user
+		Username:   cleanUsername,
+	}
+
+	var result map[string]interface{}
+	err = m.giteaClient.Post("/admin/users", userReq, &result)
+	if err != nil {
+		return fmt.Errorf("failed to create placeholder user %s: %w", username, err)
+	}
+
+	utils.PrintInfo(fmt.Sprintf("Placeholder user %s created as %s", username, cleanUsername))
+	return nil
+}
+
+// importUserKey imports a user's SSH key to Gitea
+func (m *Manager) importUserKey(username string, key *gitlab.SSHKey) error {
+	// Check if key already exists
+	var existingKeys []map[string]interface{}
+	err := m.giteaClient.Get(fmt.Sprintf("/users/%s/keys", username), &existingKeys)
+	if err != nil {
+		return fmt.Errorf("failed to get existing keys: %w", err)
+	}
+
+	// Check if key with same title already exists
+	for _, existingKey := range existingKeys {
+		if existingKey["title"] == key.Title {
+			utils.PrintWarning(fmt.Sprintf("Key %s already exists for user %s, skipping", key.Title, username))
+			return nil
+		}
+	}
+
+	// Create key request
+	keyReq := map[string]string{
+		"key":   key.Key,
+		"title": key.Title,
+	}
+
+	// Call Gitea API to create key
+	var result map[string]interface{}
+	err = m.giteaClient.Post(fmt.Sprintf("/admin/users/%s/keys", username), keyReq, &result)
+	if err != nil {
+		return fmt.Errorf("failed to create key %s: %w", key.Title, err)
+	}
+
+	utils.PrintInfo(fmt.Sprintf("Key %s imported for user %s", key.Title, username))
+	return nil
+}
+
+// userExists checks if a user exists in Gitea
+func (m *Manager) userExists(username string) (bool, error) {
+	var user map[string]interface{}
+	err := m.giteaClient.Get("/users/"+username, &user)
+	if err != nil {
+		// If we get an error, assume user doesn't exist
+		// But only if the error contains "not found" or similar messages
+		if isNotFoundError(err) {
+			return false, nil
+		}
+		return false, fmt.Errorf("error checking if user exists: %w", err)
+	}
+	return true, nil
+}
+
+// generateTempPassword creates a random password for new users
+func generateTempPassword() string {
+	const (
+		chars  = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
+		pwdLen = 12
+		prefix = "Tmp1!"
+	)
+
+	// Initialize random source
+	r := rand.New(rand.NewSource(time.Now().UnixNano()))
+
+	// Generate random part of password
+	result := make([]byte, pwdLen)
+	for i := range result {
+		result[i] = chars[r.Intn(len(chars))]
+	}
+
+	return prefix + string(result)
+}
+
+// isNotFoundError checks if an error is a 404 Not Found error
+func isNotFoundError(err error) bool {
+	return err != nil && (strings.Contains(err.Error(), "404") ||
+		strings.Contains(err.Error(), "not found") ||
+		strings.Contains(err.Error(), "does not exist"))
+}