customer/internal/repository/amocrm.go

package repository

import (
	"context"
	"time"

	"github.com/sirupsen/logrus"
	"go.mongodb.org/mongo-driver/bson"
	"go.mongodb.org/mongo-driver/bson/primitive"
	"go.mongodb.org/mongo-driver/mongo"
	"penahub.gitlab.yandexcloud.net/pena-services/customer/internal/errors"
	"penahub.gitlab.yandexcloud.net/pena-services/customer/internal/fields"
	"penahub.gitlab.yandexcloud.net/pena-services/customer/internal/models"
	mongoWrapper "penahub.gitlab.yandexcloud.net/pena-services/customer/pkg/mongo"
)

type AmocrmRepository struct {
	mongoDB *mongo.Collection
	logger  *logrus.Logger
}

func NewAmocrmRepository(mongoDB *mongo.Collection, logger *logrus.Logger) *AmocrmRepository {
	return &AmocrmRepository{
		mongoDB: mongoDB,
		logger:  logger,
	}
}

func (receiver *AmocrmRepository) FindByID(ctx context.Context, amocrmID string) (*models.AmocrmUser, error) {
	filter := bson.M{
		fields.AmocrmUser.AmocrmID: amocrmID,
		fields.Audit.Deleted:       false,
	}

	user, err := mongoWrapper.FindOne[models.AmocrmUser](ctx, &mongoWrapper.RequestSettings{
		Driver: receiver.mongoDB,
		Filter: filter,
	})
	if err != nil {
		receiver.logger.Errorf("failed to find amocrm user <%s> on <FindByID> of <AmocrmRepository>: %v", amocrmID, err)

		if err == mongo.ErrNoDocuments {
			return nil, errors.ErrNoRecord
		}

		return nil, errors.ErrFindRecord
	}

	return user, nil
}

func (receiver *AmocrmRepository) FindByUserID(ctx context.Context, userID string) (*models.AmocrmUser, error) {
	filter := bson.M{
		fields.AmocrmUser.UserID: userID,
		fields.Audit.Deleted:     false,
	}

	user, err := mongoWrapper.FindOne[models.AmocrmUser](ctx, &mongoWrapper.RequestSettings{
		Driver: receiver.mongoDB,
		Filter: filter,
	})
	if err != nil {
		receiver.logger.Errorf("failed to find amocrm user <%s> on <FindByUserID> of <AmocrmRepository>: %v", userID, err)

		if err == mongo.ErrNoDocuments {
			return nil, errors.ErrNoRecord
		}

		return nil, errors.ErrFindRecord
	}

	return user, nil
}

func (receiver *AmocrmRepository) Insert(ctx context.Context, user *models.AmocrmUser) (*models.AmocrmUser, error) {
	user.Audit = models.Audit{
		CreatedAt: time.Now(),
		UpdatedAt: time.Now(),
		Deleted:   false,
	}

	result, err := receiver.mongoDB.InsertOne(ctx, user)
	if err != nil {
		receiver.logger.Errorf("failed to insert record on <Insert> of <AmocrmRepository>: %v", err)
		return nil, errors.ErrInsertRecord
	}

	insertedID := result.InsertedID.(primitive.ObjectID).Hex()
	userCopy := *user
	userCopy.ID = insertedID

	return &userCopy, nil
}

func (receiver *AmocrmRepository) Delete(ctx context.Context, amocrmID string) (*models.AmocrmUser, error) {
	user := models.AmocrmUser{}

	update := bson.M{"$set": bson.M{fields.Audit.Deleted: true}}
	filter := bson.M{
		fields.AmocrmUser.AmocrmID: amocrmID,
		fields.Audit.Deleted:       false,
	}

	if err := receiver.mongoDB.FindOneAndUpdate(ctx, filter, update).Decode(&user); err != nil {
		receiver.logger.Errorf("failed to set 'deleted=true' with id <%s> on <Delete> of <AmocrmRepository>: %v", amocrmID, err)

		if err == mongo.ErrNoDocuments {
			return nil, errors.ErrNoRecord
		}

		return nil, errors.ErrUpdateRecord
	}

	return &user, nil
}

func (receiver *AmocrmRepository) Remove(ctx context.Context, id string) (*models.AmocrmUser, error) {
	objectID, err := primitive.ObjectIDFromHex(id)
	if err != nil {
		receiver.logger.Errorf("failed to parse ObjectID <%s> on <FindByID> of <DiscountRepository>: %v", id, err)
		return nil, errors.ErrInvalidArgs
	}

	user := models.AmocrmUser{}

	filter := bson.M{
		fields.AmocrmUser.ID: objectID,
		fields.Audit.Deleted: false,
	}

	if err := receiver.mongoDB.FindOneAndDelete(ctx, filter).Decode(&user); err != nil {
		receiver.logger.Errorf("failed remove user with _id <%s> on <Remove> of <AmocrmRepository>: %v", id, err)

		if err == mongo.ErrNoDocuments {
			return nil, errors.ErrNoRecord
		}

		return nil, errors.ErrUpdateRecord
	}

	return &user, nil
}