Merge branch 'main' into 669-fix-events

backend/constants/email.go

@@ -1,3 +1,7 @@
 package constants
 
-const DOMAIN string = "@generatesac.davidoduneye.com"
+const (
+	DOMAIN             string = "@generatesac.davidoduneye.com"
+	ONBOARDING_EMAIL   string = "onboarding" + DOMAIN
+	DEFAULT_FROM_EMAIL string = "no-reply" + DOMAIN
+)

backend/entities/auth/base/controller.go

@@ -51,6 +51,40 @@ func (a *AuthController) Login(c *fiber.Ctx) error {
 	return c.Status(http.StatusOK).JSON(user)
 }
 
+// Register godoc
+//
+// @Summary		Registers a user
+// @Description	Registers a user
+// @ID			register-user
+// @Tags      	auth
+// @Accept		json
+// @Produce		json
+// @Param		userBody	body	models.CreateUserRequestBody	true	"User Body"
+// @Success		201	  {object}	    models.User
+// @Failure     400   {object}      error
+// @Failure     404   {object}		error
+// @Failure     500   {object}      error
+// @Router		/auth/register  [post]
+func (a *AuthController) Register(c *fiber.Ctx) error {
+	var userBody models.CreateUserRequestBody
+
+	if err := c.BodyParser(&userBody); err != nil {
+		return utilities.InvalidJSON()
+	}
+
+	user, tokens, err := a.authService.Register(userBody)
+	if err != nil {
+		return err
+	}
+
+	err = auth.SetResponseTokens(c, tokens)
+	if err != nil {
+		return err
+	}
+
+	return c.Status(http.StatusCreated).JSON(user)
+}
+
 // Refresh godoc
 //
 // @Summary		Refreshes a user's access token

backend/entities/auth/base/routes.go

@@ -4,13 +4,13 @@ import (
 	"github.com/GenerateNU/sac/backend/types"
 )
 
-func Auth(params types.RouteParams) AuthServiceInterface {
-	authService := NewAuthService(params.ServiceParams)
-	authController := NewAuthController(authService)
+func Auth(params types.RouteParams) {
+	authController := NewAuthController(NewAuthService(params.ServiceParams))
 
 	// api/v1/auth/*
 	auth := params.Router.Group("/auth")
 
+	auth.Post("/register", authController.Register)
 	auth.Post("/logout", authController.Logout)
 	auth.Post("/login", authController.Login)
 	auth.Post("/refresh", authController.Refresh)
@@ -22,6 +22,4 @@ func Auth(params types.RouteParams) AuthServiceInterface {
 	// TODO: rate limit
 	auth.Post("/forgot-password", authController.ForgotPassword)
 	auth.Post("/verify-reset", authController.VerifyPasswordResetToken)
-
-	return authService
 }

backend/entities/auth/base/service.go

@@ -20,6 +20,7 @@ import (
 
 type AuthServiceInterface interface {
 	GetRole(id string) (*models.UserRole, error)
+	Register(userBody models.CreateUserRequestBody) (*models.User, *auth.Token, error)
 	Login(userBody models.LoginUserResponseBody) (*models.User, *auth.Token, error)
 	Refresh(refreshToken string) (*auth.Token, error)
 	Logout(c *fiber.Ctx) error
@@ -79,6 +80,49 @@ func (a *AuthService) Login(loginBody models.LoginUserResponseBody) (*models.Use
 	return user, tokens, nil
 }
 
+func (a *AuthService) Register(userBody models.CreateUserRequestBody) (*models.User, *auth.Token, error) {
+	if err := utilities.Validate(a.Validate, userBody); err != nil {
+		return nil, nil, err
+	}
+
+	if err := auth.ValidatePassword(userBody.Password); err != nil {
+		return nil, nil, err
+	}
+
+	user, err := utilities.MapRequestToModel(userBody, &models.User{})
+	if err != nil {
+		return nil, nil, err
+	}
+
+	passwordHash, err := auth.ComputeHash(userBody.Password)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	user.Email = utilities.NormalizeEmail(userBody.Email)
+	user.PasswordHash = *passwordHash
+
+	if err := a.Integrations.Email.SendWelcomeEmail(fmt.Sprintf("%s %s", user.FirstName, user.LastName), user.Email); err != nil {
+		return nil, nil, fmt.Errorf("failed to send welcome email: %w", err)
+	}
+
+	user, err = CreateUser(a.DB, user)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	if err := a.SendCode(user.Email); err != nil {
+		return nil, nil, err
+	}
+
+	_, tokens, err := a.Login(models.LoginUserResponseBody{Email: user.Email, Password: userBody.Password})
+	if err != nil {
+		return nil, nil, err
+	}
+
+	return user, tokens, nil
+}
+
 func (a *AuthService) Refresh(refreshToken string) (*auth.Token, error) {
 	claims, err := a.JWT.ExtractClaims(refreshToken, auth.RefreshToken)
 	if err != nil {

backend/entities/auth/base/transactions.go

@@ -10,6 +10,17 @@ import (
 	"gorm.io/gorm"
 )
 
+func CreateUser(db *gorm.DB, user *models.User) (*models.User, error) {
+	if err := db.Create(user).Error; err != nil {
+		if errors.Is(err, gorm.ErrDuplicatedKey) {
+			return nil, utilities.ErrDuplicate
+		}
+		return nil, err
+	}
+
+	return user, nil
+}
+
 func GetToken(db *gorm.DB, token string, tokenType models.VerificationType) (*models.Verification, error) {
 	tokenModel := models.Verification{}
 	if err := db.Where("token = ? AND type = ?", token, tokenType).First(&tokenModel).Error; err != nil {

backend/entities/categories/base/controller.go

@@ -3,9 +3,9 @@ package base
 import (
 	"net/http"
 
-	"github.com/GenerateNU/sac/backend/constants"
 	"github.com/GenerateNU/sac/backend/entities/models"
 	"github.com/GenerateNU/sac/backend/utilities"
+	"github.com/garrettladley/fiberpaginate"
 
 	"github.com/gofiber/fiber/v2"
 )
@@ -64,7 +64,12 @@ func (cat *CategoryController) CreateCategory(c *fiber.Ctx) error {
 // @Failure     500   {string}      error
 // @Router		/categories/  [get]
 func (cat *CategoryController) GetCategories(c *fiber.Ctx) error {
-	categories, err := cat.categoryService.GetCategories(c.Query("limit", constants.DEFAULT_LIMIT_STRING), c.Query("page", constants.DEFAULT_PAGE_STRING))
+	pagination, ok := fiberpaginate.FromContext(c)
+	if !ok {
+		return utilities.ErrExpectedPagination
+	}
+
+	categories, err := cat.categoryService.GetCategories(*pagination)
 	if err != nil {
 		return err
 	}

backend/entities/categories/base/routes.go

@@ -4,6 +4,7 @@ import (
 	"github.com/GenerateNU/sac/backend/auth"
 	"github.com/GenerateNU/sac/backend/entities/categories/tag"
 	"github.com/GenerateNU/sac/backend/types"
+	"github.com/garrettladley/fiberpaginate"
 	"github.com/gofiber/fiber/v2"
 )
 
@@ -23,7 +24,7 @@ func Category(categoryParams types.RouteParams) fiber.Router {
 	categories := categoryParams.Router.Group("/categories")
 
 	categories.Post("/", categoryParams.AuthMiddleware.Authorize(auth.CreateAll), categoryController.CreateCategory)
-	categories.Get("/", categoryController.GetCategories)
+	categories.Get("/", fiberpaginate.New(), categoryController.GetCategories)
 
 	// api/v1/categories/:categoryID/*
 	categoryID := categories.Group("/:categoryID")

backend/entities/categories/base/service.go

@@ -4,14 +4,15 @@ import (
 	"github.com/GenerateNU/sac/backend/entities/models"
 	"github.com/GenerateNU/sac/backend/types"
 	"github.com/GenerateNU/sac/backend/utilities"
+	"github.com/garrettladley/fiberpaginate"
 
 	"golang.org/x/text/cases"
 	"golang.org/x/text/language"
 )
 
 type CategoryServiceInterface interface {
 	CreateCategory(categoryBody models.CategoryRequestBody) (*models.Category, error)
-	GetCategories(limit string, page string) ([]models.Category, error)
+	GetCategories(pageInfo fiberpaginate.PageInfo) ([]models.Category, error)
 	GetCategory(id string) (*models.Category, error)
 	UpdateCategory(id string, params models.CategoryRequestBody) (*models.Category, error)
 	DeleteCategory(id string) error
@@ -40,18 +41,8 @@ func (c *CategoryService) CreateCategory(categoryBody models.CategoryRequestBody
 	return CreateCategory(c.DB, *category)
 }
 
-func (c *CategoryService) GetCategories(limit string, page string) ([]models.Category, error) {
-	limitAsInt, err := utilities.ValidateNonNegative(limit)
-	if err != nil {
-		return nil, err
-	}
-
-	pageAsInt, err := utilities.ValidateNonNegative(page)
-	if err != nil {
-		return nil, err
-	}
-
-	return GetCategories(c.DB, *limitAsInt, *pageAsInt)
+func (c *CategoryService) GetCategories(pageInfo fiberpaginate.PageInfo) ([]models.Category, error) {
+	return GetCategories(c.DB, pageInfo)
 }
 
 func (c *CategoryService) GetCategory(id string) (*models.Category, error) {

backend/entities/categories/base/transactions.go

@@ -4,6 +4,7 @@ import (
 	"errors"
 
 	"github.com/GenerateNU/sac/backend/utilities"
+	"github.com/garrettladley/fiberpaginate"
 	"github.com/google/uuid"
 
 	"github.com/GenerateNU/sac/backend/entities/models"
@@ -22,12 +23,10 @@ func CreateCategory(db *gorm.DB, category models.Category) (*models.Category, er
 	return &category, nil
 }
 
-func GetCategories(db *gorm.DB, limit int, page int) ([]models.Category, error) {
+func GetCategories(db *gorm.DB, pageInfo fiberpaginate.PageInfo) ([]models.Category, error) {
 	var categories []models.Category
 
-	offset := (page - 1) * limit
-
-	if err := db.Limit(limit).Offset(offset).Find(&categories).Error; err != nil {
+	if err := db.Scopes(utilities.IntoScope(pageInfo, db)).Find(&categories).Error; err != nil {
 		return nil, err
 	}
 

backend/entities/categories/tag/controller.go

@@ -3,8 +3,8 @@ package tag
 import (
 	"net/http"
 
-	"github.com/GenerateNU/sac/backend/constants"
-
+	"github.com/GenerateNU/sac/backend/utilities"
+	"github.com/garrettladley/fiberpaginate"
 	"github.com/gofiber/fiber/v2"
 )
 
@@ -32,7 +32,12 @@ func NewCategoryTagController(categoryTagService CategoryTagServiceInterface) *C
 // @Failure     500   {object}      error
 // @Router		/categories/{categoryID}/tags/  [get]
 func (ct *CategoryTagController) GetTagsByCategory(c *fiber.Ctx) error {
-	tags, err := ct.categoryTagService.GetTagsByCategory(c.Params("categoryID"), c.Query("limit", constants.DEFAULT_LIMIT_STRING), c.Query("page", constants.DEFAULT_PAGE_STRING))
+	pagination, ok := fiberpaginate.FromContext(c)
+	if !ok {
+		return utilities.ErrExpectedPagination
+	}
+
+	tags, err := ct.categoryTagService.GetTagsByCategory(c.Params("categoryID"), *pagination)
 	if err != nil {
 		return err
 	}

backend/entities/categories/tag/routes.go

@@ -2,6 +2,7 @@ package tag
 
 import (
 	"github.com/GenerateNU/sac/backend/types"
+	"github.com/garrettladley/fiberpaginate"
 )
 
 func CategoryTag(categoryParams types.RouteParams) {
@@ -10,6 +11,6 @@ func CategoryTag(categoryParams types.RouteParams) {
 	// api/v1/categories/:categoryID/tags/*
 	categoryTags := categoryParams.Router.Group("/tags")
 
-	categoryTags.Get("/", categoryTagController.GetTagsByCategory)
+	categoryTags.Get("/", fiberpaginate.New(), categoryTagController.GetTagsByCategory)
 	categoryTags.Get("/:tagID", categoryTagController.GetTagByCategory)
 }

backend/entities/categories/tag/service.go

@@ -4,10 +4,11 @@ import (
 	"github.com/GenerateNU/sac/backend/entities/models"
 	"github.com/GenerateNU/sac/backend/types"
 	"github.com/GenerateNU/sac/backend/utilities"
+	"github.com/garrettladley/fiberpaginate"
 )
 
 type CategoryTagServiceInterface interface {
-	GetTagsByCategory(categoryID string, limit string, page string) ([]models.Tag, error)
+	GetTagsByCategory(categoryID string, pageInfo fiberpaginate.PageInfo) ([]models.Tag, error)
 	GetTagByCategory(categoryID string, tagID string) (*models.Tag, error)
 }
 
@@ -19,23 +20,13 @@ func NewCategoryTagService(params types.ServiceParams) CategoryTagServiceInterfa
 	return &CategoryTagService{params}
 }
 
-func (t *CategoryTagService) GetTagsByCategory(categoryID string, limit string, page string) ([]models.Tag, error) {
+func (t *CategoryTagService) GetTagsByCategory(categoryID string, pageInfo fiberpaginate.PageInfo) ([]models.Tag, error) {
 	categoryIDAsUUID, err := utilities.ValidateID(categoryID)
 	if err != nil {
 		return nil, err
 	}
 
-	limitAsInt, err := utilities.ValidateNonNegative(limit)
-	if err != nil {
-		return nil, err
-	}
-
-	pageAsInt, err := utilities.ValidateNonNegative(page)
-	if err != nil {
-		return nil, err
-	}
-
-	return GetTagsByCategory(t.DB, *categoryIDAsUUID, *limitAsInt, *pageAsInt)
+	return GetTagsByCategory(t.DB, *categoryIDAsUUID, pageInfo)
 }
 
 func (t *CategoryTagService) GetTagByCategory(categoryID string, tagID string) (*models.Tag, error) {

backend/entities/categories/tag/transactions.go

@@ -3,6 +3,7 @@ package tag
 import (
 	"errors"
 
+	"github.com/garrettladley/fiberpaginate"
 	"github.com/google/uuid"
 
 	"github.com/GenerateNU/sac/backend/entities/models"
@@ -11,7 +12,7 @@ import (
 	"gorm.io/gorm"
 )
 
-func GetTagsByCategory(db *gorm.DB, categoryID uuid.UUID, limit int, page int) ([]models.Tag, error) {
+func GetTagsByCategory(db *gorm.DB, categoryID uuid.UUID, pageInfo fiberpaginate.PageInfo) ([]models.Tag, error) {
 	var category models.Category
 
 	if err := db.Where("id = ?", categoryID).First(&category).Error; err != nil {
@@ -23,9 +24,7 @@ func GetTagsByCategory(db *gorm.DB, categoryID uuid.UUID, limit int, page int) (
 
 	var tags []models.Tag
 
-	offset := (page - 1) * limit
-
-	if err := db.Where("category_id = ?", categoryID).Limit(limit).Offset(offset).Find(&tags).Error; err != nil {
+	if err := db.Where("category_id = ?", categoryID).Scopes(utilities.IntoScope(pageInfo, db)).Find(&tags).Error; err != nil {
 		return nil, err
 	}