feat(tasks): implement bulk task actions (complete/delete)

backend/controllers/complete_tasks.go

@@ -0,0 +1,81 @@
+package controllers
+
+import (
+	"ccsync_backend/models"
+	"ccsync_backend/utils/tw"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+)
+
+// BulkCompleteTaskHandler godoc
+// @Summary Bulk complete tasks
+// @Description Mark multiple tasks as completed in Taskwarrior
+// @Tags Tasks
+// @Accept json
+// @Produce json
+// @Param task body models.BulkCompleteTaskRequestBody true "Bulk task completion details"
+// @Success 202 {string} string "Bulk task completion accepted for processing"
+// @Failure 400 {string} string "Invalid request - missing or empty taskuuids"
+// @Failure 405 {string} string "Method not allowed"
+// @Router /complete-tasks [post]
+func BulkCompleteTaskHandler(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodPost {
+		http.Error(w, "Invalid request method", http.StatusMethodNotAllowed)
+		return
+	}
+
+	body, err := io.ReadAll(r.Body)
+	if err != nil {
+		http.Error(w, fmt.Sprintf("error reading request body: %v", err), http.StatusBadRequest)
+		return
+	}
+	defer r.Body.Close()
+
+	var requestBody models.BulkCompleteTaskRequestBody
+
+	if err := json.Unmarshal(body, &requestBody); err != nil {
+		http.Error(w, fmt.Sprintf("error decoding request body: %v", err), http.StatusBadRequest)
+		return
+	}
+
+	email := requestBody.Email
+	encryptionSecret := requestBody.EncryptionSecret
+	uuid := requestBody.UUID
+	taskUUIDs := requestBody.TaskUUIDs
+
+	if len(taskUUIDs) == 0 {
+		http.Error(w, "taskuuids is required and cannot be empty", http.StatusBadRequest)
+		return
+	}
+
+	logStore := models.GetLogStore()
+
+	// Create a *single* job for all UUIDs
+	job := Job{
+		Name: "Bulk Complete Tasks",
+		Execute: func() error {
+			logStore.AddLog("INFO", fmt.Sprintf("[Bulk Complete] Starting %d tasks", len(taskUUIDs)), uuid, "Bulk Complete Task")
+
+			failedTasks, err := tw.CompleteTasksInTaskwarrior(email, encryptionSecret, uuid, taskUUIDs)
+
+			for taskUUID, errMsg := range failedTasks {
+				logStore.AddLog("ERROR", fmt.Sprintf("[Bulk Complete] Failed: %s (%s)", taskUUID, errMsg), uuid, "Bulk Complete Task")
+			}
+
+			if err != nil {
+				logStore.AddLog("ERROR", fmt.Sprintf("[Bulk Complete] Sync error: %v", err), uuid, "Bulk Complete Task")
+				return err
+			}
+
+			successCount := len(taskUUIDs) - len(failedTasks)
+			logStore.AddLog("INFO", fmt.Sprintf("[Bulk Complete] Finished: %d succeeded, %d failed", successCount, len(failedTasks)), uuid, "Bulk Complete Task")
+
+			return nil
+		},
+	}
+
+	GlobalJobQueue.AddJob(job)
+	w.WriteHeader(http.StatusAccepted)
+}

backend/controllers/delete_tasks.go

@@ -0,0 +1,80 @@
+package controllers
+
+import (
+	"ccsync_backend/models"
+	"ccsync_backend/utils/tw"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+)
+
+// BulkDeleteTaskHandler godoc
+// @Summary Bulk delete tasks
+// @Description Delete multiple tasks in Taskwarrior
+// @Tags Tasks
+// @Accept json
+// @Produce json
+// @Param task body models.BulkDeleteTaskRequestBody true "Bulk task deletion details"
+// @Success 202 {string} string "Bulk task deletion accepted for processing"
+// @Failure 400 {string} string "Invalid request - missing or empty taskuuids"
+// @Failure 405 {string} string "Method not allowed"
+// @Router /delete-tasks [post]
+func BulkDeleteTaskHandler(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodPost {
+		http.Error(w, "Invalid request method", http.StatusMethodNotAllowed)
+		return
+	}
+
+	body, err := io.ReadAll(r.Body)
+	if err != nil {
+		http.Error(w, fmt.Sprintf("error reading request body: %v", err), http.StatusBadRequest)
+		return
+	}
+	defer r.Body.Close()
+
+	var requestBody models.BulkDeleteTaskRequestBody
+
+	if err := json.Unmarshal(body, &requestBody); err != nil {
+		http.Error(w, fmt.Sprintf("error decoding request body: %v", err), http.StatusBadRequest)
+		return
+	}
+
+	email := requestBody.Email
+	encryptionSecret := requestBody.EncryptionSecret
+	uuid := requestBody.UUID
+	taskUUIDs := requestBody.TaskUUIDs
+
+	if len(taskUUIDs) == 0 {
+		http.Error(w, "taskuuids is required and cannot be empty", http.StatusBadRequest)
+		return
+	}
+
+	logStore := models.GetLogStore()
+
+	job := Job{
+		Name: "Bulk Delete Tasks",
+		Execute: func() error {
+			logStore.AddLog("INFO", fmt.Sprintf("[Bulk Delete] Starting %d tasks", len(taskUUIDs)), uuid, "Bulk Delete Task")
+
+			failedTasks, err := tw.DeleteTasksInTaskwarrior(email, encryptionSecret, uuid, taskUUIDs)
+
+			for taskUUID, errMsg := range failedTasks {
+				logStore.AddLog("ERROR", fmt.Sprintf("[Bulk Delete] Failed: %s (%s)", taskUUID, errMsg), uuid, "Bulk Delete Task")
+			}
+
+			if err != nil {
+				logStore.AddLog("ERROR", fmt.Sprintf("[Bulk Delete] Sync error: %v", err), uuid, "Bulk Delete Task")
+				return err
+			}
+
+			successCount := len(taskUUIDs) - len(failedTasks)
+			logStore.AddLog("INFO", fmt.Sprintf("[Bulk Delete] Finished: %d succeeded, %d failed", successCount, len(failedTasks)), uuid, "Bulk Delete Task")
+
+			return nil
+		},
+	}
+
+	GlobalJobQueue.AddJob(job)
+	w.WriteHeader(http.StatusAccepted)
+}

backend/main.go

@@ -99,6 +99,8 @@ func main() {
 	mux.Handle("/complete-task", rateLimitedHandler(http.HandlerFunc(controllers.CompleteTaskHandler)))
 	mux.Handle("/delete-task", rateLimitedHandler(http.HandlerFunc(controllers.DeleteTaskHandler)))
 	mux.Handle("/sync/logs", rateLimitedHandler(http.HandlerFunc(controllers.SyncLogsHandler)))
+	mux.Handle("/complete-tasks", rateLimitedHandler(http.HandlerFunc(controllers.BulkCompleteTaskHandler)))
+	mux.Handle("/delete-tasks", rateLimitedHandler(http.HandlerFunc(controllers.BulkDeleteTaskHandler)))
 
 	mux.HandleFunc("/health", controllers.HealthCheckHandler)
 

backend/models/request_body.go

@@ -60,3 +60,15 @@ type DeleteTaskRequestBody struct {
 	UUID             string `json:"UUID"`
 	TaskUUID         string `json:"taskuuid"`
 }
+type BulkCompleteTaskRequestBody struct {
+	Email            string   `json:"email"`
+	EncryptionSecret string   `json:"encryptionSecret"`
+	UUID             string   `json:"UUID"`
+	TaskUUIDs        []string `json:"taskuuids"`
+}
+type BulkDeleteTaskRequestBody struct {
+	Email            string   `json:"email"`
+	EncryptionSecret string   `json:"encryptionSecret"`
+	UUID             string   `json:"UUID"`
+	TaskUUIDs        []string `json:"taskuuids"`
+}

backend/utils/tw/complete_tasks.go

@@ -0,0 +1,45 @@
+package tw
+
+import (
+	"ccsync_backend/utils"
+	"fmt"
+	"os"
+)
+
+func CompleteTasksInTaskwarrior(email, encryptionSecret, uuid string, taskUUIDs []string) (map[string]string, error) {
+	failedTasks := make(map[string]string)
+
+	if err := utils.ExecCommand("rm", "-rf", "/root/.task"); err != nil {
+		return nil, fmt.Errorf("error deleting Taskwarrior data: %v", err)
+	}
+
+	tempDir, err := os.MkdirTemp("", "taskwarrior-"+email)
+
+	if err != nil {
+		return nil, fmt.Errorf("failed to create temporary directory: %v", err)
+	}
+	defer os.RemoveAll(tempDir)
+
+	origin := os.Getenv("CONTAINER_ORIGIN")
+	if err := SetTaskwarriorConfig(tempDir, encryptionSecret, origin, uuid); err != nil {
+		return nil, err
+	}
+
+	if err := SyncTaskwarrior(tempDir); err != nil {
+		return nil, err
+	}
+
+	for _, taskuuid := range taskUUIDs {
+		if err := utils.ExecCommandInDir(tempDir, "task", taskuuid, "done", "rc.confirmation=off"); err != nil {
+			failedTasks[taskuuid] = err.Error()
+			continue
+		}
+	}
+
+	// Sync Taskwarrior again
+	if err := SyncTaskwarrior(tempDir); err != nil {
+		return failedTasks, err
+	}
+
+	return failedTasks, nil
+}

backend/utils/tw/delete_tasks.go

@@ -0,0 +1,45 @@
+package tw
+
+import (
+	"ccsync_backend/utils"
+	"fmt"
+	"os"
+)
+
+func DeleteTasksInTaskwarrior(email, encryptionSecret, uuid string, taskUUIDs []string) (map[string]string, error) {
+	failedTasks := make(map[string]string)
+
+	if err := utils.ExecCommand("rm", "-rf", "/root/.task"); err != nil {
+		return nil, fmt.Errorf("error deleting Taskwarrior data: %v", err)
+	}
+
+	tempDir, err := os.MkdirTemp("", "taskwarrior-"+email)
+
+	if err != nil {
+		return nil, fmt.Errorf("failed to create temporary directory: %v", err)
+	}
+	defer os.RemoveAll(tempDir)
+
+	origin := os.Getenv("CONTAINER_ORIGIN")
+	if err := SetTaskwarriorConfig(tempDir, encryptionSecret, origin, uuid); err != nil {
+		return nil, err
+	}
+
+	if err := SyncTaskwarrior(tempDir); err != nil {
+		return nil, err
+	}
+
+	for _, taskuuid := range taskUUIDs {
+		if err := utils.ExecCommandInDir(tempDir, "task", taskuuid, "delete", "rc.confirmation=off"); err != nil {
+			failedTasks[taskuuid] = err.Error()
+			continue
+		}
+	}
+
+	// Sync Taskwarrior again
+	if err := SyncTaskwarrior(tempDir); err != nil {
+		return failedTasks, err
+	}
+
+	return failedTasks, nil
+}

frontend/src/components/HomeComponents/Tasks/TaskDialog.tsx

@@ -42,6 +42,8 @@ export const TaskDialog = ({
   selectedIndex,
   onOpenChange,
   onSelectTask,
+  selectedTaskUUIDs,
+  onCheckboxChange,
   editState,
   onUpdateState,
   allTasks,
@@ -100,6 +102,18 @@ export const TaskDialog = ({
             onSelectTask(task, index);
           }}
         >
+          <TableCell className="py-2" onClick={(e) => e.stopPropagation()}>
+            <input
+              type="checkbox"
+              checked={selectedTaskUUIDs.includes(task.uuid)}
+              disabled={task.status === 'deleted'}
+              onChange={(e) => {
+                e.stopPropagation();
+                onCheckboxChange(task.uuid, e.target.checked);
+              }}
+            />
+          </TableCell>
+
           {/* Display task details */}
           <TableCell className="py-2">
             <span