haixunMaster/haixun-backend/internal/model/persona/repository/mongo.go

package repository

import (
	"context"
	"strings"

	"haixun-backend/internal/library/clock"
	app "haixun-backend/internal/library/errors"
	"haixun-backend/internal/library/errors/code"
	"haixun-backend/internal/model/persona/domain/entity"
	domrepo "haixun-backend/internal/model/persona/domain/repository"

	"go.mongodb.org/mongo-driver/bson"
	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"
)

type mongoRepository struct {
	collection *mongo.Collection
}

func NewMongoRepository(db *mongo.Database) domrepo.Repository {
	if db == nil {
		return &mongoRepository{}
	}
	return &mongoRepository{collection: db.Collection(entity.CollectionName)}
}

func (r *mongoRepository) EnsureIndexes(ctx context.Context) error {
	if r.collection == nil {
		return nil
	}
	_, err := r.collection.Indexes().CreateMany(ctx, []mongo.IndexModel{
		{Keys: bson.D{{Key: "tenant_id", Value: 1}, {Key: "owner_uid", Value: 1}, {Key: "update_at", Value: -1}}},
		{Keys: bson.D{{Key: "tenant_id", Value: 1}, {Key: "owner_uid", Value: 1}, {Key: "_id", Value: 1}}, Options: options.Index().SetUnique(true)},
	})
	return err
}

func (r *mongoRepository) Create(ctx context.Context, persona *entity.Persona) (*entity.Persona, error) {
	if r.collection == nil {
		return nil, app.For(code.Persona).DBUnavailable("Mongo is not configured")
	}
	now := clock.NowUnixNano()
	persona.CreateAt = now
	persona.UpdateAt = now
	if persona.Status == "" {
		persona.Status = entity.StatusOpen
	}
	_, err := r.collection.InsertOne(ctx, persona)
	if err != nil {
		return nil, err
	}
	return persona, nil
}

func (r *mongoRepository) FindByID(ctx context.Context, tenantID, ownerUID, personaID string) (*entity.Persona, error) {
	return r.findOne(ctx, bson.M{
		"_id":       strings.TrimSpace(personaID),
		"tenant_id": tenantID,
		"owner_uid": ownerUID,
		"status":    entity.StatusOpen,
	})
}

func (r *mongoRepository) ListByOwner(ctx context.Context, tenantID, ownerUID string) ([]*entity.Persona, error) {
	if r.collection == nil {
		return nil, app.For(code.Persona).DBUnavailable("Mongo is not configured")
	}
	cursor, err := r.collection.Find(
		ctx,
		bson.M{"tenant_id": tenantID, "owner_uid": ownerUID, "status": entity.StatusOpen},
		options.Find().SetSort(bson.D{{Key: "update_at", Value: -1}}),
	)
	if err != nil {
		return nil, err
	}
	defer cursor.Close(ctx)
	var items []*entity.Persona
	if err := cursor.All(ctx, &items); err != nil {
		return nil, err
	}
	return items, nil
}

func (r *mongoRepository) Update(ctx context.Context, tenantID, ownerUID, personaID string, patch map[string]interface{}) (*entity.Persona, error) {
	if r.collection == nil {
		return nil, app.For(code.Persona).DBUnavailable("Mongo is not configured")
	}
	if len(patch) == 0 {
		return r.FindByID(ctx, tenantID, ownerUID, personaID)
	}
	patch["update_at"] = clock.NowUnixNano()
	var out entity.Persona
	err := r.collection.FindOneAndUpdate(
		ctx,
		bson.M{"_id": personaID, "tenant_id": tenantID, "owner_uid": ownerUID, "status": entity.StatusOpen},
		bson.M{"$set": patch},
		options.FindOneAndUpdate().SetReturnDocument(options.After),
	).Decode(&out)
	if err == mongo.ErrNoDocuments {
		return nil, app.For(code.Persona).ResNotFound("persona not found")
	}
	return &out, err
}

func (r *mongoRepository) SoftDelete(ctx context.Context, tenantID, ownerUID, personaID string) error {
	if r.collection == nil {
		return app.For(code.Persona).DBUnavailable("Mongo is not configured")
	}
	res, err := r.collection.UpdateOne(
		ctx,
		bson.M{"_id": personaID, "tenant_id": tenantID, "owner_uid": ownerUID, "status": entity.StatusOpen},
		bson.M{"$set": bson.M{"status": entity.StatusDeleted, "update_at": clock.NowUnixNano()}},
	)
	if err != nil {
		return err
	}
	if res.MatchedCount == 0 {
		return app.For(code.Persona).ResNotFound("persona not found")
	}
	return nil
}

func (r *mongoRepository) findOne(ctx context.Context, filter bson.M) (*entity.Persona, error) {
	if r.collection == nil {
		return nil, app.For(code.Persona).DBUnavailable("Mongo is not configured")
	}
	var out entity.Persona
	err := r.collection.FindOne(ctx, filter).Decode(&out)
	if err == mongo.ErrNoDocuments {
		return nil, app.For(code.Persona).ResNotFound("persona not found")
	}
	if err != nil {
		return nil, err
	}
	return &out, nil
}