handler.go

package main

import (
	"net/http"

	"github.com/gin-gonic/gin"
)

type CheckPasswordRequest struct {
	Password string `json:"password" binding:"required"`
}

type CheckPasswordResponse struct {
	PasswordHash string `json:"passwordHash"`
	BreachCount  uint64 `json:"breachCount"`
	IsLeaked     bool   `json:"leaked"`
}

type HashResponse struct {
	Hash  string `json:"hash"`
	Count uint64 `json:"count"`
}

type ErrorResponse struct {
	Error string `json:"error"`
}

func GetByHashHandler(ps *PasswordService) gin.HandlerFunc {
	return func(c *gin.Context) {
		passwordHash := c.Param("hash")

		if passwordHash == "" {
			respondWithError(c, http.StatusBadRequest, "Missing passwordHash param!")
			return
		}

		passwordHashObj, err := ps.GetByHash(passwordHash)

		if err != nil {
			respondWithError(c, http.StatusInternalServerError, err.Error())
			return
		}

		if passwordHashObj == nil {
			respondWithError(c, http.StatusNotFound, "Hash not found")
			return
		}

		c.JSON(http.StatusOK, HashResponse{
			Hash:  passwordHashObj.Hash,
			Count: passwordHashObj.Count,
		})
	}
}

func CheckPasswordHandler(ps *PasswordService) gin.HandlerFunc {
	return func(c *gin.Context) {
		var request CheckPasswordRequest
		if err := c.ShouldBindJSON(&request); err != nil {
			respondWithError(c, http.StatusBadRequest, "Invalid request: password field is required")
			return
		}

		hashedPassword := ps.HashPassword(request.Password)
		passwordHash, err := ps.Check(hashedPassword)

		if err != nil {
			respondWithError(c, http.StatusInternalServerError, err.Error())
			return
		}

		response := CheckPasswordResponse{
			PasswordHash: hashedPassword,
			BreachCount:  0,
			IsLeaked:     false,
		}

		if passwordHash != nil {
			response.BreachCount = passwordHash.Count
			response.IsLeaked = true
		}

		c.JSON(http.StatusOK, response)
	}
}

func respondWithError(c *gin.Context, code int, message string) {
	response := ErrorResponse{
		Error: message,
	}
	c.JSON(code, response)
}