// Code generated by sqlc. DO NOT EDIT. // versions: // sqlc v1.30.0 // source: subscriptions.sql package dbgen import ( "context" "github.com/jackc/pgx/v5/pgtype" ) const CancelUserSubscription = `-- name: CancelUserSubscription :exec UPDATE user_subscriptions SET status = 'CANCELLED', cancelled_at = CURRENT_TIMESTAMP, auto_renew = false, updated_at = CURRENT_TIMESTAMP WHERE id = $1 ` func (q *Queries) CancelUserSubscription(ctx context.Context, id int64) error { _, err := q.db.Exec(ctx, CancelUserSubscription, id) return err } const CountUserSubscriptions = `-- name: CountUserSubscriptions :one SELECT COUNT(*) FROM user_subscriptions WHERE user_id = $1 ` func (q *Queries) CountUserSubscriptions(ctx context.Context, userID int64) (int64, error) { row := q.db.QueryRow(ctx, CountUserSubscriptions, userID) var count int64 err := row.Scan(&count) return count, err } const CreateSubscriptionPlan = `-- name: CreateSubscriptionPlan :one INSERT INTO subscription_plans ( name, description, duration_value, duration_unit, price, currency, is_active ) VALUES ($1, $2, $3, $4, $5, $6, COALESCE($7, true)) RETURNING id, name, description, duration_value, duration_unit, price, currency, is_active, created_at, updated_at ` type CreateSubscriptionPlanParams struct { Name string `json:"name"` Description pgtype.Text `json:"description"` DurationValue int32 `json:"duration_value"` DurationUnit string `json:"duration_unit"` Price pgtype.Numeric `json:"price"` Currency string `json:"currency"` Column7 interface{} `json:"column_7"` } // ===================== // Subscription Plans // ===================== func (q *Queries) CreateSubscriptionPlan(ctx context.Context, arg CreateSubscriptionPlanParams) (SubscriptionPlan, error) { row := q.db.QueryRow(ctx, CreateSubscriptionPlan, arg.Name, arg.Description, arg.DurationValue, arg.DurationUnit, arg.Price, arg.Currency, arg.Column7, ) var i SubscriptionPlan err := row.Scan( &i.ID, &i.Name, &i.Description, &i.DurationValue, &i.DurationUnit, &i.Price, &i.Currency, &i.IsActive, &i.CreatedAt, &i.UpdatedAt, ) return i, err } const CreateUserSubscription = `-- name: CreateUserSubscription :one INSERT INTO user_subscriptions ( user_id, plan_id, starts_at, expires_at, status, payment_reference, payment_method, auto_renew ) VALUES ($1, $2, COALESCE($3, CURRENT_TIMESTAMP), $4, COALESCE($5, 'ACTIVE'), $6, $7, COALESCE($8, false)) RETURNING id, user_id, plan_id, starts_at, expires_at, status, payment_reference, payment_method, auto_renew, cancelled_at, created_at, updated_at ` type CreateUserSubscriptionParams struct { UserID int64 `json:"user_id"` PlanID int64 `json:"plan_id"` Column3 interface{} `json:"column_3"` ExpiresAt pgtype.Timestamptz `json:"expires_at"` Column5 interface{} `json:"column_5"` PaymentReference pgtype.Text `json:"payment_reference"` PaymentMethod pgtype.Text `json:"payment_method"` Column8 interface{} `json:"column_8"` } // ===================== // User Subscriptions // ===================== func (q *Queries) CreateUserSubscription(ctx context.Context, arg CreateUserSubscriptionParams) (UserSubscription, error) { row := q.db.QueryRow(ctx, CreateUserSubscription, arg.UserID, arg.PlanID, arg.Column3, arg.ExpiresAt, arg.Column5, arg.PaymentReference, arg.PaymentMethod, arg.Column8, ) var i UserSubscription err := row.Scan( &i.ID, &i.UserID, &i.PlanID, &i.StartsAt, &i.ExpiresAt, &i.Status, &i.PaymentReference, &i.PaymentMethod, &i.AutoRenew, &i.CancelledAt, &i.CreatedAt, &i.UpdatedAt, ) return i, err } const DeleteSubscriptionPlan = `-- name: DeleteSubscriptionPlan :exec DELETE FROM subscription_plans WHERE id = $1 ` func (q *Queries) DeleteSubscriptionPlan(ctx context.Context, id int64) error { _, err := q.db.Exec(ctx, DeleteSubscriptionPlan, id) return err } const ExpireUserSubscription = `-- name: ExpireUserSubscription :exec UPDATE user_subscriptions SET status = 'EXPIRED', updated_at = CURRENT_TIMESTAMP WHERE id = $1 ` func (q *Queries) ExpireUserSubscription(ctx context.Context, id int64) error { _, err := q.db.Exec(ctx, ExpireUserSubscription, id) return err } const ExtendSubscription = `-- name: ExtendSubscription :exec UPDATE user_subscriptions SET expires_at = $1, updated_at = CURRENT_TIMESTAMP WHERE id = $2 ` type ExtendSubscriptionParams struct { ExpiresAt pgtype.Timestamptz `json:"expires_at"` ID int64 `json:"id"` } func (q *Queries) ExtendSubscription(ctx context.Context, arg ExtendSubscriptionParams) error { _, err := q.db.Exec(ctx, ExtendSubscription, arg.ExpiresAt, arg.ID) return err } const GetActiveSubscriptionByUserID = `-- name: GetActiveSubscriptionByUserID :one SELECT us.id, us.user_id, us.plan_id, us.starts_at, us.expires_at, us.status, us.payment_reference, us.payment_method, us.auto_renew, us.cancelled_at, us.created_at, us.updated_at, sp.name AS plan_name, sp.duration_value, sp.duration_unit, sp.price, sp.currency FROM user_subscriptions us JOIN subscription_plans sp ON sp.id = us.plan_id WHERE us.user_id = $1 AND us.status = 'ACTIVE' AND us.expires_at > CURRENT_TIMESTAMP ORDER BY us.expires_at DESC LIMIT 1 ` type GetActiveSubscriptionByUserIDRow struct { ID int64 `json:"id"` UserID int64 `json:"user_id"` PlanID int64 `json:"plan_id"` StartsAt pgtype.Timestamptz `json:"starts_at"` ExpiresAt pgtype.Timestamptz `json:"expires_at"` Status string `json:"status"` PaymentReference pgtype.Text `json:"payment_reference"` PaymentMethod pgtype.Text `json:"payment_method"` AutoRenew bool `json:"auto_renew"` CancelledAt pgtype.Timestamptz `json:"cancelled_at"` CreatedAt pgtype.Timestamptz `json:"created_at"` UpdatedAt pgtype.Timestamptz `json:"updated_at"` PlanName string `json:"plan_name"` DurationValue int32 `json:"duration_value"` DurationUnit string `json:"duration_unit"` Price pgtype.Numeric `json:"price"` Currency string `json:"currency"` } func (q *Queries) GetActiveSubscriptionByUserID(ctx context.Context, userID int64) (GetActiveSubscriptionByUserIDRow, error) { row := q.db.QueryRow(ctx, GetActiveSubscriptionByUserID, userID) var i GetActiveSubscriptionByUserIDRow err := row.Scan( &i.ID, &i.UserID, &i.PlanID, &i.StartsAt, &i.ExpiresAt, &i.Status, &i.PaymentReference, &i.PaymentMethod, &i.AutoRenew, &i.CancelledAt, &i.CreatedAt, &i.UpdatedAt, &i.PlanName, &i.DurationValue, &i.DurationUnit, &i.Price, &i.Currency, ) return i, err } const GetExpiredSubscriptions = `-- name: GetExpiredSubscriptions :many SELECT us.id, us.user_id, us.plan_id, us.starts_at, us.expires_at, us.status, us.payment_reference, us.payment_method, us.auto_renew, us.cancelled_at, us.created_at, us.updated_at, sp.name AS plan_name FROM user_subscriptions us JOIN subscription_plans sp ON sp.id = us.plan_id WHERE us.status = 'ACTIVE' AND us.expires_at <= CURRENT_TIMESTAMP ` type GetExpiredSubscriptionsRow struct { ID int64 `json:"id"` UserID int64 `json:"user_id"` PlanID int64 `json:"plan_id"` StartsAt pgtype.Timestamptz `json:"starts_at"` ExpiresAt pgtype.Timestamptz `json:"expires_at"` Status string `json:"status"` PaymentReference pgtype.Text `json:"payment_reference"` PaymentMethod pgtype.Text `json:"payment_method"` AutoRenew bool `json:"auto_renew"` CancelledAt pgtype.Timestamptz `json:"cancelled_at"` CreatedAt pgtype.Timestamptz `json:"created_at"` UpdatedAt pgtype.Timestamptz `json:"updated_at"` PlanName string `json:"plan_name"` } func (q *Queries) GetExpiredSubscriptions(ctx context.Context) ([]GetExpiredSubscriptionsRow, error) { rows, err := q.db.Query(ctx, GetExpiredSubscriptions) if err != nil { return nil, err } defer rows.Close() var items []GetExpiredSubscriptionsRow for rows.Next() { var i GetExpiredSubscriptionsRow if err := rows.Scan( &i.ID, &i.UserID, &i.PlanID, &i.StartsAt, &i.ExpiresAt, &i.Status, &i.PaymentReference, &i.PaymentMethod, &i.AutoRenew, &i.CancelledAt, &i.CreatedAt, &i.UpdatedAt, &i.PlanName, ); err != nil { return nil, err } items = append(items, i) } if err := rows.Err(); err != nil { return nil, err } return items, nil } const GetExpiringSubscriptions = `-- name: GetExpiringSubscriptions :many SELECT us.id, us.user_id, us.plan_id, us.starts_at, us.expires_at, us.status, us.payment_reference, us.payment_method, us.auto_renew, us.cancelled_at, us.created_at, us.updated_at, sp.name AS plan_name, u.email, u.first_name FROM user_subscriptions us JOIN subscription_plans sp ON sp.id = us.plan_id JOIN users u ON u.id = us.user_id WHERE us.status = 'ACTIVE' AND us.expires_at > CURRENT_TIMESTAMP AND us.expires_at <= CURRENT_TIMESTAMP + INTERVAL '7 days' ` type GetExpiringSubscriptionsRow struct { ID int64 `json:"id"` UserID int64 `json:"user_id"` PlanID int64 `json:"plan_id"` StartsAt pgtype.Timestamptz `json:"starts_at"` ExpiresAt pgtype.Timestamptz `json:"expires_at"` Status string `json:"status"` PaymentReference pgtype.Text `json:"payment_reference"` PaymentMethod pgtype.Text `json:"payment_method"` AutoRenew bool `json:"auto_renew"` CancelledAt pgtype.Timestamptz `json:"cancelled_at"` CreatedAt pgtype.Timestamptz `json:"created_at"` UpdatedAt pgtype.Timestamptz `json:"updated_at"` PlanName string `json:"plan_name"` Email pgtype.Text `json:"email"` FirstName pgtype.Text `json:"first_name"` } func (q *Queries) GetExpiringSubscriptions(ctx context.Context) ([]GetExpiringSubscriptionsRow, error) { rows, err := q.db.Query(ctx, GetExpiringSubscriptions) if err != nil { return nil, err } defer rows.Close() var items []GetExpiringSubscriptionsRow for rows.Next() { var i GetExpiringSubscriptionsRow if err := rows.Scan( &i.ID, &i.UserID, &i.PlanID, &i.StartsAt, &i.ExpiresAt, &i.Status, &i.PaymentReference, &i.PaymentMethod, &i.AutoRenew, &i.CancelledAt, &i.CreatedAt, &i.UpdatedAt, &i.PlanName, &i.Email, &i.FirstName, ); err != nil { return nil, err } items = append(items, i) } if err := rows.Err(); err != nil { return nil, err } return items, nil } const GetSubscriptionPlanByID = `-- name: GetSubscriptionPlanByID :one SELECT id, name, description, duration_value, duration_unit, price, currency, is_active, created_at, updated_at FROM subscription_plans WHERE id = $1 ` func (q *Queries) GetSubscriptionPlanByID(ctx context.Context, id int64) (SubscriptionPlan, error) { row := q.db.QueryRow(ctx, GetSubscriptionPlanByID, id) var i SubscriptionPlan err := row.Scan( &i.ID, &i.Name, &i.Description, &i.DurationValue, &i.DurationUnit, &i.Price, &i.Currency, &i.IsActive, &i.CreatedAt, &i.UpdatedAt, ) return i, err } const GetUserSubscriptionByID = `-- name: GetUserSubscriptionByID :one SELECT us.id, us.user_id, us.plan_id, us.starts_at, us.expires_at, us.status, us.payment_reference, us.payment_method, us.auto_renew, us.cancelled_at, us.created_at, us.updated_at, sp.name AS plan_name, sp.duration_value, sp.duration_unit, sp.price, sp.currency FROM user_subscriptions us JOIN subscription_plans sp ON sp.id = us.plan_id WHERE us.id = $1 ` type GetUserSubscriptionByIDRow struct { ID int64 `json:"id"` UserID int64 `json:"user_id"` PlanID int64 `json:"plan_id"` StartsAt pgtype.Timestamptz `json:"starts_at"` ExpiresAt pgtype.Timestamptz `json:"expires_at"` Status string `json:"status"` PaymentReference pgtype.Text `json:"payment_reference"` PaymentMethod pgtype.Text `json:"payment_method"` AutoRenew bool `json:"auto_renew"` CancelledAt pgtype.Timestamptz `json:"cancelled_at"` CreatedAt pgtype.Timestamptz `json:"created_at"` UpdatedAt pgtype.Timestamptz `json:"updated_at"` PlanName string `json:"plan_name"` DurationValue int32 `json:"duration_value"` DurationUnit string `json:"duration_unit"` Price pgtype.Numeric `json:"price"` Currency string `json:"currency"` } func (q *Queries) GetUserSubscriptionByID(ctx context.Context, id int64) (GetUserSubscriptionByIDRow, error) { row := q.db.QueryRow(ctx, GetUserSubscriptionByID, id) var i GetUserSubscriptionByIDRow err := row.Scan( &i.ID, &i.UserID, &i.PlanID, &i.StartsAt, &i.ExpiresAt, &i.Status, &i.PaymentReference, &i.PaymentMethod, &i.AutoRenew, &i.CancelledAt, &i.CreatedAt, &i.UpdatedAt, &i.PlanName, &i.DurationValue, &i.DurationUnit, &i.Price, &i.Currency, ) return i, err } const GetUserSubscriptionHistory = `-- name: GetUserSubscriptionHistory :many SELECT us.id, us.user_id, us.plan_id, us.starts_at, us.expires_at, us.status, us.payment_reference, us.payment_method, us.auto_renew, us.cancelled_at, us.created_at, us.updated_at, sp.name AS plan_name, sp.duration_value, sp.duration_unit, sp.price, sp.currency FROM user_subscriptions us JOIN subscription_plans sp ON sp.id = us.plan_id WHERE us.user_id = $1 ORDER BY us.created_at DESC LIMIT $3::INT OFFSET $2::INT ` type GetUserSubscriptionHistoryParams struct { UserID int64 `json:"user_id"` Offset pgtype.Int4 `json:"offset"` Limit pgtype.Int4 `json:"limit"` } type GetUserSubscriptionHistoryRow struct { ID int64 `json:"id"` UserID int64 `json:"user_id"` PlanID int64 `json:"plan_id"` StartsAt pgtype.Timestamptz `json:"starts_at"` ExpiresAt pgtype.Timestamptz `json:"expires_at"` Status string `json:"status"` PaymentReference pgtype.Text `json:"payment_reference"` PaymentMethod pgtype.Text `json:"payment_method"` AutoRenew bool `json:"auto_renew"` CancelledAt pgtype.Timestamptz `json:"cancelled_at"` CreatedAt pgtype.Timestamptz `json:"created_at"` UpdatedAt pgtype.Timestamptz `json:"updated_at"` PlanName string `json:"plan_name"` DurationValue int32 `json:"duration_value"` DurationUnit string `json:"duration_unit"` Price pgtype.Numeric `json:"price"` Currency string `json:"currency"` } func (q *Queries) GetUserSubscriptionHistory(ctx context.Context, arg GetUserSubscriptionHistoryParams) ([]GetUserSubscriptionHistoryRow, error) { rows, err := q.db.Query(ctx, GetUserSubscriptionHistory, arg.UserID, arg.Offset, arg.Limit) if err != nil { return nil, err } defer rows.Close() var items []GetUserSubscriptionHistoryRow for rows.Next() { var i GetUserSubscriptionHistoryRow if err := rows.Scan( &i.ID, &i.UserID, &i.PlanID, &i.StartsAt, &i.ExpiresAt, &i.Status, &i.PaymentReference, &i.PaymentMethod, &i.AutoRenew, &i.CancelledAt, &i.CreatedAt, &i.UpdatedAt, &i.PlanName, &i.DurationValue, &i.DurationUnit, &i.Price, &i.Currency, ); err != nil { return nil, err } items = append(items, i) } if err := rows.Err(); err != nil { return nil, err } return items, nil } const HasActiveSubscription = `-- name: HasActiveSubscription :one SELECT EXISTS( SELECT 1 FROM user_subscriptions WHERE user_id = $1 AND status = 'ACTIVE' AND expires_at > CURRENT_TIMESTAMP ) AS has_subscription ` func (q *Queries) HasActiveSubscription(ctx context.Context, userID int64) (bool, error) { row := q.db.QueryRow(ctx, HasActiveSubscription, userID) var has_subscription bool err := row.Scan(&has_subscription) return has_subscription, err } const ListActiveSubscriptionPlans = `-- name: ListActiveSubscriptionPlans :many SELECT id, name, description, duration_value, duration_unit, price, currency, is_active, created_at, updated_at FROM subscription_plans WHERE is_active = true ORDER BY price ASC ` func (q *Queries) ListActiveSubscriptionPlans(ctx context.Context) ([]SubscriptionPlan, error) { rows, err := q.db.Query(ctx, ListActiveSubscriptionPlans) if err != nil { return nil, err } defer rows.Close() var items []SubscriptionPlan for rows.Next() { var i SubscriptionPlan if err := rows.Scan( &i.ID, &i.Name, &i.Description, &i.DurationValue, &i.DurationUnit, &i.Price, &i.Currency, &i.IsActive, &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 ListSubscriptionPlans = `-- name: ListSubscriptionPlans :many SELECT id, name, description, duration_value, duration_unit, price, currency, is_active, created_at, updated_at FROM subscription_plans WHERE ($1::BOOLEAN IS NULL OR $1 = true AND is_active = true OR $1 = false) ORDER BY price ASC ` func (q *Queries) ListSubscriptionPlans(ctx context.Context, dollar_1 bool) ([]SubscriptionPlan, error) { rows, err := q.db.Query(ctx, ListSubscriptionPlans, dollar_1) if err != nil { return nil, err } defer rows.Close() var items []SubscriptionPlan for rows.Next() { var i SubscriptionPlan if err := rows.Scan( &i.ID, &i.Name, &i.Description, &i.DurationValue, &i.DurationUnit, &i.Price, &i.Currency, &i.IsActive, &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 UpdateAutoRenew = `-- name: UpdateAutoRenew :exec UPDATE user_subscriptions SET auto_renew = $1, updated_at = CURRENT_TIMESTAMP WHERE id = $2 ` type UpdateAutoRenewParams struct { AutoRenew bool `json:"auto_renew"` ID int64 `json:"id"` } func (q *Queries) UpdateAutoRenew(ctx context.Context, arg UpdateAutoRenewParams) error { _, err := q.db.Exec(ctx, UpdateAutoRenew, arg.AutoRenew, arg.ID) return err } const UpdateSubscriptionPlan = `-- name: UpdateSubscriptionPlan :exec UPDATE subscription_plans SET name = COALESCE($1, name), description = COALESCE($2, description), duration_value = COALESCE($3, duration_value), duration_unit = COALESCE($4, duration_unit), price = COALESCE($5, price), currency = COALESCE($6, currency), is_active = COALESCE($7, is_active), updated_at = CURRENT_TIMESTAMP WHERE id = $8 ` type UpdateSubscriptionPlanParams struct { Name string `json:"name"` Description pgtype.Text `json:"description"` DurationValue int32 `json:"duration_value"` DurationUnit string `json:"duration_unit"` Price pgtype.Numeric `json:"price"` Currency string `json:"currency"` IsActive bool `json:"is_active"` ID int64 `json:"id"` } func (q *Queries) UpdateSubscriptionPlan(ctx context.Context, arg UpdateSubscriptionPlanParams) error { _, err := q.db.Exec(ctx, UpdateSubscriptionPlan, arg.Name, arg.Description, arg.DurationValue, arg.DurationUnit, arg.Price, arg.Currency, arg.IsActive, arg.ID, ) return err } const UpdateUserSubscriptionStatus = `-- name: UpdateUserSubscriptionStatus :exec UPDATE user_subscriptions SET status = $1, updated_at = CURRENT_TIMESTAMP WHERE id = $2 ` type UpdateUserSubscriptionStatusParams struct { Status string `json:"status"` ID int64 `json:"id"` } func (q *Queries) UpdateUserSubscriptionStatus(ctx context.Context, arg UpdateUserSubscriptionStatusParams) error { _, err := q.db.Exec(ctx, UpdateUserSubscriptionStatus, arg.Status, arg.ID) return err }