Implement task uncompletion (#132)

Author: dkhalife

internal/apis/task.go

@@ -1,6 +1,8 @@
 package apis
 
 import (
+	"context"
+	"errors"
 	"fmt"
 	"net/http"
 	"strconv"
@@ -16,6 +18,7 @@ import (
 	auth "dkhalife.com/tasks/core/internal/utils/auth"
 	jwt "github.com/appleboy/gin-jwt/v2"
 	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
 )
 
 type LabelReq struct {
@@ -533,6 +536,65 @@ func (h *TasksAPIHandler) completeTask(c *gin.Context) {
 	})
 }
 
+func (h *TasksAPIHandler) uncompleteTask(c *gin.Context) {
+	currentIdentity := auth.CurrentIdentity(c)
+	log := logging.FromContext(c)
+
+	rawID := c.Param("id")
+	id, err := strconv.Atoi(rawID)
+	if err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{
+			"error": "Invalid task ID",
+		})
+		return
+	}
+
+	task, err := h.tRepo.GetTask(c, id)
+	if err != nil {
+		log.Errorf("error getting task: %s", err.Error())
+		c.JSON(http.StatusInternalServerError, gin.H{
+			"error": "Error getting task",
+		})
+		return
+	}
+
+	if currentIdentity.UserID != task.CreatedBy {
+		c.JSON(http.StatusForbidden, gin.H{
+			"error": "You are not allowed to update this task",
+		})
+		return
+	}
+
+	if err := h.tRepo.UncompleteTask(c, id); err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			c.JSON(http.StatusBadRequest, gin.H{"error": "Task was not completed already"})
+			return
+		}
+		log.Errorf("error uncompleting task: %s", err.Error())
+		c.JSON(http.StatusInternalServerError, gin.H{
+			"error": "Error uncompleting task",
+		})
+		return
+	}
+
+	updatedTask, err := h.tRepo.GetTask(c, id)
+	if err != nil {
+		log.Errorf("error getting updated task: %s", err.Error())
+		c.JSON(http.StatusInternalServerError, gin.H{
+			"error": "Error getting updated task",
+		})
+		return
+	}
+
+	go func(task *models.Task) {
+		h.nRepo.GenerateNotifications(context.Background(), task)
+	}(updatedTask)
+
+	c.JSON(http.StatusOK, gin.H{
+		"task": updatedTask,
+	})
+}
+
 func (h *TasksAPIHandler) GetTaskHistory(c *gin.Context) {
 	currentIdentity := auth.CurrentIdentity(c)
 	log := logging.FromContext(c)
@@ -578,6 +640,7 @@ func TaskRoutes(router *gin.Engine, h *TasksAPIHandler, auth *jwt.GinJWTMiddlewa
 		tasksRoutes.GET("/:id", authMW.ScopeMiddleware(models.ApiTokenScopeTaskRead), h.getTask)
 		tasksRoutes.GET("/:id/history", authMW.ScopeMiddleware(models.ApiTokenScopeTaskRead), h.GetTaskHistory)
 		tasksRoutes.POST("/:id/do", authMW.ScopeMiddleware(models.ApiTokenScopeTaskWrite), h.completeTask)
+		tasksRoutes.POST("/:id/undo", authMW.ScopeMiddleware(models.ApiTokenScopeTaskWrite), h.uncompleteTask)
 		tasksRoutes.POST("/:id/skip", authMW.ScopeMiddleware(models.ApiTokenScopeTaskWrite), h.skipTask)
 		tasksRoutes.PUT("/:id/dueDate", authMW.ScopeMiddleware(models.ApiTokenScopeTaskWrite), h.updateDueDate)
 		tasksRoutes.DELETE("/:id", authMW.ScopeMiddleware(models.ApiTokenScopeTaskWrite), h.deleteTask)

internal/repos/task/task.go

@@ -107,6 +107,30 @@ func (r *TaskRepository) CompleteTask(c context.Context, task *models.Task, user
 	return err
 }
 
+func (r *TaskRepository) UncompleteTask(c context.Context, taskID int) error {
+	return r.db.WithContext(c).Transaction(func(tx *gorm.DB) error {
+		var last models.TaskHistory
+		if err := tx.Where("task_id = ?", taskID).Order("id desc").First(&last).Error; err != nil {
+			return err
+		}
+
+		if err := tx.Delete(&last).Error; err != nil {
+			return err
+		}
+
+		updates := map[string]interface{}{
+			"next_due_date": last.DueDate,
+			"is_active":     true,
+		}
+
+		if err := tx.Model(&models.Task{}).Where("id = ?", taskID).Updates(updates).Error; err != nil {
+			return err
+		}
+
+		return nil
+	})
+}
+
 func (r *TaskRepository) GetTaskHistory(c context.Context, taskID int) ([]*models.TaskHistory, error) {
 	var histories []*models.TaskHistory
 	if err := r.db.WithContext(c).Where("task_id = ?", taskID).Order("due_date desc").Find(&histories).Error; err != nil {

internal/repos/task/task_test.go

@@ -367,6 +367,41 @@ func (s *TaskTestSuite) TestCompleteTask() {
 	s.WithinDuration(*updatedRecurringTask.NextDueDate, nextDueDate, time.Second)
 }
 
+func (s *TaskTestSuite) TestUncompleteTask() {
+	ctx := context.Background()
+	dueDate := time.Now().Add(24 * time.Hour)
+	completedDate := time.Now()
+
+	task := &models.Task{
+		Title:       "Undo Task",
+		CreatedBy:   s.testUser.ID,
+		NextDueDate: &dueDate,
+		IsActive:    true,
+		Frequency: models.Frequency{
+			Type: models.RepeatOnce,
+		},
+	}
+
+	err := s.DB.Create(task).Error
+	s.Require().NoError(err)
+
+	err = s.repo.CompleteTask(ctx, task, s.testUser.ID, nil, &completedDate)
+	s.Require().NoError(err)
+
+	err = s.repo.UncompleteTask(ctx, task.ID)
+	s.Require().NoError(err)
+
+	var updatedTask models.Task
+	err = s.DB.First(&updatedTask, task.ID).Error
+	s.Require().NoError(err)
+	s.True(updatedTask.IsActive)
+	s.WithinDuration(dueDate, *updatedTask.NextDueDate, time.Second)
+
+	var count int64
+	s.DB.Model(&models.TaskHistory{}).Where("task_id = ?", task.ID).Count(&count)
+	s.Equal(int64(0), count)
+}
+
 func (s *TaskTestSuite) TestGetTaskHistory() {
 	ctx := context.Background()
 	dueDate := time.Now().Add(-24 * time.Hour) // Due yesterday