package service import ( "errors" "strings" "github.com/kazier/backend/repository" ) // GroupDTO serializes a group for GET /groups. type GroupDTO struct { ID string `json:"id"` Name string `json:"name"` Role string `json:"role"` // "owner" | "member" } // sanitizeGroupName trims + caps display names (same spirit as file names). func sanitizeGroupName(name string) (string, error) { n := strings.TrimSpace(name) if n == "" || len(n) > 255 { return "", ErrInvalidUpload } return n, nil } // CreateGroup stores a group owned by userID. func (s *Resources) CreateGroup(userID, name string) (GroupDTO, error) { clean, err := sanitizeGroupName(name) if err != nil { return GroupDTO{}, err } id, err := s.Repository.Groups.Create(clean, userID) if err != nil { return GroupDTO{}, err } return GroupDTO{ID: id, Name: clean, Role: "owner"}, nil } // ListGroups returns groups the user owns or joins. func (s *Resources) ListGroups(userID string) ([]GroupDTO, error) { groups, err := s.Repository.Groups.ListForUser(userID) if err != nil { return nil, err } out := make([]GroupDTO, 0, len(groups)) for _, gr := range groups { out = append(out, GroupDTO{ID: gr.ID, Name: gr.Name, Role: gr.Role}) } return out, nil } // AddGroupMember adds an existing active user to a group the caller owns. // Unknown group (or not owned) → ErrNotFound (no enumeration) ; unknown // member → ErrGranteeNotFound (same code as share recipients). func (s *Resources) AddGroupMember(userID, groupID, memberID string) error { owner, err := s.Repository.Groups.IsOwner(groupID, userID) if err != nil { return err } if !owner { return repository.ErrNotFound } if _, err := s.Repository.Users.GetByID(memberID); err != nil { if errors.Is(err, repository.ErrNotFound) { return repository.ErrGranteeNotFound } return err } return s.Repository.Groups.AddMember(groupID, memberID) } // RemoveGroupMember removes a membership (group must be owned by caller). // Missing membership → ErrNotFound (idempotent-safe callers treat as done). func (s *Resources) RemoveGroupMember(userID, groupID, memberID string) error { owner, err := s.Repository.Groups.IsOwner(groupID, userID) if err != nil { return err } if !owner { return repository.ErrNotFound } return s.Repository.Groups.RemoveMember(groupID, memberID) } // MemberDTO serializes a membership for GET /groups/:id/members. type MemberDTO struct { ID string `json:"id"` Username string `json:"username"` } // ListMembers returns memberships of a group the caller owns. func (s *Resources) ListMembers(userID, groupID string) ([]MemberDTO, error) { owner, err := s.Repository.Groups.IsOwner(groupID, userID) if err != nil { return nil, err } if !owner { return nil, repository.ErrNotFound } members, err := s.Repository.Groups.ListMembers(groupID) if err != nil { return nil, err } out := make([]MemberDTO, 0, len(members)) for _, m := range members { out = append(out, MemberDTO{ID: m.UserID, Username: m.Username}) } return out, nil } // DeleteGroup removes an owned group (member shares cascade via FK). func (s *Resources) DeleteGroup(userID, groupID string) error { return s.Repository.Groups.Delete(groupID, userID) }