tariffs/internal/repository/privilege/privilege.go

package privilege

import (
	"context"
	"go.mongodb.org/mongo-driver/bson"
	"go.mongodb.org/mongo-driver/bson/primitive"
	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"
	"go.uber.org/zap"
	"hub_admin_backend_service/internal/errors"
	"hub_admin_backend_service/internal/models"
	"time"
)

type Deps struct {
	Mdb    *mongo.Collection
	Logger *zap.Logger
}

type Privilege struct {
	mdb    *mongo.Collection
	logger *zap.Logger
}

func NewPrivilegeRepo(deps Deps) *Privilege {
	return &Privilege{
		mdb:    deps.Mdb,
		logger: deps.Logger,
	}
}

func (p *Privilege) GetAllPrivileges(ctx context.Context) ([]models.Privilege, error) {
	filter := bson.M{"isDeleted": false}
	opts := options.Find()

	cursor, err := p.mdb.Find(ctx, filter, opts)
	if err != nil {
		if err == mongo.ErrNoDocuments {
			return nil, errors.ErrNotFound
		}
		p.logger.Error("failed to find privileges", zap.Error(err))
		return nil, err
	}
	defer cursor.Close(ctx)

	var privileges []models.Privilege
	if err = cursor.All(ctx, &privileges); err != nil {
		p.logger.Error("failed to decode privileges", zap.Error(err))
		return nil, err
	}

	return privileges, nil
}

func (p *Privilege) Create(ctx context.Context, req models.CreateUpdateReq) (models.Privilege, error) {
	exist := models.Privilege{}
	err := p.mdb.FindOne(ctx, bson.M{"privilegeId": req.PrivilegeId}).Decode(exist)
	if err == nil {
		return models.Privilege{}, errors.ErrAlreadyExist
	} else if err != mongo.ErrNoDocuments {
		p.logger.Error("Failed to check existing privilege", zap.Error(err))
		return models.Privilege{}, err
	}

	privilege := models.Privilege{
		ID:          primitive.NewObjectID(),
		Name:        req.Name,
		PrivilegeID: req.PrivilegeId,
		ServiceKey:  req.ServiceKey,
		Description: req.Description,
		Type:        req.Type,
		Value:       req.Value,
		Price:       req.Price,
		CreatedAt:   time.Now(),
		IsDeleted:   false,
	}

	_, err = p.mdb.InsertOne(ctx, privilege)
	if err != nil {
		p.logger.Error("Failed to create privilege", zap.Error(err))
		return models.Privilege{}, err
	}

	return privilege, nil
}

func (p *Privilege) Update(ctx context.Context, req models.CreateUpdateReq) (models.Privilege, error) {
	exist := models.Privilege{}
	err := p.mdb.FindOne(ctx, bson.M{"privilegeId": req.PrivilegeId}).Decode(exist)
	if err == mongo.ErrNoDocuments {
		return models.Privilege{}, errors.ErrNotFound
	} else if err != nil {
		p.logger.Error("Failed to find privilege", zap.Error(err))
		return models.Privilege{}, err
	}

	update := bson.M{
		"$set": bson.M{
			"name":        req.Name,
			"serviceKey":  req.ServiceKey,
			"description": req.Description,
			"type":        req.Type,
			"value":       req.Value,
			"price":       req.Price,
			"updatedAt":   time.Now(),
		},
	}

	_, err = p.mdb.UpdateOne(ctx, bson.M{"privilegeId": req.PrivilegeId}, update)
	if err != nil {
		p.logger.Error("Failed to update privilege", zap.Error(err))
		return models.Privilege{}, err
	}

	exist.Name = req.Name
	exist.ServiceKey = req.ServiceKey
	exist.Description = req.Description
	exist.Type = req.Type
	exist.Value = req.Value
	exist.Price = req.Price
	exist.UpdatedAt = time.Now()

	return exist, nil
}

func (p *Privilege) Delete(ctx context.Context, id string) (models.Privilege, error) {
	var privilege models.Privilege
	filter := bson.M{"privilegeId": id}

	update := bson.M{
		"$set": bson.M{
			"isDeleted": true,
			"deletedAt": time.Now(),
		},
	}

	opts := options.FindOneAndUpdate().SetReturnDocument(options.After)
	err := p.mdb.FindOneAndUpdate(ctx, filter, update, opts).Decode(&privilege)
	if err != nil {
		if err == mongo.ErrNoDocuments {
			return models.Privilege{}, errors.ErrNotFound
		}
		p.logger.Error("failed to delete privilege", zap.Error(err))
		return models.Privilege{}, err
	}

	return privilege, nil
}

func (p *Privilege) GetByID(ctx context.Context, id string) (models.Privilege, error) {
	var privilege models.Privilege
	filter := bson.M{
		"privilegeId": id,
		"isDeleted":   false,
	}

	err := p.mdb.FindOne(ctx, filter).Decode(&privilege)
	if err != nil {
		if err == mongo.ErrNoDocuments {
			return models.Privilege{}, errors.ErrNotFound
		}
		p.logger.Error("failed to get privilege by privilege id", zap.Error(err))
		return models.Privilege{}, err
	}

	return privilege, nil
}

func (p *Privilege) GetByServiceKey(ctx context.Context, serviceKey string) ([]models.Privilege, error) {
	filter := bson.M{
		"serviceKey": serviceKey,
		"isDeleted":  false,
	}
	opts := options.Find()

	cursor, err := p.mdb.Find(ctx, filter, opts)
	if err != nil {
		if err == mongo.ErrNoDocuments {
			return nil, errors.ErrNotFound
		}
		p.logger.Error("failed to find privileges by service key", zap.Error(err))
		return nil, err
	}
	defer cursor.Close(ctx)

	var privileges []models.Privilege
	if err = cursor.All(ctx, &privileges); err != nil {
		p.logger.Error("failed to decode privileges", zap.Error(err))
		return nil, err
	}

	return privileges, nil
}