fix owner leave club

Author: nevzattalhaozcan

internal/handlers/club.go

@@ -291,10 +291,30 @@ func (h *ClubHandler) LeaveClub(c *gin.Context) {
 		return
 	}
 
-	err = h.clubService.LeaveClub(uint(clubID), uint(userID))
-	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
-		return
+	var req models.OwnerLeaveRequest
+	var ownerAction *models.OwnerLeaveRequest
+	if err := c.ShouldBindJSON(&req); err == nil {
+		ownerAction = &req
+	}
+
+	if err := h.clubService.LeaveClub(uint(clubID), userID, ownerAction); err != nil {
+		switch err.Error() {
+		case "club not found", "not a member":
+			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+			return
+		case "owner must choose action: transfer or close",
+            "new_owner_id is required for transfer",
+            "only the owner can transfer ownership",
+            "new owner must be different from current owner",
+            "new owner must be a member of the club",
+            "new owner must be an approved member",
+            "invalid action; must be one of: transfer, close":
+			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+			return
+		default:
+			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+			return
+		}
 	}
 
 	c.JSON(http.StatusOK, gin.H{

internal/models/club.go

@@ -108,6 +108,11 @@ type UpdateClubRatingRequest struct {
 	Rating float32 `json:"rating" validate:"required,gte=0,lte=5"`
 }
 
+type OwnerLeaveRequest struct {
+	Action     string `json:"action" validate:"omitempty,oneof=transfer close"`
+    NewOwnerID *uint  `json:"new_owner_id,omitempty"`
+}
+
 type ClubMembershipResponse struct {
 	ID         uint         `json:"id"`
 	UserID     uint         `json:"user_id"`

internal/repository/club.go

@@ -158,4 +158,8 @@ func (r *clubRatingRepository) GetAggregateForClub(clubID uint) (float32, int, e
 		Scan(&a).Error
 
 	return float32(a.Avg), int(a.Count), err
+}
+
+func (r *clubRepository) UpdateMembership(m *models.ClubMembership) error {
+    return r.db.Save(m).Error
 }

internal/repository/interfaces.go

@@ -27,6 +27,7 @@ type ClubRepository interface {
 	UpdateClubMember(membership *models.ClubMembership) error
 	GetClubMemberByUserID(clubID, userID uint) (*models.ClubMembership, error)
 	UpdateRatingAggregate(clubID uint, avg float32, count int) error
+	UpdateMembership(m *models.ClubMembership) error
 }
 
 type ClubRatingRepository interface {

internal/services/club.go

@@ -265,7 +265,7 @@ func (s *ClubService) JoinClub(clubID, userID uint) (*models.ClubMembershipRespo
 	return &response, nil
 }
 
-func (s *ClubService) LeaveClub(clubID, userID uint) error {
+func (s *ClubService) LeaveClub(clubID, userID uint, ownerAction *models.OwnerLeaveRequest) error {
 	club, err := s.clubRepo.GetByID(clubID)
 	if err != nil {
 		if errors.Is(err, gorm.ErrRecordNotFound) {
@@ -280,13 +280,55 @@ func (s *ClubService) LeaveClub(clubID, userID uint) error {
 		}
 		return err
 	}
+	
+	isOwner := club.OwnerID != nil && *club.OwnerID == userID
+	if isOwner {
+		if ownerAction == nil || ownerAction.Action == "" {
+			return errors.New("owner must choose action: transfer or close")
+		}
+		switch ownerAction.Action {
+		case "close":
+			return s.clubRepo.Delete(club.ID)
+		case "transfer":
+			if ownerAction.NewOwnerID == nil {
+				return errors.New("new_owner_id is required for transfer")
+			}
+			if err := s.TransferOwnership(clubID, userID, *ownerAction.NewOwnerID); err != nil {
+				return err
+			}
+			if err := s.clubRepo.LeaveClub(clubID, userID); err != nil {
+				return err
+			}
+			if m.IsApproved && club.MembersCount > 0 {
+				club.MembersCount--
+				if err := s.clubRepo.Update(club); err != nil {
+					return err
+				}
+			}
+			if club.MembersCount == 0 {
+				return s.clubRepo.Delete(club.ID)
+			}
+			return nil
+		default:
+			return errors.New("invalid action; must be one of: transfer, close")
+		}
+	}
+
+	if err := s.clubRepo.LeaveClub(clubID, userID); err != nil {
+		return err
+	}
 	if m.IsApproved && club.MembersCount > 0 {
 		club.MembersCount--
 		if err := s.clubRepo.Update(club); err != nil {
 			return err
 		}
 	}
-	return s.clubRepo.LeaveClub(clubID, userID)
+
+	if club.MembersCount == 0 {
+		return s.clubRepo.Delete(club.ID)
+	}
+
+	return nil
 }
 
 func (s *ClubService) ListClubMembers(clubID uint) ([]*models.ClubMembership, error) {
@@ -414,4 +456,45 @@ func (s *ClubService) ListClubRatings(clubID uint, limit, offset int) ([]models.
 		return nil, err
 	}
 	return s.clubRatingRepo.ListByClub(clubID, limit, offset)
+}
+
+func (s *ClubService) TransferOwnership(clubID, currentOwnerID, newOwnerID uint) error {
+	club, err := s.clubRepo.GetByID(clubID)
+	if err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return ErrClubNotFound
+		}
+		return err
+	}
+	if club.OwnerID == nil || *club.OwnerID != currentOwnerID {
+		return errors.New("only the owner can transfer ownership")
+	}
+	if newOwnerID == currentOwnerID {
+		return errors.New("new owner must be different from current owner")
+	}
+
+	newOwnerMembership, err := s.clubRepo.GetClubMemberByUserID(clubID, newOwnerID)
+	if err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return errors.New("new owner must be a member of the club")
+		}
+		return err
+	}
+	if !newOwnerMembership.IsApproved {
+		return errors.New("new owner must be an approved member of the club")
+	}
+
+	club.OwnerID = &newOwnerID
+	if err := s.clubRepo.Update(club); err != nil {
+		return err
+	}
+
+	if newOwnerMembership.Role != "admin" {
+		newOwnerMembership.Role = "admin"
+		if err := s.clubRepo.UpdateMembership(newOwnerMembership); err != nil {
+			return err
+		}
+	}
+
+	return nil
 }