Initial commit: Open sourcing all of the Maple Open Technologies code.

cloud/maplefile-backend/internal/repo/blockedemail/blockedemail.go

@@ -0,0 +1,199 @@
+// codeberg.org/mapleopentech/monorepo/cloud/maplefile-backend/internal/repo/blockedemail/blockedemail.go
+package blockedemail
+
+import (
+	"context"
+	"strings"
+
+	"go.uber.org/zap"
+
+	"github.com/gocql/gocql"
+	"codeberg.org/mapleopentech/monorepo/cloud/maplefile-backend/config"
+	dom_blockedemail "codeberg.org/mapleopentech/monorepo/cloud/maplefile-backend/internal/domain/blockedemail"
+	"codeberg.org/mapleopentech/monorepo/cloud/maplefile-backend/pkg/validation"
+)
+
+type blockedEmailRepositoryImpl struct {
+	config  *config.Configuration
+	logger  *zap.Logger
+	session *gocql.Session
+}
+
+func NewBlockedEmailRepository(
+	config *config.Configuration,
+	logger *zap.Logger,
+	session *gocql.Session,
+) dom_blockedemail.BlockedEmailRepository {
+	logger = logger.Named("BlockedEmailRepository")
+	return &blockedEmailRepositoryImpl{
+		config:  config,
+		logger:  logger,
+		session: session,
+	}
+}
+
+func (r *blockedEmailRepositoryImpl) Create(ctx context.Context, blockedEmail *dom_blockedemail.BlockedEmail) error {
+	// Normalize email to lowercase
+	normalizedEmail := strings.ToLower(strings.TrimSpace(blockedEmail.BlockedEmail))
+
+	query := `INSERT INTO user_blocked_emails (
+		user_id, blocked_email, blocked_user_id, reason, created_at
+	) VALUES (?, ?, ?, ?, ?)`
+
+	err := r.session.Query(query,
+		blockedEmail.UserID,
+		normalizedEmail,
+		blockedEmail.BlockedUserID,
+		blockedEmail.Reason,
+		blockedEmail.CreatedAt,
+	).WithContext(ctx).Exec()
+
+	if err != nil {
+		r.logger.Error("Failed to create blocked email",
+			zap.Any("error", err),
+			zap.Any("user_id", blockedEmail.UserID),
+			zap.String("blocked_email", validation.MaskEmail(normalizedEmail)))
+		return err
+	}
+
+	r.logger.Debug("Blocked email created",
+		zap.Any("user_id", blockedEmail.UserID),
+		zap.String("blocked_email", validation.MaskEmail(normalizedEmail)))
+
+	return nil
+}
+
+func (r *blockedEmailRepositoryImpl) Get(ctx context.Context, userID gocql.UUID, blockedEmail string) (*dom_blockedemail.BlockedEmail, error) {
+	// Normalize email to lowercase
+	normalizedEmail := strings.ToLower(strings.TrimSpace(blockedEmail))
+
+	query := `SELECT user_id, blocked_email, blocked_user_id, reason, created_at
+		FROM user_blocked_emails
+		WHERE user_id = ? AND blocked_email = ?`
+
+	var result dom_blockedemail.BlockedEmail
+	err := r.session.Query(query, userID, normalizedEmail).
+		WithContext(ctx).
+		Scan(
+			&result.UserID,
+			&result.BlockedEmail,
+			&result.BlockedUserID,
+			&result.Reason,
+			&result.CreatedAt,
+		)
+
+	if err != nil {
+		if err == gocql.ErrNotFound {
+			return nil, nil
+		}
+		r.logger.Error("Failed to get blocked email",
+			zap.Any("error", err),
+			zap.Any("user_id", userID),
+			zap.String("blocked_email", validation.MaskEmail(normalizedEmail)))
+		return nil, err
+	}
+
+	return &result, nil
+}
+
+func (r *blockedEmailRepositoryImpl) List(ctx context.Context, userID gocql.UUID) ([]*dom_blockedemail.BlockedEmail, error) {
+	query := `SELECT user_id, blocked_email, blocked_user_id, reason, created_at
+		FROM user_blocked_emails
+		WHERE user_id = ?`
+
+	iter := r.session.Query(query, userID).WithContext(ctx).Iter()
+
+	var results []*dom_blockedemail.BlockedEmail
+	var entry dom_blockedemail.BlockedEmail
+
+	for iter.Scan(
+		&entry.UserID,
+		&entry.BlockedEmail,
+		&entry.BlockedUserID,
+		&entry.Reason,
+		&entry.CreatedAt,
+	) {
+		results = append(results, &dom_blockedemail.BlockedEmail{
+			UserID:        entry.UserID,
+			BlockedEmail:  entry.BlockedEmail,
+			BlockedUserID: entry.BlockedUserID,
+			Reason:        entry.Reason,
+			CreatedAt:     entry.CreatedAt,
+		})
+	}
+
+	if err := iter.Close(); err != nil {
+		r.logger.Error("Failed to list blocked emails",
+			zap.Any("error", err),
+			zap.Any("user_id", userID))
+		return nil, err
+	}
+
+	r.logger.Debug("Listed blocked emails",
+		zap.Any("user_id", userID),
+		zap.Int("count", len(results)))
+
+	return results, nil
+}
+
+func (r *blockedEmailRepositoryImpl) Delete(ctx context.Context, userID gocql.UUID, blockedEmail string) error {
+	// Normalize email to lowercase
+	normalizedEmail := strings.ToLower(strings.TrimSpace(blockedEmail))
+
+	query := `DELETE FROM user_blocked_emails WHERE user_id = ? AND blocked_email = ?`
+
+	err := r.session.Query(query, userID, normalizedEmail).WithContext(ctx).Exec()
+	if err != nil {
+		r.logger.Error("Failed to delete blocked email",
+			zap.Any("error", err),
+			zap.Any("user_id", userID),
+			zap.String("blocked_email", validation.MaskEmail(normalizedEmail)))
+		return err
+	}
+
+	r.logger.Debug("Blocked email deleted",
+		zap.Any("user_id", userID),
+		zap.String("blocked_email", validation.MaskEmail(normalizedEmail)))
+
+	return nil
+}
+
+func (r *blockedEmailRepositoryImpl) IsBlocked(ctx context.Context, userID gocql.UUID, email string) (bool, error) {
+	// Normalize email to lowercase
+	normalizedEmail := strings.ToLower(strings.TrimSpace(email))
+
+	query := `SELECT blocked_email FROM user_blocked_emails WHERE user_id = ? AND blocked_email = ?`
+
+	var blockedEmail string
+	err := r.session.Query(query, userID, normalizedEmail).
+		WithContext(ctx).
+		Scan(&blockedEmail)
+
+	if err != nil {
+		if err == gocql.ErrNotFound {
+			return false, nil
+		}
+		r.logger.Error("Failed to check if email is blocked",
+			zap.Any("error", err),
+			zap.Any("user_id", userID),
+			zap.String("email", validation.MaskEmail(normalizedEmail)))
+		return false, err
+	}
+
+	return true, nil
+}
+
+func (r *blockedEmailRepositoryImpl) Count(ctx context.Context, userID gocql.UUID) (int, error) {
+	query := `SELECT COUNT(*) FROM user_blocked_emails WHERE user_id = ?`
+
+	var count int
+	err := r.session.Query(query, userID).WithContext(ctx).Scan(&count)
+	if err != nil {
+		r.logger.Error("Failed to count blocked emails",
+			zap.Any("error", err),
+			zap.Any("user_id", userID))
+		return 0, err
+	}
+
+	return count, nil
+}