Release / release-apk (push) Successful in 9m25s
Release / release-docker (push) Successful in 33s
CI / docker (push) Successful in 7s
CI / lint-backend (push) Successful in 1m29s
CI / lint-mobile (push) Failing after 7m46s
CI / test-backend (push) Successful in 1m30s
CI / test-mobile (push) Successful in 9m27s
CI / build-backend (push) Successful in 47s
115 lines
3.2 KiB
Go
115 lines
3.2 KiB
Go
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)
|
|
}
|