refactor: change logic

Author: warmdev17

cmd/helpers.go

@@ -2,158 +2,153 @@ package cmd
 
 import (
 	"encoding/json"
-	"errors"
 	"fmt"
 	"os"
 	"os/exec"
 	"path/filepath"
 	"strconv"
 	"strings"
+	"sync"
 
 	"github.com/spf13/cobra"
 )
 
 var (
-	projectName   string
-	projectCount  int
-	projectPrefix string
-	projectProto  string
+	createProjectCount  int
+	createProjectPrefix string
+	createProjectProto  string
 )
 
 var projectCreateCmd = &cobra.Command{
-	Use:   "create",
-	Short: "Create multiple projects with prefix and count",
-	Long: `Create one or more new projects in the current subgroup on GitLab.
-
-Use the --count flag to specify how many projects to create,
-and --prefix to define the project name prefix.
+	Use:   "create [names...]",
+	Short: "Create projects (Interactive or Batch)",
+	Long: `Create one or more projects in the current subgroup.
 
 Examples:
-  ash project create --count 5 --prefix Baitap
-    → Creates projects: Baitap1, Baitap2, Baitap3, Baitap4, Baitap5
-
-All created projects will also be recorded in subgroup.json for sync tracking.`,
-	SilenceUsage:  true,
-	SilenceErrors: true,
+  ash project create BaiTap1 BaiTap2
+  ash project create -c 5 -p Lab`,
+	SilenceUsage: true,
 
 	RunE: func(cmd *cobra.Command, args []string) error {
-		if projectProto != "ssh" && projectProto != "https" {
-			projectProto = "https"
-		}
-
+		// 1. Env Check
 		wd, err := os.Getwd()
 		if err != nil {
-			return fmt.Errorf("getwd failed: %w", err)
+			return err
 		}
 		ashDir := filepath.Join(wd, ".ash")
 		subMetaPath := filepath.Join(ashDir, "subgroup.json")
+
 		if !fileExists(subMetaPath) {
-			return errors.New("not in a subgroup folder: .ash/subgroup.json not found")
+			return fmt.Errorf("not in a subgroup folder (.ash/subgroup.json missing)")
 		}
 
-		// read subgroup meta to get current subgroupo (namespace)
 		var meta subgroupMeta
 		if err := readJSON(subMetaPath, &meta); err != nil {
-			return fmt.Errorf("parse subgroup.json failed: %w", err)
-		}
-		if meta.Group.ID == 0 {
-			return errors.New("invalid subgroup.json: missing subgroup id")
+			return fmt.Errorf("read metadata failed: %w", err)
 		}
 
-		// build names to create
+		// 2. Determine List
 		var names []string
-		if strings.TrimSpace(projectName) != "" {
-			if projectCount > 0 || strings.TrimSpace(projectPrefix) != "" {
-				return errors.New("use either -n <Name> or -c <N> -p <prefix> ")
-			}
-			names = []string{projectName}
+		if len(args) > 0 {
+			names = args
 		} else {
-			if projectCount <= 0 || strings.TrimSpace(projectPrefix) == "" {
-				return errors.New("missing project count, please use -c <N>")
+			if createProjectCount <= 0 || createProjectPrefix == "" {
+				return fmt.Errorf("missing args: usage 'ash project create Name' or '-c 5 -p Prefix'")
 			}
-			for i := 1; i <= projectCount; i++ {
-				names = append(names, fmt.Sprintf("%s%d", projectPrefix, i))
+			for i := 1; i <= createProjectCount; i++ {
+				names = append(names, fmt.Sprintf("%s%d", createProjectPrefix, i))
 			}
 		}
 
-		// create each project via glab API, then clone
-		createdAny := false
-		for _, name := range names {
-			display := strings.TrimSpace(name)
-			if display == "" {
-				continue
-			}
-			path := slugify(display) // reuse helper from init.go
-
-			fmt.Printf("%s Creating project: name=%q path=%q namespace_id=%d\n", icRun, display, path, meta.Group.ID)
-			create := exec.Command("glab", "api", "-X", "POST", "/projects",
-				"-f", "name="+display,
-				"-f", "path="+path,
-				"-f", "namespace_id="+strconv.FormatInt(meta.Group.ID, 10),
-				"-f", "visibility=public",
-			)
-			out, err := create.Output()
-			if err != nil {
-				fmt.Printf("%s create failed for %s: %v\n", icErr, display, err)
-				continue
-			}
+		// 3. EXECUTE
+		var results []TaskResult
+		var mu sync.Mutex // Để append kết quả an toàn
 
-			// parse response using glProject (already defined in codebase)
-			var pr glProject
-			if err := json.Unmarshal(out, &pr); err != nil {
-				fmt.Printf("%s parse create response failed for %s: %v\n", icErr, display, err)
-				continue
-			}
-			if pr.ID == 0 {
-				fmt.Printf("%s unexpected response for %s (no ID)\n", icErr, display)
-				continue
-			}
-			fmt.Printf("%s created: id=%d name=%q path=%q\n", icOk, pr.ID, pr.Name, pr.Path)
+		title := fmt.Sprintf("Creating %d project(s)...", len(names))
 
-			// clone locally into folder named by display Name
-			dest := filepath.Join(wd, display)
-			url := pr.SSHURLToRepo
-			if repoProto == "https" {
-				url = pr.HTTPURLToRepo
-			}
-			fmt.Printf("%s cloning → %s\n", icDownload, dest)
-			clone := exec.Command("git", "clone", "--quiet", url, dest)
-			if err := clone.Run(); err != nil {
-				fmt.Printf("%s clone failed: %s (%v)\n", icErr, display, err)
-				continue
-			}
-			fmt.Printf("%s cloned %s\n", icOk, display)
-			createdAny = true
-		}
+		err = RunWithSpinner(title, func() error {
+			for _, rawName := range names {
+				display := strings.TrimSpace(rawName)
+				if display == "" {
+					continue
+				}
 
-		// refresh subgroup.json (take live snapshot) if at least one created
-		if createdAny {
-			fmt.Println("🗂  refreshing .ash/subgroup.json ...")
-			projects, err := apiListProjects(meta.Group.ID) // lists projects for subgroup
-			if err != nil {
-				return err
-			}
-			prj := make([]projectIdent, 0, len(projects))
-			for _, p := range projects {
-				prj = append(prj, projectIdent{ID: p.ID, Path: p.Path, Name: p.Name})
-			}
-			meta.Projects = prj
-			if err := writeSubgroupJSON(ashDir, meta); err != nil {
-				return fmt.Errorf("write subgroup.json failed: %w", err)
+				res := createOneProject(wd, meta.Group.ID, display, createProjectProto)
+
+				mu.Lock()
+				results = append(results, res)
+				mu.Unlock()
 			}
-			fmt.Printf("%s Updated .ash/subgroup.json", icInfo)
-		}
 
-		fmt.Printf("%s Done.", icOk)
+			// Refresh Metadata Silent
+			refreshProjectMeta(ashDir, meta.Group.ID)
+			return nil
+		})
+		if err != nil {
+			return err
+		}
+		PrintResults(results)
 		return nil
 	},
 }
 
+func createOneProject(wd string, groupID int64, name string, proto string) TaskResult {
+	path := slugify(name)
+
+	createCmd := exec.Command("glab", "api", "/projects", "-X", "POST",
+		"-f", "name="+name,
+		"-f", "path="+path,
+		"-f", "namespace_id="+strconv.FormatInt(groupID, 10),
+		"-f", "visibility=public",
+	)
+
+	out, err := createCmd.Output()
+	if err != nil {
+		// Check nếu lỗi do trùng tên hoặc lỗi mạng
+		return TaskResult{Name: name, Status: "ERR", Message: "GitLab create failed"}
+	}
+
+	var pr glProject
+	if err := json.Unmarshal(out, &pr); err != nil {
+		return TaskResult{Name: name, Status: "ERR", Message: "Parse response failed"}
+	}
+
+	// B. Clone
+	dest := filepath.Join(wd, name)
+	repoURL := pr.HTTPURLToRepo
+	if proto == "ssh" {
+		repoURL = pr.SSHURLToRepo
+	}
+
+	if err := exec.Command("git", "clone", "--quiet", repoURL, dest).Run(); err != nil {
+		return TaskResult{Name: name, Status: "ERR", Message: "Created but Clone failed"}
+	}
+
+	return TaskResult{Name: name, Status: "OK", Message: "Ready"}
+}
+
+func refreshProjectMeta(ashDir string, groupID int64) {
+	prjs, _ := apiListProjects(groupID)
+	if len(prjs) > 0 {
+		var newMeta subgroupMeta
+		// Đọc lại để giữ thông tin cũ (nếu có field khác), ở đây tui đơn giản hóa
+		// Nếu file không tồn tại hoặc lỗi đọc thì coi như empty struct
+		readJSON(filepath.Join(ashDir, "subgroup.json"), &newMeta)
+
+		idents := make([]projectIdent, 0, len(prjs))
+		for _, p := range prjs {
+			idents = append(idents, projectIdent{ID: p.ID, Path: p.Path, Name: p.Name})
+		}
+		newMeta.Projects = idents
+		// Giữ lại Group ID cũ nếu cần, hoặc giả định apiListProjects là đúng
+		// Ở đây ta chỉ update list project
+		writeJSON(filepath.Join(ashDir, "subgroup.json"), newMeta)
+	}
+}
+
 func init() {
 	projectCmd.AddCommand(projectCreateCmd)
-
-	projectCreateCmd.Flags().StringVarP(&projectName, "name", "n", "", "Name of project")
-	projectCreateCmd.Flags().IntVarP(&projectCount, "count", "c", 0, "Count of project")
-	projectCreateCmd.Flags().StringVarP(&projectPrefix, "prefix", "p", "", "Create multiple project with Prefix")
-	projectCreateCmd.Flags().StringVarP(&projectProto, "proto", "g", "https", "Clone project ( https | ssh )")
+	projectCreateCmd.Flags().IntVarP(&createProjectCount, "count", "c", 0, "Number of projects")
+	projectCreateCmd.Flags().StringVarP(&createProjectPrefix, "prefix", "p", "", "Prefix for batch creation")
+	projectCreateCmd.Flags().StringVarP(&createProjectProto, "proto", "g", "https", "Protocol (https/ssh)")
 }

cmd/project_create.go

@@ -3,48 +3,94 @@ package cmd
 import (
 	"fmt"
 	"os"
+	"os/exec"
 	"path/filepath"
+	"sync"
 
 	"github.com/spf13/cobra"
 )
 
 var projectSyncCmd = &cobra.Command{
-	Use: "sync",
+	Use:   "sync",
+	Short: "Sync all projects (Clone/Pull)",
+	RunE: func(cmd *cobra.Command, args []string) error {
+		wd, err := os.Getwd()
+		if err != nil {
+			return err
+		}
+		subMetaPath := filepath.Join(wd, ".ash", "subgroup.json")
+		if !fileExists(subMetaPath) {
+			return fmt.Errorf("not in a subgroup folder")
+		}
 
-	Short: "Sync projects between GitLab and local workspace",
-	Long: `Synchronize all projects in the current subgroup between GitLab and the local workspace.
+		var meta subgroupMeta
+		if err := readJSON(subMetaPath, &meta); err != nil {
+			return err
+		}
 
-New projects on GitLab will be cloned automatically.
-Deleted projects on GitLab will be removed from subgroup.json.
+		if len(meta.Projects) == 0 {
+			fmt.Printf("%s[INFO] No projects found in metadata.%s\n", Cyan, Reset)
+			return nil
+		}
 
-Use the --clean flag to also delete local folders corresponding
-to projects that no longer exist on GitLab.
+		// EXECUTE
+		var results []TaskResult
+		var mu sync.Mutex
 
-Examples:
-  ash project sync
-    → Updates metadata only (keeps local folders)
-  ash project sync --clean
-    → Deletes local folders for removed projects and updates metadata.`,
-	SilenceUsage:  true,
-	SilenceErrors: true,
+		title := fmt.Sprintf("Syncing %d project(s)...", len(meta.Projects))
 
-	RunE: func(cmd *cobra.Command, args []string) error {
-		wd, err := os.Getwd()
+		err = RunWithSpinner(title, func() error {
+			var wg sync.WaitGroup
+			sem := make(chan struct{}, 5) // Limit 5 concurrent threads
+
+			for _, p := range meta.Projects {
+				wg.Add(1)
+				go func(proj projectIdent) {
+					defer wg.Done()
+					sem <- struct{}{}
+					defer func() { <-sem }()
+
+					res := syncOneProject(wd, proj)
+
+					mu.Lock()
+					results = append(results, res)
+					mu.Unlock()
+				}(p)
+			}
+			wg.Wait()
+			return nil
+		})
 		if err != nil {
-			return fmt.Errorf("getwd failed: %w", err)
+			return err
 		}
-		ashDir := filepath.Join(wd, ".ash")
-		// groupMetaPath := filepath.Join(ashDir, "groups.json")
-		subMetaPath := filepath.Join(ashDir, "subgroups.json")
+		PrintResults(results)
+		return nil
+	},
+}
 
-		if !fileExists(subMetaPath) {
-			return fmt.Errorf(RED+"this look like a group folder (found %s); run from the subgroup folder"+RED, subMetaPath)
+func syncOneProject(wd string, p projectIdent) TaskResult {
+	targetDir := filepath.Join(wd, p.Name)
+
+	// Case 1: Folder missing -> CLONE
+	if !fileExists(targetDir) {
+		// Dùng glab repo clone để nó tự handle auth/url
+		err := exec.Command("glab", "repo", "clone", p.Path, targetDir).Run()
+		if err != nil {
+			return TaskResult{Name: p.Name, Status: "ERR", Message: "Clone failed"}
 		}
+		return TaskResult{Name: p.Name, Status: "NEW", Message: "Cloned"}
+	}
 
-		println(GREEN + "Sync called" + GREEN)
+	// Case 2: Folder exists -> PULL
+	if !fileExists(filepath.Join(targetDir, ".git")) {
+		return TaskResult{Name: p.Name, Status: "SKIP", Message: "Not a git repo"}
+	}
 
-		return nil
-	},
+	err := exec.Command("git", "-C", targetDir, "pull", "--quiet").Run()
+	if err != nil {
+		return TaskResult{Name: p.Name, Status: "ERR", Message: "Pull failed (Conflict?)"}
+	}
+	return TaskResult{Name: p.Name, Status: "OK", Message: "Updated"}
 }
 
 func init() {