Yimaru-BackEnd/gen/db/referal.sql.go

// Code generated by sqlc. DO NOT EDIT.
// versions:
//   sqlc v1.29.0
// source: referal.sql

package dbgen

import (
	"context"
)

const CreateReferralCode = `-- name: CreateReferralCode :one
INSERT INTO referral_codes (
              referral_code,
              referrer_id,
              company_id,
              number_of_referrals,
              reward_amount
       )
VALUES ($1, $2, $3, $4, $5)
RETURNING id, referral_code, referrer_id, company_id, is_active, number_of_referrals, reward_amount, created_at, updated_at
`

type CreateReferralCodeParams struct {
	ReferralCode      string `json:"referral_code"`
	ReferrerID        int64  `json:"referrer_id"`
	CompanyID         int64  `json:"company_id"`
	NumberOfReferrals int64  `json:"number_of_referrals"`
	RewardAmount      int64  `json:"reward_amount"`
}

func (q *Queries) CreateReferralCode(ctx context.Context, arg CreateReferralCodeParams) (ReferralCode, error) {
	row := q.db.QueryRow(ctx, CreateReferralCode,
		arg.ReferralCode,
		arg.ReferrerID,
		arg.CompanyID,
		arg.NumberOfReferrals,
		arg.RewardAmount,
	)
	var i ReferralCode
	err := row.Scan(
		&i.ID,
		&i.ReferralCode,
		&i.ReferrerID,
		&i.CompanyID,
		&i.IsActive,
		&i.NumberOfReferrals,
		&i.RewardAmount,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const CreateUserReferral = `-- name: CreateUserReferral :one
INSERT INTO user_referrals (referred_id, referral_code_id)
VALUES ($1, $2)
RETURNING id, referred_id, referral_code_id, created_at
`

type CreateUserReferralParams struct {
	ReferredID     int64 `json:"referred_id"`
	ReferralCodeID int64 `json:"referral_code_id"`
}

func (q *Queries) CreateUserReferral(ctx context.Context, arg CreateUserReferralParams) (UserReferral, error) {
	row := q.db.QueryRow(ctx, CreateUserReferral, arg.ReferredID, arg.ReferralCodeID)
	var i UserReferral
	err := row.Scan(
		&i.ID,
		&i.ReferredID,
		&i.ReferralCodeID,
		&i.CreatedAt,
	)
	return i, err
}

const GetReferralCode = `-- name: GetReferralCode :one
SELECT id, referral_code, referrer_id, company_id, is_active, number_of_referrals, reward_amount, created_at, updated_at
FROM referral_codes
WHERE referral_code = $1
`

func (q *Queries) GetReferralCode(ctx context.Context, referralCode string) (ReferralCode, error) {
	row := q.db.QueryRow(ctx, GetReferralCode, referralCode)
	var i ReferralCode
	err := row.Scan(
		&i.ID,
		&i.ReferralCode,
		&i.ReferrerID,
		&i.CompanyID,
		&i.IsActive,
		&i.NumberOfReferrals,
		&i.RewardAmount,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const GetReferralCodeByUser = `-- name: GetReferralCodeByUser :many
SELECt id, referral_code, referrer_id, company_id, is_active, number_of_referrals, reward_amount, created_at, updated_at
FROM referral_codes
WHERE referrer_id = $1
`

func (q *Queries) GetReferralCodeByUser(ctx context.Context, referrerID int64) ([]ReferralCode, error) {
	rows, err := q.db.Query(ctx, GetReferralCodeByUser, referrerID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []ReferralCode
	for rows.Next() {
		var i ReferralCode
		if err := rows.Scan(
			&i.ID,
			&i.ReferralCode,
			&i.ReferrerID,
			&i.CompanyID,
			&i.IsActive,
			&i.NumberOfReferrals,
			&i.RewardAmount,
			&i.CreatedAt,
			&i.UpdatedAt,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const GetReferralStats = `-- name: GetReferralStats :one
SELECT COUNT(*) AS total_referrals,
       COALESCE(SUM(reward_amount), 0)::bigint AS total_reward_earned
FROM user_referrals
       JOIN referral_codes ON referral_codes.id = referral_code_id
WHERE referrer_id = $1
       AND company_id = $2
`

type GetReferralStatsParams struct {
	ReferrerID int64 `json:"referrer_id"`
	CompanyID  int64 `json:"company_id"`
}

type GetReferralStatsRow struct {
	TotalReferrals    int64 `json:"total_referrals"`
	TotalRewardEarned int64 `json:"total_reward_earned"`
}

func (q *Queries) GetReferralStats(ctx context.Context, arg GetReferralStatsParams) (GetReferralStatsRow, error) {
	row := q.db.QueryRow(ctx, GetReferralStats, arg.ReferrerID, arg.CompanyID)
	var i GetReferralStatsRow
	err := row.Scan(&i.TotalReferrals, &i.TotalRewardEarned)
	return i, err
}

const GetUserReferral = `-- name: GetUserReferral :one
SELECT id, referred_id, referral_code_id, created_at
FROM user_referrals
WHERE referred_id = $1
`

func (q *Queries) GetUserReferral(ctx context.Context, referredID int64) (UserReferral, error) {
	row := q.db.QueryRow(ctx, GetUserReferral, referredID)
	var i UserReferral
	err := row.Scan(
		&i.ID,
		&i.ReferredID,
		&i.ReferralCodeID,
		&i.CreatedAt,
	)
	return i, err
}

const GetUserReferralsByCode = `-- name: GetUserReferralsByCode :many
SELECT user_referrals.id, user_referrals.referred_id, user_referrals.referral_code_id, user_referrals.created_at
FROM user_referrals
       JOIN referral_codes ON referral_codes.id = referral_code_id
WHERE referral_code = $1
`

func (q *Queries) GetUserReferralsByCode(ctx context.Context, referralCode string) ([]UserReferral, error) {
	rows, err := q.db.Query(ctx, GetUserReferralsByCode, referralCode)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []UserReferral
	for rows.Next() {
		var i UserReferral
		if err := rows.Scan(
			&i.ID,
			&i.ReferredID,
			&i.ReferralCodeID,
			&i.CreatedAt,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const GetUserReferralsCount = `-- name: GetUserReferralsCount :one
SELECT COUNT(*)
FROM user_referrals
       JOIN referral_codes ON referral_codes.id = referral_code_id
WHERE referrer_id = $1
`

func (q *Queries) GetUserReferralsCount(ctx context.Context, referrerID int64) (int64, error) {
	row := q.db.QueryRow(ctx, GetUserReferralsCount, referrerID)
	var count int64
	err := row.Scan(&count)
	return count, err
}

const UpdateReferralCode = `-- name: UpdateReferralCode :exec
UPDATE referral_codes
SET is_active = $2,
       referral_code = $3,
       number_of_referrals = $4,
       reward_amount = $5,
       updated_at = CURRENT_TIMESTAMP
WHERE id = $1
`

type UpdateReferralCodeParams struct {
	ID                int64  `json:"id"`
	IsActive          bool   `json:"is_active"`
	ReferralCode      string `json:"referral_code"`
	NumberOfReferrals int64  `json:"number_of_referrals"`
	RewardAmount      int64  `json:"reward_amount"`
}

func (q *Queries) UpdateReferralCode(ctx context.Context, arg UpdateReferralCodeParams) error {
	_, err := q.db.Exec(ctx, UpdateReferralCode,
		arg.ID,
		arg.IsActive,
		arg.ReferralCode,
		arg.NumberOfReferrals,
		arg.RewardAmount,
	)
	return err
}