รู้จักกับ Middleware

package main

import (
  "fmt"
  "time"

  "github.com/gofiber/fiber/v2"
)

// loggingMiddleware logs the processing time for each request
func loggingMiddleware(c *fiber.Ctx) error {
  // Start timer
  start := time.Now()

  // Process request
  err := c.Next()

  // Calculate processing time
  duration := time.Since(start)

  // Log the information
  fmt.Printf("Request URL: %s - Method: %s - Duration: %s\n", c.OriginalURL(), c.Method(), duration)

  return err
}

func main() {
  app := fiber.New()

  // Use the logging middleware
  app.Use(loggingMiddleware)

  // Setup routes
  app.Get("/", func(c *fiber.Ctx) error {
    return c.SendString("Hello, World!")
  })

  app.Listen(":8080")
}

go get -u github.com/gofiber/jwt/v2

package main

import (
  "time"

  "github.com/gofiber/fiber/v2"
  "github.com/gofiber/jwt/v2"
  "github.com/golang-jwt/jwt/v4"
)

func main() {
  app := fiber.New()

  // JWT Secret Key
  secretKey := "secret"

  // Login route
  app.Post("/login", login(secretKey))

  // JWT Middleware
  app.Use(jwtware.New(jwtware.Config{
    SigningKey: []byte(secretKey),
  }))

  // Protected Book routes
  app.Get("/book", getBooks)
  app.Get("/book/:id", getBook)
  app.Post("/book", createBook)
  app.Put("/book/:id", updateBook)
  app.Delete("/book/:id", deleteBook)

  app.Listen(":8080")
}

// Dummy user for example
var user = struct {
  Email    string
  Password string
}{
  Email:    "[email protected]",
  Password: "password123",
}

func login(secretKey string) fiber.Handler {
  return func(c *fiber.Ctx) error {
    type LoginRequest struct {
      Email    string `json:"email"`
      Password string `json:"password"`
    }

    var request LoginRequest
    if err := c.BodyParser(&request); err != nil {
      return err
    }

    // Check credentials - In real world, you should check against a database
    if request.Email != user.Email || request.Password != user.Password {
      return fiber.ErrUnauthorized
    }

    // Create token
    token := jwt.New(jwt.SigningMethodHS256)

    // Set claims
    claims := token.Claims.(jwt.MapClaims)
    claims["name"] = "John Doe"
    claims["admin"] = true
    claims["exp"] = time.Now().Add(time.Hour * 72).Unix()

    // Generate encoded token
    t, err := token.SignedString([]byte(secretKey))
    if err != nil {
      return c.SendStatus(fiber.StatusInternalServerError)
    }

    return c.JSON(fiber.Map{"token": t})
  }
}

func login(secretKey string) fiber.Handler {
  return func(c *fiber.Ctx) error {
    type LoginRequest struct {
      Email    string `json:"email"`
      Password string `json:"password"`
    }

    var request LoginRequest
    if err := c.BodyParser(&request); err != nil {
      return err
    }

    // Check credentials - In real world, you should check against a database
    if request.Email != user.Email || request.Password != user.Password {
      return fiber.ErrUnauthorized
    }

    // Create token
    token := jwt.New(jwt.SigningMethodHS256)

    // Set claims
    claims := token.Claims.(jwt.MapClaims)
    claims["email"] = user.Email
    claims["role"] = "admin" // example role
    claims["exp"] = time.Now().Add(time.Hour * 72).Unix()

    // Generate encoded token
    t, err := token.SignedString([]byte(secretKey))
    if err != nil {
      return c.SendStatus(fiber.StatusInternalServerError)
    }

    return c.JSON(fiber.Map{"token": t})
  }
}

// UserData represents the user data extracted from the JWT token
type UserData struct {
  Email string
  Role  string
}

// userContextKey is the key used to store user data in the Fiber context
const userContextKey = "user"

// extractUserFromJWT is a middleware that extracts user data from the JWT token
func extractUserFromJWT(c *fiber.Ctx) error {
  user := &UserData{}

  // Extract the token from the Fiber context (inserted by the JWT middleware)
  token := c.Locals("user").(*jwt.Token)
  claims := token.Claims.(jwt.MapClaims)

  fmt.Println(claims)

  user.Email = claims["email"].(string)
  user.Role = claims["role"].(string)

  // Store the user data in the Fiber context
  c.Locals(userContextKey, user)

  return c.Next()
}

func main() {
  app := fiber.New()

  // JWT Secret Key
  secretKey := "secret"

  // Login route
  app.Post("/login", login(secretKey))

  // JWT Middleware
  app.Use(jwtware.New(jwtware.Config{
    SigningKey: []byte(secretKey),
  }))

  // Middleware to extract user data from JWT
  app.Use(extractUserFromJWT)

  // code เรียก router fiber เหมือนเดิม
}

func getBooks(c *fiber.Ctx) error {
  // Retrieve user data from the context
  user := c.Locals(userContextKey).(*UserData)

  // Use the user data (e.g., for authorization, custom responses, etc.)
  fmt.Printf("User Email: %s, Role: %s\n", user.Email, user.Role)

  return c.JSON(books)
}

// isAdmin checks if the user is an admin
func isAdmin(c *fiber.Ctx) error {
  user := c.Locals(userContextKey).(*UserData)

  if user.Role != "admin" {
    return fiber.ErrUnauthorized
  }

  return c.Next()
}

func main() {
  app := fiber.New()

  // JWT Secret Key
  secretKey := "secret"

  // Login route
  app.Post("/login", login(secretKey))

  // JWT Middleware
  app.Use(jwtware.New(jwtware.Config{
    SigningKey: []byte(secretKey),
  }))

  // Middleware to extract user data from JWT
  app.Use(extractUserFromJWT)

  // Group routes under /book
  bookGroup := app.Group("/book")

  // Apply the isAdmin middleware only to the /book routes
  bookGroup.Use(isAdmin)

  // Now, only authenticated admins can access these routes
  bookGroup.Get("/", getBooks)
  bookGroup.Get("/:id", getBook)
  bookGroup.Post("/", createBook)
  bookGroup.Put("/:id", updateBook)
  bookGroup.Delete("/:id", deleteBook)

  app.Listen(":8080")
}