refactor associations into seperate verticals | gen clean up

backend/src/controllers/category.go

@@ -31,14 +31,14 @@ func NewCategoryController(categoryService services.CategoryServiceInterface) *C
 // @Failure		400	  {string}	  string "category with that name already exists"
 // @Failure     500   {string}    string "failed to create category"
 // @Router		/api/v1/category/  [post]
-func (t *CategoryController) CreateCategory(c *fiber.Ctx) error {
+func (cat *CategoryController) CreateCategory(c *fiber.Ctx) error {
 	var categoryBody models.CategoryRequestBody
 
 	if err := c.BodyParser(&categoryBody); err != nil {
 		return errors.FailedToParseRequestBody.FiberError(c)
 	}
 
-	newCategory, err := t.categoryService.CreateCategory(categoryBody)
+	newCategory, err := cat.categoryService.CreateCategory(categoryBody)
 	if err != nil {
 		return err.FiberError(c)
 	}
@@ -56,11 +56,11 @@ func (t *CategoryController) CreateCategory(c *fiber.Ctx) error {
 // @Success		200	  {object}	  []models.Category
 // @Failure     500   {string}    string "unable to retrieve categories"
 // @Router		/api/v1/category/  [get]
-func (t *CategoryController) GetCategories(c *fiber.Ctx) error {
+func (cat *CategoryController) GetCategories(c *fiber.Ctx) error {
 	defaultLimit := 10
 	defaultPage := 1
 
-	categories, err := t.categoryService.GetCategories(c.Query("limit", strconv.Itoa(defaultLimit)), c.Query("page", strconv.Itoa(defaultPage)))
+	categories, err := cat.categoryService.GetCategories(c.Query("limit", strconv.Itoa(defaultLimit)), c.Query("page", strconv.Itoa(defaultPage)))
 	if err != nil {
 		return err.FiberError(c)
 	}
@@ -80,8 +80,8 @@ func (t *CategoryController) GetCategories(c *fiber.Ctx) error {
 // @Failure     404   {string}    string "faied to find category"
 // @Failure     500   {string}    string "failed to retrieve category"
 // @Router		/api/v1/category/{id}  [get]
-func (t *CategoryController) GetCategory(c *fiber.Ctx) error {
-	category, err := t.categoryService.GetCategory(c.Params("id"))
+func (cat *CategoryController) GetCategory(c *fiber.Ctx) error {
+	category, err := cat.categoryService.GetCategory(c.Params("id"))
 	if err != nil {
 		return err.FiberError(c)
 	}
@@ -101,8 +101,8 @@ func (t *CategoryController) GetCategory(c *fiber.Ctx) error {
 // @Failure     404   {string}    string "failed to find category"
 // @Failure     500   {string}    string "failed to delete category"
 // @Router		/api/v1/category/{id}  [delete]
-func (t *CategoryController) DeleteCategory(c *fiber.Ctx) error {
-	if err := t.categoryService.DeleteCategory(c.Params("id")); err != nil {
+func (cat *CategoryController) DeleteCategory(c *fiber.Ctx) error {
+	if err := cat.categoryService.DeleteCategory(c.Params("id")); err != nil {
 		return err.FiberError(c)
 	}
 
@@ -121,14 +121,14 @@ func (t *CategoryController) DeleteCategory(c *fiber.Ctx) error {
 // @Failure     404   {string}    string "failed to find category"
 // @Failure     500   {string}    string "failed to update category"
 // @Router		/api/v1/category/{id}  [patch]
-func (t *CategoryController) UpdateCategory(c *fiber.Ctx) error {
+func (cat *CategoryController) UpdateCategory(c *fiber.Ctx) error {
 	var category models.CategoryRequestBody
 
 	if err := c.BodyParser(&category); err != nil {
 		return errors.FailedToValidateCategory.FiberError(c)
 	}
 
-	updatedCategory, err := t.categoryService.UpdateCategory(c.Params("id"), category)
+	updatedCategory, err := cat.categoryService.UpdateCategory(c.Params("id"), category)
 	if err != nil {
 		return err.FiberError(c)
 	}

backend/src/controllers/category_tag.go

@@ -16,20 +16,20 @@ func NewCategoryTagController(categoryTagService services.CategoryTagServiceInte
 	return &CategoryTagController{categoryTagService: categoryTagService}
 }
 
-func (t *CategoryTagController) GetTagsByCategory(c *fiber.Ctx) error {
+func (ct *CategoryTagController) GetTagsByCategory(c *fiber.Ctx) error {
 	defaultLimit := 10
 	defaultPage := 1
 
-	tags, err := t.categoryTagService.GetTagsByCategory(c.Params("categoryID"), c.Query("limit", strconv.Itoa(defaultLimit)), c.Query("page", strconv.Itoa(defaultPage)))
+	tags, err := ct.categoryTagService.GetTagsByCategory(c.Params("categoryID"), c.Query("limit", strconv.Itoa(defaultLimit)), c.Query("page", strconv.Itoa(defaultPage)))
 	if err != nil {
 		return err.FiberError(c)
 	}
 
 	return c.Status(fiber.StatusOK).JSON(&tags)
 }
 
-func (t *CategoryTagController) GetTagByCategory(c *fiber.Ctx) error {
-	tag, err := t.categoryTagService.GetTagByCategory(c.Params("categoryID"), c.Params("tagID"))
+func (ct *CategoryTagController) GetTagByCategory(c *fiber.Ctx) error {
+	tag, err := ct.categoryTagService.GetTagByCategory(c.Params("categoryID"), c.Params("tagID"))
 	if err != nil {
 		return err.FiberError(c)
 	}

backend/src/controllers/club.go

@@ -17,71 +17,61 @@ func NewClubController(clubService services.ClubServiceInterface) *ClubControlle
 	return &ClubController{clubService: clubService}
 }
 
-func (l *ClubController) GetAllClubs(c *fiber.Ctx) error {
+func (cc *ClubController) GetAllClubs(c *fiber.Ctx) error {
 	defaultLimit := 10
 	defaultPage := 1
 
-	clubs, err := l.clubService.GetClubs(c.Query("limit", strconv.Itoa(defaultLimit)), c.Query("page", strconv.Itoa(defaultPage)))
+	clubs, err := cc.clubService.GetClubs(c.Query("limit", strconv.Itoa(defaultLimit)), c.Query("page", strconv.Itoa(defaultPage)))
 	if err != nil {
 		return err.FiberError(c)
 	}
 
 	return c.Status(fiber.StatusOK).JSON(clubs)
 }
 
-func (l *ClubController) CreateClub(c *fiber.Ctx) error {
+func (cc *ClubController) CreateClub(c *fiber.Ctx) error {
 	var clubBody models.CreateClubRequestBody
 	if err := c.BodyParser(&clubBody); err != nil {
 		return errors.FailedToParseRequestBody.FiberError(c)
 	}
 
-	club, err := l.clubService.CreateClub(clubBody)
+	club, err := cc.clubService.CreateClub(clubBody)
 	if err != nil {
 		return err.FiberError(c)
 	}
 
 	return c.Status(fiber.StatusCreated).JSON(club)
 }
 
-func (l *ClubController) GetClub(c *fiber.Ctx) error {
-	club, err := l.clubService.GetClub(c.Params("id"))
+func (cc *ClubController) GetClub(c *fiber.Ctx) error {
+	club, err := cc.clubService.GetClub(c.Params("id"))
 	if err != nil {
 		return err.FiberError(c)
 	}
 
 	return c.Status(fiber.StatusOK).JSON(club)
 }
 
-func (l *ClubController) UpdateClub(c *fiber.Ctx) error {
+func (cc *ClubController) UpdateClub(c *fiber.Ctx) error {
 	var clubBody models.UpdateClubRequestBody
 
 	if err := c.BodyParser(&clubBody); err != nil {
 		return errors.FailedToParseRequestBody.FiberError(c)
 	}
 
-	updatedClub, err := l.clubService.UpdateClub(c.Params("id"), clubBody)
+	updatedClub, err := cc.clubService.UpdateClub(c.Params("id"), clubBody)
 	if err != nil {
 		return err.FiberError(c)
 	}
 
 	return c.Status(fiber.StatusOK).JSON(updatedClub)
 }
 
-func (l *ClubController) DeleteClub(c *fiber.Ctx) error {
-	err := l.clubService.DeleteClub(c.Params("id"))
+func (cc *ClubController) DeleteClub(c *fiber.Ctx) error {
+	err := cc.clubService.DeleteClub(c.Params("id"))
 	if err != nil {
 		return err.FiberError(c)
 	}
 
 	return c.SendStatus(fiber.StatusNoContent)
 }
-
-func (l *ClubController) GetUserFollowersForClub(c *fiber.Ctx) error {
-
-	clubs, err := l.clubService.GetUserFollowersForClub(c.Params("id"))
-	if err != nil {
-		return err.FiberError(c)
-	}
-
-	return c.Status(fiber.StatusOK).JSON(&clubs)
-}

backend/src/controllers/club_follower.go

@@ -0,0 +1,23 @@
+package controllers
+
+import (
+	"github.com/GenerateNU/sac/backend/src/services"
+	"github.com/gofiber/fiber/v2"
+)
+
+type ClubFollowerController struct {
+	clubFollowerService services.ClubFollowerServiceInterface
+}
+
+func NewClubFollowerController(clubFollowerService services.ClubFollowerServiceInterface) *ClubFollowerController {
+	return &ClubFollowerController{clubFollowerService: clubFollowerService}
+}
+
+func (cf *ClubFollowerController) GetUserFollowingClubs(c *fiber.Ctx) error {
+	clubs, err := cf.clubFollowerService.GetUserFollowingClubs(c.Params("userID"))
+	if err != nil {
+		return err.FiberError(c)
+	}
+
+	return c.Status(fiber.StatusOK).JSON(&clubs)
+}

backend/src/controllers/user.go

@@ -137,49 +137,3 @@ func (u *UserController) DeleteUser(c *fiber.Ctx) error {
 
 	return c.SendStatus(fiber.StatusNoContent)
 }
-
-func (u *UserController) GetUserTags(c *fiber.Ctx) error {
-	tags, err := u.userService.GetUserTags(c.Params("uid"))
-	if err != nil {
-		return err.FiberError(c)
-	}
-	return c.Status(fiber.StatusOK).JSON(&tags)
-}
-
-func (u *UserController) CreateUserTags(c *fiber.Ctx) error {
-	var requestBody models.CreateUserTagsBody
-	if err := c.BodyParser(&requestBody); err != nil {
-		return errors.FailedToParseRequestBody.FiberError(c)
-	}
-
-	tags, err := u.userService.CreateUserTags(c.Params("uid"), requestBody)
-	if err != nil {
-		return err.FiberError(c)
-	}
-	return c.Status(fiber.StatusCreated).JSON(&tags)
-}
-
-func (u *UserController) CreateFollowing(c *fiber.Ctx) error {
-	err := u.userService.CreateFollowing(c.Params("user_id"), c.Params("club_id"))
-	if err != nil {
-		return err.FiberError(c)
-	}
-	return c.SendStatus(fiber.StatusCreated)
-}
-
-func (u *UserController) DeleteFollowing(c *fiber.Ctx) error {
-
-	err := u.userService.DeleteFollowing(c.Params("user_id"), c.Params("club_id"))
-	if err != nil {
-		return err.FiberError(c)
-	}
-	return c.SendStatus(fiber.StatusNoContent)
-}
-
-func (u *UserController) GetAllFollowing(c *fiber.Ctx) error {
-	clubs, err := u.userService.GetFollowing(c.Params("user_id"))
-	if err != nil {
-		return err.FiberError(c)
-	}
-	return c.Status(fiber.StatusOK).JSON(clubs)
-}

backend/src/controllers/user_follower.go

@@ -0,0 +1,38 @@
+package controllers
+
+import (
+	"github.com/GenerateNU/sac/backend/src/services"
+	"github.com/gofiber/fiber/v2"
+)
+
+type UserFollowerController struct {
+	userFollowerService services.UserFollowerServiceInterface
+}
+
+func NewUserFollowerController(userFollowerService services.UserFollowerServiceInterface) *UserFollowerController {
+	return &UserFollowerController{userFollowerService: userFollowerService}
+}
+
+func (uf *UserFollowerController) CreateFollowing(c *fiber.Ctx) error {
+	err := uf.userFollowerService.CreateFollowing(c.Params("userID"), c.Params("clubID"))
+	if err != nil {
+		return err.FiberError(c)
+	}
+	return c.SendStatus(fiber.StatusCreated)
+}
+
+func (uf *UserFollowerController) DeleteFollowing(c *fiber.Ctx) error {
+	err := uf.userFollowerService.DeleteFollowing(c.Params("userID"), c.Params("clubID"))
+	if err != nil {
+		return err.FiberError(c)
+	}
+	return c.SendStatus(fiber.StatusNoContent)
+}
+
+func (uf *UserFollowerController) GetAllFollowing(c *fiber.Ctx) error {
+	clubs, err := uf.userFollowerService.GetFollowing(c.Params("userID"))
+	if err != nil {
+		return err.FiberError(c)
+	}
+	return c.Status(fiber.StatusOK).JSON(clubs)
+}

backend/src/controllers/user_tag.go

@@ -15,21 +15,21 @@ func NewUserTagController(userTagService services.UserTagServiceInterface) *User
 	return &UserTagController{userTagService: userTagService}
 }
 
-func (u *UserTagController) GetUserTags(c *fiber.Ctx) error {
-	tags, err := u.userTagService.GetUserTags(c.Params("userID"))
+func (ut *UserTagController) GetUserTags(c *fiber.Ctx) error {
+	tags, err := ut.userTagService.GetUserTags(c.Params("userID"))
 	if err != nil {
 		return err.FiberError(c)
 	}
 	return c.Status(fiber.StatusOK).JSON(&tags)
 }
 
-func (u *UserTagController) CreateUserTags(c *fiber.Ctx) error {
+func (ut *UserTagController) CreateUserTags(c *fiber.Ctx) error {
 	var requestBody models.CreateUserTagsBody
 	if err := c.BodyParser(&requestBody); err != nil {
 		return errors.FailedToParseRequestBody.FiberError(c)
 	}
 
-	tags, err := u.userTagService.CreateUserTags(c.Params("userID"), requestBody)
+	tags, err := ut.userTagService.CreateUserTags(c.Params("userID"), requestBody)
 	if err != nil {
 		return err.FiberError(c)
 	}

backend/src/middleware/club.go

@@ -32,7 +32,7 @@ func (m *MiddlewareService) ClubAuthorizeById(c *fiber.Ctx) error {
 		return errors.FailedToParseAccessToken.FiberError(c)
 	}
 
-	// use club_id to get the list of admin for a certain club
+	// use clubID to get the list of admin for a certain club
 	clubAdmin, clubErr := transactions.GetAdminIDs(m.DB, *clubUUID)
 	if clubErr != nil {
 		return err