gohorsejobs/backend/internal/infrastructure/persistence/postgres/user_repository.go

package postgres

import (
	"context"
	"database/sql"
	"time"

	"github.com/rede5/gohorsejobs/backend/internal/core/domain/entity"
)

type UserRepository struct {
	db *sql.DB
}

func NewUserRepository(db *sql.DB) *UserRepository {
	return &UserRepository{db: db}
}

func (r *UserRepository) Save(ctx context.Context, user *entity.User) (*entity.User, error) {
	tx, err := r.db.BeginTx(ctx, nil)
	if err != nil {
		return nil, err
	}
	defer tx.Rollback()

	// TenantID is string (UUID) or empty
	var tenantID *string
	if user.TenantID != "" {
		tenantID = &user.TenantID
	}

	// 1. Insert User - users table has UUID id
	query := `
		INSERT INTO users (identifier, password_hash, role, full_name, email, name, tenant_id, status, created_at, updated_at)
		VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)
		RETURNING id
	`

	var id string
	// Map the first role to the role column, default to 'candidate'
	role := "candidate"
	if len(user.Roles) > 0 {
		role = user.Roles[0].Name
	}

	err = tx.QueryRowContext(ctx, query,
		user.Email, // identifier = email for now
		user.PasswordHash,
		role,
		user.Name,
		user.Email,
		user.Name,
		tenantID,
		user.Status,
		user.CreatedAt,
		user.UpdatedAt,
	).Scan(&id)

	if err != nil {
		return nil, err
	}
	user.ID = id

	// 2. Insert Roles into user_roles table
	if len(user.Roles) > 0 {
		roleQuery := `INSERT INTO user_roles (user_id, role) VALUES ($1, $2) ON CONFLICT DO NOTHING`
		for _, role := range user.Roles {
			_, err := tx.ExecContext(ctx, roleQuery, id, role.Name)
			if err != nil {
				return nil, err
			}
		}
	}

	if err := tx.Commit(); err != nil {
		return nil, err
	}

	return user, nil
}

func (r *UserRepository) FindByEmail(ctx context.Context, email string) (*entity.User, error) {
	query := `SELECT id, COALESCE(tenant_id::text, ''), COALESCE(name, full_name, ''), 
		COALESCE(email, identifier), password_hash, COALESCE(status, 'active'), created_at, updated_at 
		FROM users WHERE email = $1 OR identifier = $1`
	row := r.db.QueryRowContext(ctx, query, email)

	u := &entity.User{}
	var dbID string
	err := row.Scan(&dbID, &u.TenantID, &u.Name, &u.Email, &u.PasswordHash, &u.Status, &u.CreatedAt, &u.UpdatedAt)
	if err != nil {
		if err == sql.ErrNoRows {
			return nil, nil // Return nil if not found
		}
		return nil, err
	}
	u.ID = dbID
	u.Roles, _ = r.getRoles(ctx, dbID)
	return u, nil
}

func (r *UserRepository) FindByID(ctx context.Context, id string) (*entity.User, error) {
	query := `SELECT id, COALESCE(tenant_id::text, ''), COALESCE(name, full_name, ''), 
		COALESCE(email, identifier), password_hash, COALESCE(status, 'active'), created_at, updated_at 
		FROM users WHERE id = $1`
	row := r.db.QueryRowContext(ctx, query, id)

	u := &entity.User{}
	var dbID string
	err := row.Scan(&dbID, &u.TenantID, &u.Name, &u.Email, &u.PasswordHash, &u.Status, &u.CreatedAt, &u.UpdatedAt)
	if err != nil {
		return nil, err
	}
	u.ID = dbID
	u.Roles, _ = r.getRoles(ctx, dbID)
	return u, nil
}

func (r *UserRepository) FindAllByTenant(ctx context.Context, tenantID string, limit, offset int) ([]*entity.User, int, error) {
	var total int
	countQuery := `SELECT COUNT(*) FROM users WHERE tenant_id = $1`
	if err := r.db.QueryRowContext(ctx, countQuery, tenantID).Scan(&total); err != nil {
		return nil, 0, err
	}

	query := `SELECT id, COALESCE(tenant_id::text, ''), COALESCE(name, full_name, ''), 
		COALESCE(email, identifier), password_hash, COALESCE(status, 'active'), created_at, updated_at
		FROM users
		WHERE tenant_id = $1
		ORDER BY created_at DESC
		LIMIT $2 OFFSET $3`
	rows, err := r.db.QueryContext(ctx, query, tenantID, limit, offset)
	if err != nil {
		return nil, 0, err
	}
	defer rows.Close()

	var users []*entity.User
	for rows.Next() {
		u := &entity.User{}
		var dbID string
		if err := rows.Scan(&dbID, &u.TenantID, &u.Name, &u.Email, &u.PasswordHash, &u.Status, &u.CreatedAt, &u.UpdatedAt); err != nil {
			return nil, 0, err
		}
		u.ID = dbID
		u.Roles, _ = r.getRoles(ctx, dbID)
		users = append(users, u)
	}
	return users, total, nil
}

func (r *UserRepository) Update(ctx context.Context, user *entity.User) (*entity.User, error) {
	user.UpdatedAt = time.Now()
	query := `UPDATE users SET name=$1, email=$2, status=$3, updated_at=$4 WHERE id=$5`
	_, err := r.db.ExecContext(ctx, query, user.Name, user.Email, user.Status, user.UpdatedAt, user.ID)
	return user, err
}

func (r *UserRepository) Delete(ctx context.Context, id string) error {
	_, err := r.db.ExecContext(ctx, `DELETE FROM users WHERE id=$1`, id)
	return err
}

func (r *UserRepository) getRoles(ctx context.Context, userID string) ([]entity.Role, error) {
	rows, err := r.db.QueryContext(ctx, `SELECT role FROM user_roles WHERE user_id = $1`, userID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var roles []entity.Role
	for rows.Next() {
		var roleName string
		rows.Scan(&roleName)
		roles = append(roles, entity.Role{Name: roleName})
	}
	return roles, nil
}