Bulk Uploading Items in the ToDo App

Welcome to our lesson on enhancing the ToDo app with a Bulk Uploading feature. The focus of today's session is on improving the app's efficiency by allowing multiple tasks to be added in one go. This functionality is particularly useful when you need to add multiple items simultaneously, saving time and effort.

By the end of this lesson, you’ll understand how to implement the bulk uploading feature in the ToDo app using Gin, a web framework for Go. You will learn how to set up a route, manage requests, and validate data effectively. Let's dive in!

To handle bulk uploading in our app, the first step is to register a new route in the router. The RegisterRoutes function helps us achieve this:

package router

import (
    "github.com/gin-gonic/gin"
    
    "codesignal.com/todoapp/controllers"
)

func RegisterRoutes(router *gin.Engine) {
    // Register the bulk upload route
    router.POST("/api/todos/bulk", controllers.BulkUploadTodos)
}

Here is what's happening:

• We define a POST route /api/todos/bulk, which is titled meaningfully to reflect that it handles bulk operations.
• We use router.POST to bind the route to the BulkUploadTodos function, ensuring the controller manages incoming requests appropriately.

This structure helps keep the router neat and the responsibility of request handling delegated to the controller, adhering to the principle of separation of concerns.

Once a POST request hits the /api/todos/bulk endpoint, the corresponding controller function, BulkUploadTodos, processes it:

package controllers

import (
    "net/http"
    
    "github.com/gin-gonic/gin"
    
    "codesignal.com/todoapp/services"
    "codesignal.com/todoapp/models"
    "codesignal.com/todoapp/utils"
)

var todos = make([]models.Todo, 0) // Initialize an empty todos slice

func BulkUploadTodos(c *gin.Context) {
    var newTodos []models.Todo

    if err := c.ShouldBindJSON(&newTodos); err != nil {
        c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid JSON payload"})
        return
    }

    duplicates := utils.CheckForDuplicates(newTodos)
    if len(duplicates) > 0 {
        c.JSON(http.StatusBadRequest, gin.H{"error": "Duplicate todos found", "duplicates": duplicates})
        return
    }

    addedTodos := services.AddTodos(&todos, newTodos)
    c.JSON(http.StatusCreated, addedTodos)
}

Let's break this down:

• We use c.ShouldBindJSON(&newTodos) to bind incoming JSON data to a newTodos slice. This method checks the request's body format and validates the JSON structure.
• If the payload contains invalid JSON, it responds with a 400 Bad Request status.
• To ensure every todo item is unique, we call utils.CheckForDuplicates(newTodos) to identify any repeating entries.
• If duplicates are found, a similar 400 Bad Request response is sent, specifying the duplicate titles.
• Finally, services.AddTodos appends the valid todos, and a 201 Created response is returned with the newly added todos.

The service layer processes the validated data and adds it to the maintained todo list, assigning unique IDs:

package services

import "codesignal.com/todoapp/models"

func AddTodos(todos *[]models.Todo, newTodos []models.Todo) []models.Todo {
    for i := range newTodos {
        newTodos[i].ID = len(*todos) + 1 + i
        *todos = append(*todos, newTodos[i])
    }
    return newTodos
}

Here's how this works:

• The AddTodos function iterates over newTodos, assigning each a unique ID to maintain data integrity.
• IDs are computed based on the current length of the todos already stored, ensuring no duplication.
• Each new todo is appended to the existing todos list, making the updated list available for future requests.

Checking for and managing duplicates ensure our data's consistency and prevents unwanted redundancy:

package utils

import "codesignal.com/todoapp/models"

func CheckForDuplicates(todos []models.Todo) []string {
    titleMap := make(map[string]bool)
    duplicates := []string{}

    for _, todo := range todos {
        if _, found := titleMap[todo.Title]; found {
            duplicates = append(duplicates, todo.Title)
        } else {
            titleMap[todo.Title] = true
        }
    }

    return duplicates
}

This function operates by:

• Maintaining a map of todo titles, where each entry's existence is checked.
• Titles found more than once are collected as duplicates.
• Returning duplicate titles allows our controller to respond with specific information on what entries need corrective attention.

When making a bulk upload request to our ToDo app, the payload should be a JSON array of todo items, each represented as an object with the necessary fields. Note that the ID field is managed by the server and shouldn't be included in the request.

A typical JSON payload might look like this:

[
    {
        "title": "Buy groceries",
        "completed": false
    },
    {
        "title": "Read book",
        "completed": false
    }
]

To test this request in a terminal using curl, you can use the following command:

curl -X POST http://localhost:8080/api/todos/bulk \
     -H "Content-Type: application/json" \
     -d '[
            {"title": "Buy groceries", "completed": false},
            {"title": "Read book", "completed": false}
         ]'

This command sends a POST request to the specified endpoint with a JSON payload containing multiple todo items, effectively demonstrating the bulk uploading feature in action.

Throughout this lesson, you've progressively built and understood the bulk uploading feature for the ToDo app utilizing Gin. We’ve seen how to register routes, handle and validate incoming requests, manage data services, and ensure the integrity of our todos through duplicate checks.

Moving forward, as you practice and engage with the exercises, think about the practical applications of bulk data operations beyond our ToDo app scenario. Exploring these concepts enhances your ability to create more efficient and user-friendly applications.

You're well on your way to making a highly functional ToDo app! Keep up the great work as you tackle the practice problems and further refine these new skills.