Yimaru-BackEnd/internal/repository/referal.go

package repository

import (
	"context"

	dbgen "github.com/SamuelTariku/FortuneBet-Backend/gen/db"
	"github.com/SamuelTariku/FortuneBet-Backend/internal/domain"
)

type ReferralRepository interface {
	CreateReferralCode(ctx context.Context, referralCode domain.CreateReferralCode) (domain.ReferralCode, error)
	CreateUserReferral(ctx context.Context, referral domain.CreateUserReferrals) (domain.UserReferral, error)
	GetReferralCodesByUser(ctx context.Context, userID int64) ([]domain.ReferralCode, error)
	GetReferralCode(ctx context.Context, code string) (domain.ReferralCode, error)
	UpdateReferralCode(ctx context.Context, referral domain.UpdateReferralCode) error
	GetReferralStats(ctx context.Context, userID int64, companyID int64) (domain.ReferralStats, error)
	GetUserReferral(ctx context.Context, referredID int64) (domain.UserReferral, error)
	GetUserReferralsByCode(ctx context.Context, code string) ([]domain.UserReferral, error)
	GetUserReferralCount(ctx context.Context, referrerID int64) (int64, error)
}

type ReferralRepo struct {
	store *Store
}

func NewReferralRepository(store *Store) ReferralRepository {
	return &ReferralRepo{store: store}
}

func (r *ReferralRepo) CreateReferralCode(ctx context.Context, referralCode domain.CreateReferralCode) (domain.ReferralCode, error) {
	newReferralCode, err := r.store.queries.CreateReferralCode(ctx, domain.ConvertCreateReferralCode(referralCode))

	if err != nil {
		return domain.ReferralCode{}, err
	}
	return domain.ConvertDBReferralCode(newReferralCode), nil
}

func (r *ReferralRepo) CreateUserReferral(ctx context.Context, referral domain.CreateUserReferrals) (domain.UserReferral, error) {
	newReferral, err := r.store.queries.CreateUserReferral(ctx, domain.ConvertCreateUserReferral(referral))

	if err != nil {
		return domain.UserReferral{}, err
	}

	return domain.ConvertDBUserReferral(newReferral), nil
}

func (r *ReferralRepo) GetReferralCodesByUser(ctx context.Context, userID int64) ([]domain.ReferralCode, error) {
	codes, err := r.store.queries.GetReferralCodeByUser(ctx, userID)

	if err != nil {
		return nil, err
	}

	return domain.ConvertDBReferralCodes(codes), nil
}

func (r *ReferralRepo) GetReferralCode(ctx context.Context, code string) (domain.ReferralCode, error) {
	referralCode, err := r.store.queries.GetReferralCode(ctx, code)

	if err != nil {
		return domain.ReferralCode{}, err
	}

	return domain.ConvertDBReferralCode(referralCode), nil

}
func (r *ReferralRepo) UpdateReferralCode(ctx context.Context, referral domain.UpdateReferralCode) error {
	err := r.store.queries.UpdateReferralCode(ctx, domain.ConvertUpdateReferralCode(referral))

	if err != nil {
		return err
	}

	return nil
}

func (r *ReferralRepo) GetReferralStats(ctx context.Context, userID int64, companyID int64) (domain.ReferralStats, error) {
	stats, err := r.store.queries.GetReferralStats(ctx, dbgen.GetReferralStatsParams{
		ReferrerID: userID,
		CompanyID:  companyID,
	})
	if err != nil {
		return domain.ReferralStats{}, err
	}

	return domain.ConvertDBReferralStats(stats), nil
}

func (r *ReferralRepo) GetUserReferral(ctx context.Context, referredID int64) (domain.UserReferral, error) {
	dbReferral, err := r.store.queries.GetUserReferral(ctx, referredID)
	if err != nil {
		return domain.UserReferral{}, err
	}
	return domain.ConvertDBUserReferral(dbReferral), nil
}

func (r *ReferralRepo) GetUserReferralsByCode(ctx context.Context, code string) ([]domain.UserReferral, error) {
	dbReferrals, err := r.store.queries.GetUserReferralsByCode(ctx, code)

	if err != nil {
		return nil, err
	}

	return domain.ConvertDBUserReferrals(dbReferrals), nil
}

func (r *ReferralRepo) GetUserReferralCount(ctx context.Context, referrerID int64) (int64, error) {
	count, err := r.store.queries.GetUserReferralsCount(ctx, referrerID)
	if err != nil {
		return 0, err
	}
	return count, nil
}

// func (r *ReferralRepo) mapToDomainReferral(dbRef *dbgen.Referral) *domain.Referral {
// 	var referredID *int64
// 	if dbRef.ReferredID.Valid {
// 		referredID = &dbRef.ReferredID.Int64
// 	}

// 	rewardAmount := 0.0
// 	if dbRef.RewardAmount.Valid {
// 		if f8, err := dbRef.RewardAmount.Float64Value(); err == nil {
// 			rewardAmount = f8.Float64
// 		}
// 	}

// 	cashbackAmount := 0.0
// 	if dbRef.CashbackAmount.Valid {
// 		if f8, err := dbRef.CashbackAmount.Float64Value(); err == nil {
// 			cashbackAmount = f8.Float64
// 		}
// 	}

// 	return &domain.Referral{
// 		ID:             dbRef.ID,
// 		ReferralCode:   dbRef.ReferralCode,
// 		ReferrerID:     dbRef.ReferrerID,
// 		ReferredID:     referredID,
// 		Status:         domain.ReferralStatus(dbRef.Status),
// 		RewardAmount:   rewardAmount,
// 		CashbackAmount: cashbackAmount,
// 		CreatedAt:      dbRef.CreatedAt.Time,
// 		UpdatedAt:      dbRef.UpdatedAt.Time,
// 		ExpiresAt:      dbRef.ExpiresAt.Time,
// 	}
// }

// func (r *ReferralRepo) mapToDomainSettings(dbSettings *dbgen.ReferralSetting) *domain.ReferralSettings {
// 	rewardAmount := 0.0
// 	if dbSettings.ReferralRewardAmount.Valid {
// 		if f8, err := dbSettings.ReferralRewardAmount.Float64Value(); err == nil {
// 			rewardAmount = f8.Float64
// 		}
// 	}

// 	cashbackPercentage := 0.0
// 	if dbSettings.CashbackPercentage.Valid {
// 		if f8, err := dbSettings.CashbackPercentage.Float64Value(); err == nil {
// 			cashbackPercentage = f8.Float64
// 		}
// 	}

// 	betReferralBonusPercentage := 0.0
// 	if dbSettings.BetReferralBonusPercentage.Valid {
// 		if f8, err := dbSettings.BetReferralBonusPercentage.Float64Value(); err == nil {
// 			betReferralBonusPercentage = f8.Float64
// 		}
// 	}

// 	return &domain.ReferralSettings{
// 		ID:                         dbSettings.ID,
// 		ReferralRewardAmount:       rewardAmount,
// 		CashbackPercentage:         cashbackPercentage,
// 		BetReferralBonusPercentage: betReferralBonusPercentage, // New field
// 		MaxReferrals:               dbSettings.MaxReferrals,
// 		ExpiresAfterDays:           dbSettings.ExpiresAfterDays,
// 		UpdatedBy:                  dbSettings.UpdatedBy,
// 		CreatedAt:                  dbSettings.CreatedAt.Time,
// 		UpdatedAt:                  dbSettings.UpdatedAt.Time,
// 		Version:                    dbSettings.Version,
// 	}
// }