Handling PUT and DELETE Requests with Gin

Welcome to this lesson, where we will focus on handling PUT and DELETE requests to update and delete resources in a web application using the Gin framework. In previous lessons, you've become familiar with setting up a Gin application and handling GET and POST requests. As a quick reminder, Gin is a popular framework in the Go language used to build web applications and APIs efficiently.

Before we dive into the examples, let's briefly go over what PUT and DELETE HTTP methods entail. As part of the fundamentals of building RESTful APIs, these methods play a critical role:

• PUT: This method is used to update existing resources. For instance, if your to-do app has a task with certain attributes, using a PUT request, you can change those attributes to different values.

• DELETE: This method is used to remove resources. When a task is completed and no longer needed in your to-do list, a DELETE request will remove it.

Understanding these methods is crucial as they allow you to modify the state of resources within your web application.

To handle a PUT request that updates a todo item by its ID, you'll need to understand what kind of data is being sent. Here's an example JSON body that you might send with a PUT request to update a todo item:

{
    "title": "Learn HTTP Methods",
    "completed": false
}

This JSON object represents a todo item with the title attribute and a completed status. These are the fields that can be updated.

Let’s look at the code to implement this:

router.go:

package router

import (
    "github.com/gin-gonic/gin"

    "codesignal.com/todoapp/internal/controllers"
)

func SetupRouter() *gin.Engine {
    r := gin.Default()
    r.PUT("/api/todos/:id", controllers.UpdateTodo)
    return r
}

controllers.go:

package controllers

import (
    "net/http"
    "strconv"

    "github.com/gin-gonic/gin"

    "codesignal.com/todoapp/internal/models"
    "codesignal.com/todoapp/internal/services"
)

var todos []models.Todo

func UpdateTodo(c *gin.Context) {
    id, err := strconv.Atoi(c.Param("id"))
    if err != nil {
        c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid ID"})
        return
    }
    var updateData models.Todo
    if err := c.ShouldBindJSON(&updateData); err != nil {
        c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid JSON"})
        return
    }
    if updatedTodo, err := services.UpdateTodoService(id, updateData, todos); err != nil {
        c.JSON(http.StatusNotFound, gin.H{"error": "Todo not found"})
    } else {
        c.JSON(http.StatusOK, updatedTodo)
    }
}

services.go:

package services

import (
    "errors"

    "codesignal.com/todoapp/internal/models"
)

func UpdateTodoService(id int, updateData models.Todo, todos []models.Todo) (*models.Todo, error) {
    for i, todo := range todos {
        if todo.ID == id {
            todos[i].Title = updateData.Title
            todos[i].Completed = updateData.Completed
            return &todos[i], nil
        }
    }
    return nil, errors.New("Todo not found")
}

• Parsing the ID: The path parameter :id is extracted from the URL and converted to an integer. We handle any errors that might arise if the ID provided is invalid.
• Binding JSON Data: The c.ShouldBindJSON method is used to bind the incoming JSON payload to the updateData variable, which is of type Todo. If this binding fails, due to invalid JSON format for instance, a BadRequest response is returned.
• Router Setup and Handler Function: We define the PUT route in the router setup. The route is connected to the UpdateTodo handler function, which handles the logic of managing HTTP status codes and binding JSON data.
• Business Logic and Updating the Resource: The UpdateTodoService function in the business logic package is responsible for the actual updating of the todo item. It loops through the todos list to find the matching Todo by ID and updates the Title and Completed fields.
• Response Handling: If the todo is successfully updated, the new data is sent back with a StatusOK response. If no matching todo is found, a NotFound response is returned.

Now, we'll look at implementing a DELETE request to remove a todo item using its ID:

router.go:

package router

import (
    "github.com/gin-gonic/gin"

    "codesignal.com/todoapp/internal/controllers"
)

func SetupRouter() *gin.Engine {
    r := gin.Default()
    r.DELETE("/api/todos/:id", controllers.DeleteTodo)
    return r
}

controllers.go:

package controllers

import (
    "net/http"
    "strconv"

    "github.com/gin-gonic/gin"
    
    "codesignal.com/todoapp/internal/models"
    "codesignal.com/todoapp/internal/services"
)

var todos []models.Todo

func DeleteTodo(c *gin.Context) {
    id, err := strconv.Atoi(c.Param("id"))
    if err != nil {
        c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid ID"})
        return
    }
    if deletedTodo, err := services.DeleteTodoService(id, todos); err != nil {
        c.JSON(http.StatusNotFound, gin.H{"error": "Todo not found"})
    } else {
        c.JSON(http.StatusOK, deletedTodo)
    }
}

services.go:

package services

import (
    "errors"

    "codesignal.com/todoapp/internal/models"
)

func DeleteTodoService(id int, todos []models.Todo) (*models.Todo, error) {
    for i, todo := range todos {
        if todo.ID == id {
            deletedTodo := todos[i]
            todos = append(todos[:i], todos[i+1:]...)
            return &deletedTodo, nil
        }
    }
    return nil, errors.New("Todo not found")
}

• Extracting and Validating the ID: Similar to PUT, the ID is extracted from the path and validated. Any errors in conversion result in a BadRequest response.
• Router Setup and Handler Function: The DELETE route is defined in the router setup and linked to the DeleteTodo handler function. This function manages the removal process and returns appropriate HTTP status codes.
• Finding and Removing the Resource: The DeleteTodoService function in the business logic package iterates through the todos list to find the todo with the matching ID and removes it from the slice using optimized slice operations.
• Response Management: A successful deletion results in a StatusOK response with the removed todo. If the todo is not found, a NotFound response is provided.

In this lesson, you learned how to handle PUT and DELETE requests with Gin. We explored how these HTTP methods work within RESTful APIs and walked through implementing them in code with practical examples. Understanding how to update and remove resources is fundamental as you continue to build dynamic web applications.

Get ready to apply what you've learned through upcoming practice exercises that will reinforce your understanding by implementing these techniques on your own. You are making excellent progress — keep experimenting and practicing to deepen your knowledge and skills further!