cgalo5758
71818de0bd
Implement the ux-first-run change: a state-derived setup checklist on /operator/setup with a landing region that recedes once required steps are done, and empty states that distinguish blocked from empty across operator and member surfaces. Also add production deployment and environment reference docs, plus a config-key completeness test.
423 lines
14 KiB
Go
423 lines
14 KiB
Go
// Code generated by sqlc. DO NOT EDIT.
|
|
// versions:
|
|
// sqlc v1.29.0
|
|
// source: pool_provision_ladders.sql
|
|
|
|
package entitlements
|
|
|
|
import (
|
|
"context"
|
|
"database/sql"
|
|
|
|
"github.com/google/uuid"
|
|
)
|
|
|
|
const anyActiveLadderAttachment = `-- name: AnyActiveLadderAttachment :one
|
|
SELECT EXISTS(SELECT 1 FROM core.pool_provision_ladders WHERE status = 'active')
|
|
`
|
|
|
|
// Empty-validation-domain probe: the topology health strip claims health
|
|
// only when at least one active attachment existed for the checks to cover.
|
|
func (q *Queries) AnyActiveLadderAttachment(ctx context.Context) (bool, error) {
|
|
row := q.db.QueryRowContext(ctx, anyActiveLadderAttachment)
|
|
var exists bool
|
|
err := row.Scan(&exists)
|
|
return exists, err
|
|
}
|
|
|
|
const countActiveAttachmentsByLadder = `-- name: CountActiveAttachmentsByLadder :one
|
|
SELECT COUNT(*) FROM core.pool_provision_ladders
|
|
WHERE plan_ladder_id = $1 AND status = 'active'
|
|
`
|
|
|
|
func (q *Queries) CountActiveAttachmentsByLadder(ctx context.Context, planLadderID string) (int64, error) {
|
|
row := q.db.QueryRowContext(ctx, countActiveAttachmentsByLadder, planLadderID)
|
|
var count int64
|
|
err := row.Scan(&count)
|
|
return count, err
|
|
}
|
|
|
|
const countActiveAttachmentsByTier = `-- name: CountActiveAttachmentsByTier :one
|
|
SELECT COUNT(*) FROM core.pool_provision_ladders
|
|
WHERE plan_ladder_id = $1 AND product_id = $2 AND status = 'active'
|
|
`
|
|
|
|
type CountActiveAttachmentsByTierParams struct {
|
|
PlanLadderID string `json:"plan_ladder_id"`
|
|
ProductID string `json:"product_id"`
|
|
}
|
|
|
|
func (q *Queries) CountActiveAttachmentsByTier(ctx context.Context, arg CountActiveAttachmentsByTierParams) (int64, error) {
|
|
row := q.db.QueryRowContext(ctx, countActiveAttachmentsByTier, arg.PlanLadderID, arg.ProductID)
|
|
var count int64
|
|
err := row.Scan(&count)
|
|
return count, err
|
|
}
|
|
|
|
const getActiveAttachmentsByPool = `-- name: GetActiveAttachmentsByPool :many
|
|
SELECT provision_id, plan_ladder_id, pool_id, status, activated_at, ended_at, created_at, updated_at, product_id, provision_ladder_id FROM core.pool_provision_ladders
|
|
WHERE pool_id = $1 AND status = 'active'
|
|
ORDER BY activated_at DESC
|
|
`
|
|
|
|
func (q *Queries) GetActiveAttachmentsByPool(ctx context.Context, poolID string) ([]PoolProvisionLadder, error) {
|
|
rows, err := q.db.QueryContext(ctx, getActiveAttachmentsByPool, poolID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
items := []PoolProvisionLadder{}
|
|
for rows.Next() {
|
|
var i PoolProvisionLadder
|
|
if err := rows.Scan(
|
|
&i.ProvisionID,
|
|
&i.PlanLadderID,
|
|
&i.PoolID,
|
|
&i.Status,
|
|
&i.ActivatedAt,
|
|
&i.EndedAt,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.ProductID,
|
|
&i.ProvisionLadderID,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Close(); err != nil {
|
|
return nil, err
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const getActiveLadderAttachmentByPoolLadder = `-- name: GetActiveLadderAttachmentByPoolLadder :one
|
|
|
|
SELECT provision_id, plan_ladder_id, pool_id, status, activated_at, ended_at, created_at, updated_at, product_id, provision_ladder_id FROM core.pool_provision_ladders
|
|
WHERE pool_id = $1 AND plan_ladder_id = $2 AND status = 'active'
|
|
LIMIT 1
|
|
`
|
|
|
|
type GetActiveLadderAttachmentByPoolLadderParams struct {
|
|
PoolID string `json:"pool_id"`
|
|
PlanLadderID string `json:"plan_ladder_id"`
|
|
}
|
|
|
|
// Writes to core.pool_provision_ladders go through the conferral functions
|
|
// (queries/conferral.sql) alone; core_writer holds no direct DML on this
|
|
// table (migration 00005 enclosure). Only read paths live here.
|
|
func (q *Queries) GetActiveLadderAttachmentByPoolLadder(ctx context.Context, arg GetActiveLadderAttachmentByPoolLadderParams) (PoolProvisionLadder, error) {
|
|
row := q.db.QueryRowContext(ctx, getActiveLadderAttachmentByPoolLadder, arg.PoolID, arg.PlanLadderID)
|
|
var i PoolProvisionLadder
|
|
err := row.Scan(
|
|
&i.ProvisionID,
|
|
&i.PlanLadderID,
|
|
&i.PoolID,
|
|
&i.Status,
|
|
&i.ActivatedAt,
|
|
&i.EndedAt,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.ProductID,
|
|
&i.ProvisionLadderID,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const getLadderAttachmentsByPool = `-- name: GetLadderAttachmentsByPool :many
|
|
SELECT provision_id, plan_ladder_id, pool_id, status, activated_at, ended_at, created_at, updated_at, product_id, provision_ladder_id FROM core.pool_provision_ladders
|
|
WHERE pool_id = $1
|
|
ORDER BY activated_at DESC
|
|
`
|
|
|
|
func (q *Queries) GetLadderAttachmentsByPool(ctx context.Context, poolID string) ([]PoolProvisionLadder, error) {
|
|
rows, err := q.db.QueryContext(ctx, getLadderAttachmentsByPool, poolID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
items := []PoolProvisionLadder{}
|
|
for rows.Next() {
|
|
var i PoolProvisionLadder
|
|
if err := rows.Scan(
|
|
&i.ProvisionID,
|
|
&i.PlanLadderID,
|
|
&i.PoolID,
|
|
&i.Status,
|
|
&i.ActivatedAt,
|
|
&i.EndedAt,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.ProductID,
|
|
&i.ProvisionLadderID,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Close(); err != nil {
|
|
return nil, err
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const getLadderAttachmentsByProvision = `-- name: GetLadderAttachmentsByProvision :many
|
|
SELECT provision_id, plan_ladder_id, pool_id, status, activated_at, ended_at, created_at, updated_at, product_id, provision_ladder_id FROM core.pool_provision_ladders
|
|
WHERE provision_id = $1
|
|
ORDER BY activated_at ASC
|
|
`
|
|
|
|
func (q *Queries) GetLadderAttachmentsByProvision(ctx context.Context, provisionID string) ([]PoolProvisionLadder, error) {
|
|
rows, err := q.db.QueryContext(ctx, getLadderAttachmentsByProvision, provisionID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
items := []PoolProvisionLadder{}
|
|
for rows.Next() {
|
|
var i PoolProvisionLadder
|
|
if err := rows.Scan(
|
|
&i.ProvisionID,
|
|
&i.PlanLadderID,
|
|
&i.PoolID,
|
|
&i.Status,
|
|
&i.ActivatedAt,
|
|
&i.EndedAt,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.ProductID,
|
|
&i.ProvisionLadderID,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Close(); err != nil {
|
|
return nil, err
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const getLivePlanAttachmentsWithSourceByPool = `-- name: GetLivePlanAttachmentsWithSourceByPool :many
|
|
SELECT l.provision_ladder_id, l.plan_ladder_id, l.provision_id,
|
|
l.status AS attachment_status,
|
|
p.product_id, p.grant_id, p.subscription_id, p.purchase_id,
|
|
g.grant_reason
|
|
FROM core.pool_provision_ladders l
|
|
JOIN core.pool_provisions p ON p.provision_id = l.provision_id
|
|
LEFT JOIN core.grants g ON g.grant_id = p.grant_id
|
|
WHERE l.pool_id = $1 AND l.status IN ('active', 'suspended')
|
|
ORDER BY l.activated_at DESC
|
|
`
|
|
|
|
type GetLivePlanAttachmentsWithSourceByPoolRow struct {
|
|
ProvisionLadderID string `json:"provision_ladder_id"`
|
|
PlanLadderID string `json:"plan_ladder_id"`
|
|
ProvisionID string `json:"provision_id"`
|
|
AttachmentStatus string `json:"attachment_status"`
|
|
ProductID string `json:"product_id"`
|
|
GrantID uuid.NullUUID `json:"grant_id"`
|
|
SubscriptionID uuid.NullUUID `json:"subscription_id"`
|
|
PurchaseID uuid.NullUUID `json:"purchase_id"`
|
|
GrantReason sql.NullString `json:"grant_reason"`
|
|
}
|
|
|
|
// Live (active|suspended) plan-ladder attachments for a pool together with
|
|
// their source provenance, for the org-type default-change classification:
|
|
// a grant-sourced row with grant_reason = 'default' marks the pool as holding
|
|
// the outgoing default (bucket 2); any other live row is another source's
|
|
// plan (bucket 3); no rows at all is a plan-less pool (bucket 1).
|
|
func (q *Queries) GetLivePlanAttachmentsWithSourceByPool(ctx context.Context, poolID string) ([]GetLivePlanAttachmentsWithSourceByPoolRow, error) {
|
|
rows, err := q.db.QueryContext(ctx, getLivePlanAttachmentsWithSourceByPool, poolID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
items := []GetLivePlanAttachmentsWithSourceByPoolRow{}
|
|
for rows.Next() {
|
|
var i GetLivePlanAttachmentsWithSourceByPoolRow
|
|
if err := rows.Scan(
|
|
&i.ProvisionLadderID,
|
|
&i.PlanLadderID,
|
|
&i.ProvisionID,
|
|
&i.AttachmentStatus,
|
|
&i.ProductID,
|
|
&i.GrantID,
|
|
&i.SubscriptionID,
|
|
&i.PurchaseID,
|
|
&i.GrantReason,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Close(); err != nil {
|
|
return nil, err
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const listLivePlanPositionsByOrgType = `-- name: ListLivePlanPositionsByOrgType :many
|
|
SELECT o.org_id, o.name, o.slug,
|
|
rp.pool_id,
|
|
l.provision_ladder_id, l.plan_ladder_id, l.provision_id,
|
|
l.status AS attachment_status,
|
|
p.product_id, p.grant_id, p.subscription_id, p.purchase_id,
|
|
g.grant_reason
|
|
FROM core.organizations o
|
|
LEFT JOIN core.resource_pools rp
|
|
ON rp.org_id = o.org_id AND rp.pool_type = 'default' AND rp.status = 'active'
|
|
LEFT JOIN core.pool_provision_ladders l
|
|
ON l.pool_id = rp.pool_id AND l.status IN ('active', 'suspended')
|
|
LEFT JOIN core.pool_provisions p ON p.provision_id = l.provision_id
|
|
LEFT JOIN core.grants g ON g.grant_id = p.grant_id
|
|
WHERE o.org_type = $1
|
|
ORDER BY o.name, o.org_id
|
|
`
|
|
|
|
type ListLivePlanPositionsByOrgTypeRow struct {
|
|
OrgID string `json:"org_id"`
|
|
Name string `json:"name"`
|
|
Slug string `json:"slug"`
|
|
PoolID uuid.NullUUID `json:"pool_id"`
|
|
ProvisionLadderID uuid.NullUUID `json:"provision_ladder_id"`
|
|
PlanLadderID uuid.NullUUID `json:"plan_ladder_id"`
|
|
ProvisionID uuid.NullUUID `json:"provision_id"`
|
|
AttachmentStatus sql.NullString `json:"attachment_status"`
|
|
ProductID uuid.NullUUID `json:"product_id"`
|
|
GrantID uuid.NullUUID `json:"grant_id"`
|
|
SubscriptionID uuid.NullUUID `json:"subscription_id"`
|
|
PurchaseID uuid.NullUUID `json:"purchase_id"`
|
|
GrantReason sql.NullString `json:"grant_reason"`
|
|
}
|
|
|
|
// The whole population for the org-type default-change classification in one
|
|
// round trip: one row per (org, live plan attachment), plus a row with NULL
|
|
// pool for orgs lacking a default pool and a row with NULL attachment for
|
|
// plan-less pools (LEFT JOINs). Replaces a per-org query pair, which does not
|
|
// scale past a few hundred organizations of one type.
|
|
func (q *Queries) ListLivePlanPositionsByOrgType(ctx context.Context, orgType string) ([]ListLivePlanPositionsByOrgTypeRow, error) {
|
|
rows, err := q.db.QueryContext(ctx, listLivePlanPositionsByOrgType, orgType)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
items := []ListLivePlanPositionsByOrgTypeRow{}
|
|
for rows.Next() {
|
|
var i ListLivePlanPositionsByOrgTypeRow
|
|
if err := rows.Scan(
|
|
&i.OrgID,
|
|
&i.Name,
|
|
&i.Slug,
|
|
&i.PoolID,
|
|
&i.ProvisionLadderID,
|
|
&i.PlanLadderID,
|
|
&i.ProvisionID,
|
|
&i.AttachmentStatus,
|
|
&i.ProductID,
|
|
&i.GrantID,
|
|
&i.SubscriptionID,
|
|
&i.PurchaseID,
|
|
&i.GrantReason,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Close(); err != nil {
|
|
return nil, err
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const listLiveTierHoldersByLadderProduct = `-- name: ListLiveTierHoldersByLadderProduct :many
|
|
SELECT l.provision_ladder_id, l.provision_id, l.status AS attachment_status,
|
|
p.product_id, p.grant_id, p.subscription_id, p.purchase_id,
|
|
g.grant_reason,
|
|
rp.pool_id, o.org_id, o.name, o.slug
|
|
FROM core.pool_provision_ladders l
|
|
JOIN core.pool_provisions p ON p.provision_id = l.provision_id
|
|
JOIN core.resource_pools rp ON rp.pool_id = l.pool_id
|
|
JOIN core.organizations o ON o.org_id = rp.org_id
|
|
LEFT JOIN core.grants g ON g.grant_id = p.grant_id
|
|
WHERE l.plan_ladder_id = $1 AND p.product_id = $2
|
|
AND l.status IN ('active', 'suspended')
|
|
ORDER BY o.name, o.org_id
|
|
`
|
|
|
|
type ListLiveTierHoldersByLadderProductParams struct {
|
|
PlanLadderID string `json:"plan_ladder_id"`
|
|
ProductID string `json:"product_id"`
|
|
}
|
|
|
|
type ListLiveTierHoldersByLadderProductRow struct {
|
|
ProvisionLadderID string `json:"provision_ladder_id"`
|
|
ProvisionID string `json:"provision_id"`
|
|
AttachmentStatus string `json:"attachment_status"`
|
|
ProductID string `json:"product_id"`
|
|
GrantID uuid.NullUUID `json:"grant_id"`
|
|
SubscriptionID uuid.NullUUID `json:"subscription_id"`
|
|
PurchaseID uuid.NullUUID `json:"purchase_id"`
|
|
GrantReason sql.NullString `json:"grant_reason"`
|
|
PoolID string `json:"pool_id"`
|
|
OrgID string `json:"org_id"`
|
|
Name string `json:"name"`
|
|
Slug string `json:"slug"`
|
|
}
|
|
|
|
// The tier-removal preview/commit population in one round trip: every live
|
|
// (active|suspended) junction on this ladder whose provision delivers this
|
|
// product, with the org (name/slug) and grant provenance so holders classify
|
|
// per position source (default-sourced needs a disposition; any other source
|
|
// is align-shrunk and never force-ended).
|
|
func (q *Queries) ListLiveTierHoldersByLadderProduct(ctx context.Context, arg ListLiveTierHoldersByLadderProductParams) ([]ListLiveTierHoldersByLadderProductRow, error) {
|
|
rows, err := q.db.QueryContext(ctx, listLiveTierHoldersByLadderProduct, arg.PlanLadderID, arg.ProductID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
items := []ListLiveTierHoldersByLadderProductRow{}
|
|
for rows.Next() {
|
|
var i ListLiveTierHoldersByLadderProductRow
|
|
if err := rows.Scan(
|
|
&i.ProvisionLadderID,
|
|
&i.ProvisionID,
|
|
&i.AttachmentStatus,
|
|
&i.ProductID,
|
|
&i.GrantID,
|
|
&i.SubscriptionID,
|
|
&i.PurchaseID,
|
|
&i.GrantReason,
|
|
&i.PoolID,
|
|
&i.OrgID,
|
|
&i.Name,
|
|
&i.Slug,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Close(); err != nil {
|
|
return nil, err
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|