250 lines
7.2 KiB
Go
250 lines
7.2 KiB
Go
package database
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"time"
|
|
|
|
"go.mongodb.org/mongo-driver/v2/bson"
|
|
"go.mongodb.org/mongo-driver/v2/mongo"
|
|
"go.mongodb.org/mongo-driver/v2/mongo/options"
|
|
|
|
"gitea.hostxtra.co.uk/mrhid6/notely/backend/internal/domain/entities"
|
|
)
|
|
|
|
// SpaceRepository implements the space repository interface
|
|
type SpaceRepository struct {
|
|
collection *mongo.Collection
|
|
}
|
|
|
|
// NewSpaceRepository creates a new space repository
|
|
func NewSpaceRepository(db *mongo.Database) *SpaceRepository {
|
|
return &SpaceRepository{
|
|
collection: db.Collection("spaces"),
|
|
}
|
|
}
|
|
|
|
// CreateSpace creates a new space
|
|
func (r *SpaceRepository) CreateSpace(ctx context.Context, space *entities.Space) error {
|
|
space.ID = bson.NewObjectID()
|
|
space.CreatedAt = time.Now()
|
|
space.UpdatedAt = time.Now()
|
|
|
|
_, err := r.collection.InsertOne(ctx, space)
|
|
return err
|
|
}
|
|
|
|
// GetSpaceByID retrieves a space by ID
|
|
func (r *SpaceRepository) GetSpaceByID(ctx context.Context, id bson.ObjectID) (*entities.Space, error) {
|
|
var space entities.Space
|
|
err := r.collection.FindOne(ctx, bson.M{"_id": id}).Decode(&space)
|
|
if err != nil {
|
|
if err == mongo.ErrNoDocuments {
|
|
return nil, errors.New("space not found")
|
|
}
|
|
return nil, err
|
|
}
|
|
return &space, nil
|
|
}
|
|
|
|
// GetSpacesByUserID retrieves all spaces for a user (via memberships)
|
|
func (r *SpaceRepository) GetSpacesByUserID(ctx context.Context, userID bson.ObjectID) ([]*entities.Space, error) {
|
|
var spaces []*entities.Space
|
|
|
|
// Query spaces where user is a member
|
|
opts := options.Find().SetSort(bson.M{"created_at": -1})
|
|
cursor, err := r.collection.Find(ctx, bson.M{}, opts)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer cursor.Close(ctx)
|
|
|
|
// This would typically be joined with membership collection
|
|
// For now, returning all spaces - in production, filter by membership
|
|
if err = cursor.All(ctx, &spaces); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return spaces, nil
|
|
}
|
|
|
|
// UpdateSpace updates a space
|
|
func (r *SpaceRepository) UpdateSpace(ctx context.Context, space *entities.Space) error {
|
|
space.UpdatedAt = time.Now()
|
|
_, err := r.collection.ReplaceOne(ctx, bson.M{"_id": space.ID}, space)
|
|
return err
|
|
}
|
|
|
|
// DeleteSpace deletes a space
|
|
func (r *SpaceRepository) DeleteSpace(ctx context.Context, id bson.ObjectID) error {
|
|
_, err := r.collection.DeleteOne(ctx, bson.M{"_id": id})
|
|
return err
|
|
}
|
|
|
|
// GetAllSpaces retrieves all spaces sorted by creation date descending
|
|
func (r *SpaceRepository) GetAllSpaces(ctx context.Context) ([]*entities.Space, error) {
|
|
opts := options.Find().SetSort(bson.D{bson.E{Key: "created_at", Value: -1}})
|
|
cursor, err := r.collection.Find(ctx, bson.M{}, opts)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer cursor.Close(ctx)
|
|
|
|
var spaces []*entities.Space
|
|
if err := cursor.All(ctx, &spaces); err != nil {
|
|
return nil, err
|
|
}
|
|
return spaces, nil
|
|
}
|
|
|
|
// GetPublicSpaces retrieves all spaces marked as public
|
|
func (r *SpaceRepository) GetPublicSpaces(ctx context.Context) ([]*entities.Space, error) {
|
|
opts := options.Find().SetSort(bson.D{bson.E{Key: "created_at", Value: -1}})
|
|
cursor, err := r.collection.Find(ctx, bson.M{"is_public": true}, opts)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer cursor.Close(ctx)
|
|
|
|
var spaces []*entities.Space
|
|
if err := cursor.All(ctx, &spaces); err != nil {
|
|
return nil, err
|
|
}
|
|
return spaces, nil
|
|
}
|
|
|
|
// EnsureIndexes creates necessary indexes
|
|
func (r *SpaceRepository) EnsureIndexes(ctx context.Context) error {
|
|
indexModel := []mongo.IndexModel{
|
|
{
|
|
Keys: bson.D{bson.E{Key: "owner_id", Value: 1}},
|
|
},
|
|
{
|
|
Keys: bson.D{bson.E{Key: "created_at", Value: -1}},
|
|
},
|
|
}
|
|
|
|
_, err := r.collection.Indexes().CreateMany(ctx, indexModel)
|
|
return err
|
|
}
|
|
|
|
// ========== MEMBERSHIP REPOSITORY ==========
|
|
|
|
// MembershipRepository implements the membership repository interface
|
|
type MembershipRepository struct {
|
|
collection *mongo.Collection
|
|
}
|
|
|
|
// NewMembershipRepository creates a new membership repository
|
|
func NewMembershipRepository(db *mongo.Database) *MembershipRepository {
|
|
return &MembershipRepository{
|
|
collection: db.Collection("memberships"),
|
|
}
|
|
}
|
|
|
|
// CreateMembership creates a new membership
|
|
func (r *MembershipRepository) CreateMembership(ctx context.Context, membership *entities.Membership) error {
|
|
membership.ID = bson.NewObjectID()
|
|
membership.JoinedAt = time.Now()
|
|
|
|
_, err := r.collection.InsertOne(ctx, membership)
|
|
return err
|
|
}
|
|
|
|
// GetMembershipByID retrieves a membership by ID
|
|
func (r *MembershipRepository) GetMembershipByID(ctx context.Context, id bson.ObjectID) (*entities.Membership, error) {
|
|
var membership entities.Membership
|
|
err := r.collection.FindOne(ctx, bson.M{"_id": id}).Decode(&membership)
|
|
if err != nil {
|
|
if err == mongo.ErrNoDocuments {
|
|
return nil, errors.New("membership not found")
|
|
}
|
|
return nil, err
|
|
}
|
|
return &membership, nil
|
|
}
|
|
|
|
// GetUserMembership retrieves a membership for a user in a space
|
|
func (r *MembershipRepository) GetUserMembership(ctx context.Context, userID, spaceID bson.ObjectID) (*entities.Membership, error) {
|
|
var membership entities.Membership
|
|
err := r.collection.FindOne(ctx, bson.M{
|
|
"user_id": userID,
|
|
"space_id": spaceID,
|
|
}).Decode(&membership)
|
|
if err != nil {
|
|
if err == mongo.ErrNoDocuments {
|
|
return nil, errors.New("membership not found")
|
|
}
|
|
return nil, err
|
|
}
|
|
return &membership, nil
|
|
}
|
|
|
|
// GetSpaceMembers retrieves all members in a space
|
|
func (r *MembershipRepository) GetSpaceMembers(ctx context.Context, spaceID bson.ObjectID) ([]*entities.Membership, error) {
|
|
var memberships []*entities.Membership
|
|
|
|
cursor, err := r.collection.Find(ctx, bson.M{"space_id": spaceID})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer cursor.Close(ctx)
|
|
|
|
if err = cursor.All(ctx, &memberships); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return memberships, nil
|
|
}
|
|
|
|
// GetUserMemberships retrieves all memberships for a user
|
|
func (r *MembershipRepository) GetUserMemberships(ctx context.Context, userID bson.ObjectID) ([]*entities.Membership, error) {
|
|
var memberships []*entities.Membership
|
|
|
|
cursor, err := r.collection.Find(ctx, bson.M{"user_id": userID})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer cursor.Close(ctx)
|
|
|
|
if err = cursor.All(ctx, &memberships); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return memberships, nil
|
|
}
|
|
|
|
// UpdateMembership updates a membership
|
|
func (r *MembershipRepository) UpdateMembership(ctx context.Context, membership *entities.Membership) error {
|
|
_, err := r.collection.ReplaceOne(ctx, bson.M{"_id": membership.ID}, membership)
|
|
return err
|
|
}
|
|
|
|
// DeleteMembership deletes a membership
|
|
func (r *MembershipRepository) DeleteMembership(ctx context.Context, id bson.ObjectID) error {
|
|
_, err := r.collection.DeleteOne(ctx, bson.M{"_id": id})
|
|
return err
|
|
}
|
|
|
|
// DeleteMembershipsBySpaceID deletes all memberships for a space
|
|
func (r *MembershipRepository) DeleteMembershipsBySpaceID(ctx context.Context, spaceID bson.ObjectID) error {
|
|
_, err := r.collection.DeleteMany(ctx, bson.M{"space_id": spaceID})
|
|
return err
|
|
}
|
|
|
|
// EnsureIndexes creates necessary indexes
|
|
func (r *MembershipRepository) EnsureIndexes(ctx context.Context) error {
|
|
indexModel := []mongo.IndexModel{
|
|
{
|
|
Keys: bson.D{bson.E{Key: "user_id", Value: 1}, bson.E{Key: "space_id", Value: 1}},
|
|
Options: options.Index().SetUnique(true),
|
|
},
|
|
{
|
|
Keys: bson.D{bson.E{Key: "space_id", Value: 1}},
|
|
},
|
|
}
|
|
|
|
_, err := r.collection.Indexes().CreateMany(ctx, indexModel)
|
|
return err
|
|
}
|