codeword/internal/repository/user_repository.go

package repository

import (
	"codeword/internal/models"
	"context"
	"encoding/json"
	"github.com/go-redis/redis/v8"
	"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/readpref"
	"time"
)

type Deps struct {
	Mdb *mongo.Collection
	Rdb *redis.Client
}

type codewordRepository struct {
	mdb *mongo.Collection
	rdb *redis.Client
}

type userRepository struct {
	mdb *mongo.Collection
}

func NewUserRepository(deps Deps) *userRepository {

	return &userRepository{mdb: deps.Mdb}
}

func NewCodewordRepository(deps Deps) *codewordRepository {

	return &codewordRepository{mdb: deps.Mdb, rdb: deps.Rdb}
}

func (r *userRepository) FindByEmail(ctx context.Context, email string) (*models.User, error) {
	var user models.User

	err := r.mdb.FindOne(ctx, bson.M{"email": email}).Decode(&user)
	if err != nil {
		if err == mongo.ErrNoDocuments {
			return nil, nil
		}
		return nil, err
	}
	return &user, nil
}

func (r *codewordRepository) StoreRecoveryRecord(ctx context.Context, userID, email, key, url string) (string, error) {
	newID := primitive.NewObjectID()
	record := models.RestoreRequest{
		ID:        newID,
		UserID:    userID,
		Email:     email,
		Sign:      key,
		SignUrl:   url,
		CreatedAt: time.Now(),
	}

	_, err := r.mdb.InsertOne(ctx, record)
	if err != nil {
		return "", err
	}

	return newID.Hex(), nil
}

func (r *codewordRepository) InsertToQueue(ctx context.Context, userID string, email string, key []byte, id string) error {
	task := models.RecoveryRecord{
		ID:     id,
		UserID: userID,
		Email:  email,
		Key:    key,
	}

	taskBytes, err := json.Marshal(task)
	if err != nil {
		return err
	}

	if err := r.rdb.LPush(ctx, "recoveryQueue", taskBytes).Err(); err != nil {
		return err
	}

	return nil
}

func (r *codewordRepository) GetRecoveryRecord(ctx context.Context, key string) (*models.RestoreRequest, error) {
	var restoreRequest models.RestoreRequest

	filter := bson.M{"sign": key}

	err := r.mdb.FindOne(ctx, filter).Decode(&restoreRequest)
	if err != nil {
		return nil, err
	}

	return &restoreRequest, nil
}

func (r *codewordRepository) Ping(ctx context.Context) error {
	return r.mdb.Database().Client().Ping(ctx, readpref.Primary())
}