430 lines
10 KiB
Go
430 lines
10 KiB
Go
package api
|
|
|
|
import (
|
|
"errors"
|
|
"net/http"
|
|
"strings"
|
|
"time"
|
|
|
|
_ "github.com/FernandoJVideira/simple_bank/docs"
|
|
"github.com/FernandoJVideira/simple_bank/internal/auth"
|
|
db "github.com/FernandoJVideira/simple_bank/internal/db/sqlc"
|
|
"github.com/FernandoJVideira/simple_bank/internal/handlers/http/response"
|
|
"github.com/FernandoJVideira/simple_bank/internal/service"
|
|
"github.com/gin-gonic/gin"
|
|
"github.com/google/uuid"
|
|
)
|
|
|
|
type createUserRequest struct {
|
|
Username string `json:"username" binding:"required,alphanum"`
|
|
Password string `json:"password" binding:"required,min=6"`
|
|
FullName string `json:"full_name" binding:"required"`
|
|
Email string `json:"email" binding:"required,email"`
|
|
}
|
|
|
|
type userResponse struct {
|
|
Username string `json:"username"`
|
|
FullName string `json:"full_name"`
|
|
Email string `json:"email"`
|
|
PasswordChangedAt time.Time `json:"password_changed_at"`
|
|
CreatedAt time.Time `json:"created_at"`
|
|
}
|
|
|
|
func newUserResponse(user db.User) userResponse {
|
|
return userResponse{
|
|
Username: user.Username,
|
|
FullName: user.FullName,
|
|
Email: user.Email,
|
|
PasswordChangedAt: user.PasswordChangedAt,
|
|
CreatedAt: user.CreatedAt,
|
|
}
|
|
}
|
|
|
|
// CreateUser godoc
|
|
// @Summary Create a new user
|
|
// @Description Register a new user account
|
|
// @Tags auth
|
|
// @Accept json
|
|
// @Produce json
|
|
// @Param request body createUserRequest true "User registration details"
|
|
// @Success 201 {object} response.JSONResponse{data=userResponse}
|
|
// @Failure 400 {object} response.JSONResponse
|
|
// @Failure 500 {object} response.JSONResponse
|
|
// @Router /v1/auth/register [post]
|
|
func (s *Server) createUser(ctx *gin.Context) {
|
|
var req createUserRequest
|
|
var resp response.JSONResponse
|
|
|
|
if err := ctx.ShouldBindJSON(&req); err != nil {
|
|
resp = response.JSONResponse{
|
|
Success: false,
|
|
Error: err.Error(),
|
|
}
|
|
ctx.JSON(http.StatusBadRequest, resp)
|
|
return
|
|
}
|
|
|
|
result, err := s.userService.CreateUser(ctx, service.RegisterUserRequest{
|
|
Username: req.Username,
|
|
Password: req.Password,
|
|
FullName: req.FullName,
|
|
Email: req.Email,
|
|
})
|
|
|
|
if err != nil {
|
|
errMessage := err.Error()
|
|
if db.ErrorCode(err) == db.UniqueViolation {
|
|
|
|
resp = response.JSONResponse{
|
|
Success: false,
|
|
Error: errMessage,
|
|
}
|
|
ctx.JSON(http.StatusForbidden, resp)
|
|
return
|
|
}
|
|
|
|
resp = response.JSONResponse{
|
|
Success: false,
|
|
Error: err.Error(),
|
|
}
|
|
ctx.JSON(http.StatusInternalServerError, resp)
|
|
return
|
|
}
|
|
|
|
resp = response.JSONResponse{
|
|
Success: true,
|
|
Message: "User created successfully",
|
|
Data: newUserResponse(result.User),
|
|
}
|
|
|
|
ctx.JSON(http.StatusCreated, resp)
|
|
}
|
|
|
|
type getUserRequest struct {
|
|
Username string `uri:"username" binding:"required,alphanum"`
|
|
}
|
|
|
|
func (s *Server) getUser(ctx *gin.Context) {
|
|
var req getUserRequest
|
|
var resp response.JSONResponse
|
|
|
|
if err := ctx.ShouldBindUri(&req); err != nil {
|
|
resp = response.JSONResponse{
|
|
Success: false,
|
|
Error: err.Error(),
|
|
}
|
|
ctx.JSON(http.StatusBadRequest, resp)
|
|
return
|
|
}
|
|
|
|
user, err := s.userService.GetUser(ctx, req.Username)
|
|
if err != nil {
|
|
if errors.Is(err, db.ErrRecordNotFound) {
|
|
resp = response.JSONResponse{
|
|
Success: false,
|
|
Error: "User not found",
|
|
}
|
|
ctx.JSON(http.StatusNotFound, resp)
|
|
return
|
|
}
|
|
resp = response.JSONResponse{
|
|
Success: false,
|
|
Error: err.Error(),
|
|
}
|
|
ctx.JSON(http.StatusInternalServerError, resp)
|
|
return
|
|
}
|
|
|
|
resp = response.JSONResponse{
|
|
Success: true,
|
|
Message: "User retrieved successfully",
|
|
Data: newUserResponse(*user),
|
|
}
|
|
|
|
ctx.JSON(http.StatusOK, resp)
|
|
}
|
|
|
|
func (s *Server) getCurrentUser(ctx *gin.Context) {
|
|
var resp response.JSONResponse
|
|
|
|
authPayload := ctx.MustGet(authorizationPayloadKey).(*auth.Payload)
|
|
|
|
user, err := s.userService.GetUser(ctx, authPayload.Username)
|
|
if err != nil {
|
|
if errors.Is(err, db.ErrRecordNotFound) {
|
|
resp = response.JSONResponse{
|
|
Success: false,
|
|
Error: "User not found",
|
|
}
|
|
ctx.JSON(http.StatusNotFound, resp)
|
|
return
|
|
}
|
|
resp = response.JSONResponse{
|
|
Success: false,
|
|
Error: err.Error(),
|
|
}
|
|
ctx.JSON(http.StatusInternalServerError, resp)
|
|
return
|
|
}
|
|
|
|
resp = response.JSONResponse{
|
|
Success: true,
|
|
Message: "Current user retrieved successfully",
|
|
Data: newUserResponse(*user),
|
|
}
|
|
|
|
ctx.JSON(http.StatusOK, resp)
|
|
}
|
|
|
|
type UpdateUserRequest struct {
|
|
Username string `json:"username" binding:"required,alphanum"`
|
|
FullName string `json:"full_name" binding:"omitempty,min=3"`
|
|
Email string `json:"email" binding:"omitempty,email"`
|
|
}
|
|
|
|
func (s *Server) updateUser(ctx *gin.Context) {
|
|
var req UpdateUserRequest
|
|
var resp response.JSONResponse
|
|
|
|
authPayload := ctx.MustGet(authorizationPayloadKey).(*auth.Payload)
|
|
|
|
if err := ctx.ShouldBindJSON(&req); err != nil {
|
|
resp = response.JSONResponse{
|
|
Success: false,
|
|
Error: err.Error(),
|
|
}
|
|
ctx.JSON(http.StatusBadRequest, resp)
|
|
return
|
|
}
|
|
|
|
if authPayload.Username != req.Username {
|
|
resp = response.JSONResponse{
|
|
Success: false,
|
|
Error: "Cannot update other user's information",
|
|
}
|
|
ctx.JSON(http.StatusForbidden, resp)
|
|
return
|
|
}
|
|
|
|
params := service.UserUpdateRequest{
|
|
Username: strings.TrimSpace(req.Username),
|
|
}
|
|
|
|
if strings.TrimSpace(req.FullName) != "" {
|
|
params.FullName = &req.FullName
|
|
}
|
|
|
|
if strings.TrimSpace(req.Email) != "" {
|
|
params.Email = &req.Email
|
|
}
|
|
|
|
user, err := s.userService.UpdateUser(ctx, params)
|
|
if err != nil {
|
|
if errors.Is(err, db.ErrRecordNotFound) {
|
|
resp = response.JSONResponse{
|
|
Success: false,
|
|
Error: "User not found",
|
|
}
|
|
ctx.JSON(http.StatusNotFound, resp)
|
|
return
|
|
}
|
|
resp = response.JSONResponse{
|
|
Success: false,
|
|
Error: err.Error(),
|
|
}
|
|
ctx.JSON(http.StatusInternalServerError, resp)
|
|
return
|
|
}
|
|
|
|
resp = response.JSONResponse{
|
|
Success: true,
|
|
Message: "User updated successfully",
|
|
Data: newUserResponse(*user),
|
|
}
|
|
|
|
ctx.JSON(http.StatusOK, resp)
|
|
}
|
|
|
|
type changePasswordRequest struct {
|
|
CurrentPassword string `json:"current_password" binding:"required,min=6"`
|
|
NewPassword string `json:"new_password" binding:"required,min=6"`
|
|
ConfirmPassword string `json:"confirm_password" binding:"required,eqfield=NewPassword"`
|
|
}
|
|
|
|
func (s *Server) changePassword(ctx *gin.Context) {
|
|
var req changePasswordRequest
|
|
var resp response.JSONResponse
|
|
|
|
authPayload := ctx.MustGet(authorizationPayloadKey).(*auth.Payload)
|
|
|
|
if err := ctx.ShouldBindJSON(&req); err != nil {
|
|
resp = response.JSONResponse{
|
|
Success: false,
|
|
Error: err.Error(),
|
|
}
|
|
ctx.JSON(http.StatusBadRequest, resp)
|
|
return
|
|
}
|
|
|
|
updUser, err := s.userService.UpdatePassword(ctx, service.PasswordUpdateRequest{
|
|
Username: authPayload.Username,
|
|
OldPassword: req.CurrentPassword,
|
|
NewPassword: req.NewPassword,
|
|
})
|
|
if err != nil {
|
|
if errors.Is(err, db.ErrRecordNotFound) {
|
|
resp = response.JSONResponse{
|
|
Success: false,
|
|
Error: "User not found",
|
|
}
|
|
ctx.JSON(http.StatusNotFound, resp)
|
|
return
|
|
}
|
|
resp = response.JSONResponse{
|
|
Success: false,
|
|
Error: err.Error(),
|
|
}
|
|
ctx.JSON(http.StatusInternalServerError, resp)
|
|
return
|
|
}
|
|
|
|
resp = response.JSONResponse{
|
|
Success: true,
|
|
Message: "Password changed successfully",
|
|
Data: newUserResponse(*updUser),
|
|
}
|
|
|
|
ctx.JSON(http.StatusOK, resp)
|
|
}
|
|
|
|
type loginUserRequest struct {
|
|
Username string `json:"username" binding:"required,alphanum"`
|
|
Password string `json:"password" binding:"required,min=6"`
|
|
}
|
|
|
|
type loginUserResponse struct {
|
|
SessionID uuid.UUID `json:"session_id"`
|
|
AccessToken string `json:"access_token"`
|
|
AccessTokenExpiresAt time.Time `json:"access_token_expires_at"`
|
|
RefreshToken string `json:"refresh_token"`
|
|
RefreshTokenExpiresAt time.Time `json:"refresh_token_expires_at"`
|
|
User userResponse `json:"user"`
|
|
}
|
|
|
|
func (s *Server) loginUser(ctx *gin.Context) {
|
|
var req loginUserRequest
|
|
var resp response.JSONResponse
|
|
|
|
if err := ctx.ShouldBindJSON(&req); err != nil {
|
|
resp = response.JSONResponse{
|
|
Success: false,
|
|
Error: err.Error(),
|
|
}
|
|
ctx.JSON(http.StatusBadRequest, resp)
|
|
return
|
|
}
|
|
|
|
loginRes, err := s.authService.Login(ctx, service.LoginCredentials{
|
|
Username: req.Username,
|
|
Password: req.Password,
|
|
UserAgent: ctx.Request.UserAgent(),
|
|
ClientIP: ctx.ClientIP(),
|
|
})
|
|
if err != nil {
|
|
statusCode := http.StatusInternalServerError
|
|
errMsg := err.Error()
|
|
|
|
// Map service errors to HTTP codes
|
|
if errors.Is(err, db.ErrRecordNotFound) || strings.Contains(errMsg, "user not found") {
|
|
statusCode = http.StatusNotFound
|
|
} else if strings.Contains(errMsg, "incorrect username or password") {
|
|
statusCode = http.StatusUnauthorized
|
|
}
|
|
|
|
resp = response.JSONResponse{
|
|
Success: false,
|
|
Error: errMsg,
|
|
}
|
|
ctx.JSON(statusCode, resp)
|
|
return
|
|
}
|
|
|
|
resp = response.JSONResponse{
|
|
Success: true,
|
|
Message: "User logged in successfully",
|
|
Data: loginUserResponse{
|
|
SessionID: loginRes.SessionID,
|
|
AccessToken: loginRes.AccessToken,
|
|
AccessTokenExpiresAt: loginRes.AccessTokenExpiresAt,
|
|
RefreshToken: loginRes.RefreshToken,
|
|
RefreshTokenExpiresAt: loginRes.RefreshTokenExpiresAt,
|
|
User: newUserResponse(loginRes.User),
|
|
},
|
|
}
|
|
|
|
ctx.JSON(http.StatusOK, resp)
|
|
}
|
|
|
|
type verifyEmailRequest struct {
|
|
ID int64 `form:"id" binding:"required,min=1"`
|
|
Code string `form:"code" binding:"required,min=32,max=128"`
|
|
}
|
|
|
|
type verifyEmailResponse struct {
|
|
IsVerified bool `json:"is_verified"`
|
|
}
|
|
|
|
func (s *Server) verifyEmail(ctx *gin.Context) {
|
|
var req verifyEmailRequest
|
|
var resp response.JSONResponse
|
|
|
|
if err := ctx.ShouldBindQuery(&req); err != nil {
|
|
resp = response.JSONResponse{
|
|
Success: false,
|
|
Error: err.Error(),
|
|
}
|
|
ctx.JSON(http.StatusBadRequest, resp)
|
|
return
|
|
}
|
|
|
|
result, err := s.userService.VerifyEmail(ctx, service.EmailVerificationRequest{
|
|
EmailID: req.ID,
|
|
SecretCode: req.Code,
|
|
})
|
|
if err != nil {
|
|
if errors.Is(err, db.ErrForeignKeyViolation) {
|
|
resp = response.JSONResponse{
|
|
Success: false,
|
|
Error: "Email verification record not found",
|
|
}
|
|
ctx.JSON(http.StatusForbidden, resp)
|
|
return
|
|
}
|
|
if errors.Is(err, db.ErrCheckViolation) {
|
|
resp = response.JSONResponse{
|
|
Success: false,
|
|
Error: "Invalid verification code",
|
|
}
|
|
ctx.JSON(http.StatusBadRequest, resp)
|
|
return
|
|
}
|
|
|
|
resp = response.JSONResponse{
|
|
Success: false,
|
|
Error: err.Error(),
|
|
}
|
|
ctx.JSON(http.StatusInternalServerError, resp)
|
|
return
|
|
}
|
|
|
|
resp = response.JSONResponse{
|
|
Success: true,
|
|
Message: "Email verified successfully",
|
|
Data: verifyEmailResponse{
|
|
IsVerified: result.User.IsEmailVerified,
|
|
},
|
|
}
|
|
|
|
ctx.JSON(http.StatusOK, resp)
|
|
}
|