Merge branch 'main' into dashboard-form

backend/config/calendar.go

@@ -0,0 +1,24 @@
+package config
+
+import (
+	"time"
+)
+
+type CalendarSettings struct {
+	MaxTerminationDate time.Time
+}
+
+type intermediateCalendarSettings struct {
+	MaxTerminationDate string `yaml:"maxterminationdate"`
+}
+
+func (int *intermediateCalendarSettings) into() (*CalendarSettings, error) {
+	t, err := time.Parse("01-02-2006", int.MaxTerminationDate)
+	if err != nil {
+		return nil, err
+	}
+
+	return &CalendarSettings{
+		MaxTerminationDate: t,
+	}, nil
+}

backend/config/config.go

@@ -8,21 +8,23 @@ import (
 )
 
 type Settings struct {
-	Application      ApplicationSettings
-	Database         DatabaseSettings
-	SuperUser        SuperUserSettings
-	Auth             AuthSettings
-	AWS              AWSSettings
-	PineconeSettings PineconeSettings
-	OpenAISettings   OpenAISettings
-	ResendSettings   ResendSettings
+	Application ApplicationSettings
+	Database    DatabaseSettings
+	SuperUser   SuperUserSettings
+	Auth        AuthSettings
+	AWS         AWSSettings
+	Pinecone    PineconeSettings
+	OpenAI      OpenAISettings
+	Resend      ResendSettings
+	Calendar    CalendarSettings
 }
 
 type intermediateSettings struct {
 	Application ApplicationSettings           `yaml:"application"`
 	Database    intermediateDatabaseSettings  `yaml:"database"`
 	SuperUser   intermediateSuperUserSettings `yaml:"superuser"`
 	Auth        intermediateAuthSettings      `yaml:"authsecret"`
+	Calendar    intermediateCalendarSettings  `yaml:"calendar"`
 }
 
 func (int *intermediateSettings) into() (*Settings, error) {
@@ -41,11 +43,17 @@ func (int *intermediateSettings) into() (*Settings, error) {
 		return nil, err
 	}
 
+	calendarSettings, err := int.Calendar.into()
+	if err != nil {
+		return nil, err
+	}
+
 	return &Settings{
 		Application: int.Application,
 		Database:    *databaseSettings,
 		SuperUser:   *superUserSettings,
 		Auth:        *authSettings,
+		Calendar:    *calendarSettings,
 	}, nil
 }
 

backend/config/local.go

@@ -42,14 +42,14 @@ func readLocal(v *viper.Viper, path string, useDevDotEnv bool) (*Settings, error
 		return nil, fmt.Errorf("failed to read Pinecone settings: %w", err)
 	}
 
-	settings.PineconeSettings = *pineconeSettings
+	settings.Pinecone = *pineconeSettings
 
 	openAISettings, err := readOpenAISettings()
 	if err != nil {
 		return nil, fmt.Errorf("failed to read OpenAI settings: %w", err)
 	}
 
-	settings.OpenAISettings = *openAISettings
+	settings.OpenAI = *openAISettings
 
 	awsSettings, err := readAWSSettings()
 	if err != nil {
@@ -63,7 +63,7 @@ func readLocal(v *viper.Viper, path string, useDevDotEnv bool) (*Settings, error
 		return nil, fmt.Errorf("failed to read Resend settings: %w", err)
 	}
 
-	settings.ResendSettings = *resendSettings
+	settings.Resend = *resendSettings
 
 	return settings, nil
 }

backend/config/production.go

@@ -14,6 +14,7 @@ import (
 type ProductionSettings struct {
 	Database    ProductionDatabaseSettings    `yaml:"database"`
 	Application ProductionApplicationSettings `yaml:"application"`
+	Calendar    CalendarSettings              `yaml:"calendar"`
 }
 
 type ProductionDatabaseSettings struct {
@@ -118,9 +119,10 @@ func readProd(v *viper.Viper) (*Settings, error) {
 			AccessKey:  authAccessKey,
 			RefreshKey: authRefreshKey,
 		},
-		PineconeSettings: *pineconeSettings,
-		OpenAISettings:   *openAISettings,
-		AWS:              *awsSettings,
-		ResendSettings:   *resendSettings,
+		Pinecone: *pineconeSettings,
+		OpenAI:   *openAISettings,
+		AWS:      *awsSettings,
+		Resend:   *resendSettings,
+		Calendar: prodSettings.Calendar,
 	}, nil
 }

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.MapJsonTags(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/service.go

@@ -31,7 +31,7 @@ func (c *CategoryService) CreateCategory(categoryBody models.CategoryRequestBody
 		return nil, err
 	}
 
-	category, err := utilities.MapRequestToModel(categoryBody, &models.Category{})
+	category, err := utilities.MapJsonTags(categoryBody, &models.Category{})
 	if err != nil {
 		return nil, err
 	}
@@ -64,7 +64,7 @@ func (c *CategoryService) UpdateCategory(id string, categoryBody models.Category
 		return nil, err
 	}
 
-	category, err := utilities.MapRequestToModel(categoryBody, &models.Category{})
+	category, err := utilities.MapJsonTags(categoryBody, &models.Category{})
 	if err != nil {
 		return nil, err
 	}

backend/entities/clubs/base/routes.go

@@ -8,17 +8,15 @@ import (
 	"github.com/GenerateNU/sac/backend/entities/clubs/member"
 	"github.com/GenerateNU/sac/backend/entities/clubs/poc"
 	"github.com/GenerateNU/sac/backend/entities/clubs/tag"
+	"github.com/GenerateNU/sac/backend/middleware"
 	"github.com/garrettladley/fiberpaginate"
 
 	"github.com/GenerateNU/sac/backend/types"
 	"github.com/gofiber/fiber/v2"
 )
 
 func ClubRoutes(clubParams types.RouteParams) {
-	clubIDRouter := ClubRouter(clubParams)
-
-	// update the router in params
-	clubParams.Router = clubIDRouter
+	clubParams.Router = ClubRouter(clubParams)
 
 	tag.ClubTag(clubParams)
 	follower.ClubFollower(clubParams)
@@ -41,7 +39,11 @@ func ClubRouter(clubParams types.RouteParams) fiber.Router {
 	clubID := clubs.Group("/:clubID")
 
 	clubID.Get("/", clubController.GetClub)
-	clubID.Patch("/", clubParams.AuthMiddleware.ClubAuthorizeById, clubController.UpdateClub)
+	clubID.Patch(
+		"/",
+		middleware.AttachExtractor(clubParams.AuthMiddleware.ClubAuthorizeById, middleware.ExtractFromParams("clubID")),
+		clubController.UpdateClub,
+	)
 	clubID.Delete("/", clubParams.AuthMiddleware.Authorize(p.DeleteAll), clubController.DeleteClub)
 
 	return clubID

backend/entities/clubs/base/service.go

@@ -35,7 +35,7 @@ func (c *ClubService) CreateClub(clubBody models.CreateClubRequestBody) (*models
 		return nil, err
 	}
 
-	club, err := utilities.MapRequestToModel(clubBody, &models.Club{})
+	club, err := utilities.MapJsonTags(clubBody, &models.Club{})
 	if err != nil {
 		return nil, err
 	}
@@ -66,7 +66,7 @@ func (c *ClubService) UpdateClub(id string, clubBody models.UpdateClubRequestBod
 		return nil, err
 	}
 
-	club, err := utilities.MapRequestToModel(clubBody, &models.Club{})
+	club, err := utilities.MapJsonTags(clubBody, &models.Club{})
 	if err != nil {
 		return nil, err
 	}

backend/entities/clubs/contact/routes.go

@@ -1,6 +1,7 @@
 package contact
 
 import (
+	"github.com/GenerateNU/sac/backend/middleware"
 	"github.com/GenerateNU/sac/backend/types"
 )
 
@@ -11,5 +12,9 @@ func ClubContact(clubParams types.RouteParams) {
 
 	// api/v1/clubs/:clubID/contacts/*
 	clubContacts.Get("/", clubContactController.GetClubContacts)
-	clubContacts.Put("/", clubParams.AuthMiddleware.ClubAuthorizeById, clubContactController.PutContact)
+	clubContacts.Put(
+		"/",
+		middleware.AttachExtractor(clubParams.AuthMiddleware.ClubAuthorizeById, middleware.ExtractFromParams("clubID")),
+		clubContactController.PutContact,
+	)
 }

backend/entities/clubs/contact/service.go

@@ -38,7 +38,7 @@ func (c *ClubContactService) PutClubContact(clubID string, contactBody models.Pu
 		return nil, err
 	}
 
-	contact, err := utilities.MapRequestToModel(contactBody, &models.Contact{})
+	contact, err := utilities.MapJsonTags(contactBody, &models.Contact{})
 	if err != nil {
 		return nil, err
 	}

backend/entities/clubs/member/routes.go

@@ -1,6 +1,7 @@
 package member
 
 import (
+	"github.com/GenerateNU/sac/backend/middleware"
 	"github.com/GenerateNU/sac/backend/types"
 	"github.com/garrettladley/fiberpaginate"
 )
@@ -12,6 +13,14 @@ func ClubMember(clubParams types.RouteParams) {
 
 	// api/v1/clubs/:clubID/members/*
 	clubMembers.Get("/", fiberpaginate.New(), clubMemberController.GetClubMembers)
-	clubMembers.Post("/:userID", clubParams.AuthMiddleware.ClubAuthorizeById, clubMemberController.CreateClubMember)
-	clubMembers.Delete("/:userID", clubParams.AuthMiddleware.ClubAuthorizeById, clubMemberController.DeleteClubMember)
+	clubMembers.Post(
+		"/:userID",
+		middleware.AttachExtractor(clubParams.AuthMiddleware.ClubAuthorizeById, middleware.ExtractFromParams("clubID")),
+		clubMemberController.CreateClubMember,
+	)
+	clubMembers.Delete(
+		"/:userID",
+		middleware.AttachExtractor(clubParams.AuthMiddleware.ClubAuthorizeById, middleware.ExtractFromParams("clubID")),
+		clubMemberController.DeleteClubMember,
+	)
 }