nCovTrack-Backend/handler/user.go

package handler

import (
	"nCovTrack-Backend/global"
	"nCovTrack-Backend/models"
	"nCovTrack-Backend/service/user"
	"nCovTrack-Backend/utils"
	"regexp"

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

//UserRegisterHandler user register
// @Tags User
// @Accept json
// @Produce json
// @Summary user register account
// @Success 200 {object} utils.GinResponse{data=models.BackUser}
// @Router /user/register [post]
// @Param json body models.UserRegister true "json"
func UserRegisterHandler(c *gin.Context) {
	jsonMap := bindJsonStruct[models.UserRegister](c)
	if jsonMap == nil {
		return
	}
	registered := user.NoDuplicatePhoneOrEmail(jsonMap["phone"].(string), jsonMap["email"].(string))
	if !registered {
		utils.Success(c, 200, 200, "Registered", nil)
		return
	}
	colMap := models.MapJ2c[models.BackUser](jsonMap, true)
	user.Register(colMap)
	utils.Succ(c, nil)
}

//UserApproveHandler admin approve account
// @Tags User
// @Accept json
// @Produce json
// @Summary admin approve account, user can use account after approved
// @Success 200 {object} utils.GinResponse{}
// @Router /user/approve [post]
// @Param Token header string true "token"
// @Param json body models.UserApprove true "json"
func UserApproveHandler(c *gin.Context) {
	claims := utils.ClaimsFromHeader(c)
	if claims.Role != global.ROLE_ID_MAP["ADMIN"] {
		Forbidden(c)
		return
	}
	jsonMap := bindJsonStruct[models.UserApprove](c)
	if jsonMap == nil {
		return
	}
	if !user.ApproveRegister(claims, jsonMap["email"].(string), jsonMap["pass"].(bool)) {
		RequestErr(c, "approve failed")
		return
	}
	utils.Succ(c, nil)
}

//UserLoginHandler admin approve account
// @Tags User
// @Accept json
// @Produce json
// @Summary user login
// @Success 200 {object} utils.GinResponse{}
// @Router /user/login [post]
// @Param json body models.UserLogin true "json"
func UserLoginHandler(c *gin.Context) {
	jsonMap := bindJsonStruct[models.UserLogin](c)
	if jsonMap == nil {
		return
	}
	token := user.Login(jsonMap)
	if token == "" {
		// Login failed reasons as follow:
		//      1. account or password incorrect
		//      2. account apply not pass
		utils.Succ(c, map[string]interface{}{"msg": "failed"})
		return
	}
	c.Writer.Header().Set("X-Token", token)
	utils.Succ(c, nil)
}

//ListRegisterUserHandler list register infos
// @Tags User
// @Produce json
// @Summary list register infos, which is to be approved
// @Success 200 {object} utils.GinResponse{}
// @Router /user/registers/{approved} [get]
// @Param Token header string true "token"
// @Param approved path string true "string enums" Enums(approved, notapproved)
func ListRegisterUserHandler(c *gin.Context) {
	approved := c.Param("approved")
	claims := utils.ClaimsFromHeader(c)
	if claims.Role != global.ROLE_ID_MAP["ADMIN"] {
		Forbidden(c)
		return
	}
	var registers *[]map[string]interface{}
	if approved == "notapproved" {
		registers = user.ListRegister(claims)
	} else if approved == "approved" {
		registers = user.ListApprovedRegister(claims)
	} else {
		UrlNotFound(c)
		return
	}
	utils.Succ(c, registers)
}

//SendEmailCodeHandler send verify code
// @Tags User
// @Produce json
// @Summary send verify code
// @Success 200 {object} utils.GinResponse{}
// @Router /user/code/{email} [get]
// @Param email path string true "email"
func SendEmailCodeHandler(c *gin.Context) {
	email := c.Param("email")
	match, _ := regexp.Match("^[\\w-\\.]+@([\\w-]+\\.)+[\\w-]{2,4}$", []byte(email))
	if !match {
		RequestErr(c, map[string]interface{}{"email": email})
		return
	}
	if ok := user.SendEmailCode(email); !ok {
		ServerErr(c, "Send Email Failed")
		return
	}
	utils.Succ(c, nil)
}

//VerifyEmailCodeHandler verify code
// @Tags User
// @Produce json
// @Summary send verify code
// @Success 200 {object} utils.GinResponse{}
// @Router /user/code/{email}/{code} [get]
// @Param email path string true "email"
// @Param code path string true "code"
func VerifyEmailCodeHandler(c *gin.Context) {
	email := c.Param("email")
	code := c.Param("code")
	emailMatch, _ := regexp.Match("^[\\w-\\.]+@([\\w-]+\\.)+[\\w-]{2,4}$", []byte(email))
	codeMatch, _ := regexp.Match("^[\\w]{6}$", []byte(code))
	if !codeMatch || !emailMatch {
		RequestErr(c, map[string]interface{}{"email": email, "code": code})
		return
	}
	utils.Succ(c, user.VerifyEmailCode(email, code))
}

//ChangePasswordHandler change user's password
// @Tags User
// @Accept json
// @Produce json
// @Summary change user's password
// @Success 200 {object} utils.GinResponse{}
// @Router /user/chpwd [post]
// @Param json body models.UserChangePwd true "json"
func ChangePasswordHandler(c *gin.Context) {
	jsonMap := bindJsonStruct[models.UserChangePwd](c)
	if jsonMap == nil {
		return
	}
	utils.Succ(c, map[string]interface{}{"success": user.ChangePassword(jsonMap)})
}