Source identity
| Field | Recorded value |
|---|---|
| Source type | GitHub source |
| Original record | Janady13/missionmatch / internal/platform/database/dbgen/slates.sql.go |
| Date | Not specified in source |
| Repository | Janady13/missionmatch |
| Revision | 720d47fae476b0d38477ae4401697d372b1ea2bc |
| Branch | feature/opportunity-to-outcome |
| Path or archive member | internal/platform/database/dbgen/slates.sql.go |
| Original SHA-256 | cde069c8b29ed5b6680ad947001e7b17e0b04e714708880f6dc79b65a7d32eca |
| Git blob SHA | bca914780b346d8d19d3fb0ae4d4f124615c079a |
| Reading-copy SHA-256 | cde069c8b29ed5b6680ad947001e7b17e0b04e714708880f6dc79b65a7d32eca |
Recovered source transcript
Download complete source text ↓459 lines · 13.7 KB
// Code generated by sqlc. DO NOT EDIT.
// versions:
// sqlc v1.31.1
// source: slates.sql
package dbgen
import (
"context"
"time"
"github.com/google/uuid"
"github.com/shopspring/decimal"
)
const addSlateMember = `-- name: AddSlateMember :one
INSERT INTO slate_members (
organization_id, slate_id, candidate_id,
total_score, band,
clearance_score, skills_score, certs_score, customer_score, experience_score, location_score,
explanation, trace, gap_summary, rank, model_version
) VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16)
RETURNING organization_id, slate_id, candidate_id, total_score, band, clearance_score, skills_score, certs_score, customer_score, experience_score, location_score, explanation, trace, gap_summary, decision, decided_by, decided_at, rank, created_at, model_version, decision_note, status, approved_by_user_id, approved_at, withdrawn_by_user_id, withdrawn_at, withdrawal_reason
`
type AddSlateMemberParams struct {
OrganizationID uuid.UUID `json:"organization_id"`
SlateID uuid.UUID `json:"slate_id"`
CandidateID uuid.UUID `json:"candidate_id"`
TotalScore decimal.Decimal `json:"total_score"`
Band string `json:"band"`
ClearanceScore decimal.Decimal `json:"clearance_score"`
SkillsScore decimal.Decimal `json:"skills_score"`
CertsScore decimal.Decimal `json:"certs_score"`
CustomerScore decimal.Decimal `json:"customer_score"`
ExperienceScore decimal.Decimal `json:"experience_score"`
LocationScore decimal.Decimal `json:"location_score"`
Explanation string `json:"explanation"`
Trace []byte `json:"trace"`
GapSummary []byte `json:"gap_summary"`
Rank *int32 `json:"rank"`
ModelVersion *string `json:"model_version"`
}
func (q *Queries) AddSlateMember(ctx context.Context, arg AddSlateMemberParams) (SlateMember, error) {
row := q.db.QueryRow(ctx, addSlateMember,
arg.OrganizationID,
arg.SlateID,
arg.CandidateID,
arg.TotalScore,
arg.Band,
arg.ClearanceScore,
arg.SkillsScore,
arg.CertsScore,
arg.CustomerScore,
arg.ExperienceScore,
arg.LocationScore,
arg.Explanation,
arg.Trace,
arg.GapSummary,
arg.Rank,
arg.ModelVersion,
)
var i SlateMember
err := row.Scan(
&i.OrganizationID,
&i.SlateID,
&i.CandidateID,
&i.TotalScore,
&i.Band,
&i.ClearanceScore,
&i.SkillsScore,
&i.CertsScore,
&i.CustomerScore,
&i.ExperienceScore,
&i.LocationScore,
&i.Explanation,
&i.Trace,
&i.GapSummary,
&i.Decision,
&i.DecidedBy,
&i.DecidedAt,
&i.Rank,
&i.CreatedAt,
&i.ModelVersion,
&i.DecisionNote,
&i.Status,
&i.ApprovedByUserID,
&i.ApprovedAt,
&i.WithdrawnByUserID,
&i.WithdrawnAt,
&i.WithdrawalReason,
)
return i, err
}
const createSlate = `-- name: CreateSlate :one
INSERT INTO slates (organization_id, requirement_id, name, status, created_by)
VALUES ($1,$2,$3,$4,$5)
RETURNING id, organization_id, requirement_id, name, status, created_by, created_at, updated_at
`
type CreateSlateParams struct {
OrganizationID uuid.UUID `json:"organization_id"`
RequirementID uuid.UUID `json:"requirement_id"`
Name string `json:"name"`
Status string `json:"status"`
CreatedBy *uuid.UUID `json:"created_by"`
}
func (q *Queries) CreateSlate(ctx context.Context, arg CreateSlateParams) (Slate, error) {
row := q.db.QueryRow(ctx, createSlate,
arg.OrganizationID,
arg.RequirementID,
arg.Name,
arg.Status,
arg.CreatedBy,
)
var i Slate
err := row.Scan(
&i.ID,
&i.OrganizationID,
&i.RequirementID,
&i.Name,
&i.Status,
&i.CreatedBy,
&i.CreatedAt,
&i.UpdatedAt,
)
return i, err
}
const getSlate = `-- name: GetSlate :one
SELECT id, organization_id, requirement_id, name, status, created_by, created_at, updated_at FROM slates WHERE id = $1
`
func (q *Queries) GetSlate(ctx context.Context, id uuid.UUID) (Slate, error) {
row := q.db.QueryRow(ctx, getSlate, id)
var i Slate
err := row.Scan(
&i.ID,
&i.OrganizationID,
&i.RequirementID,
&i.Name,
&i.Status,
&i.CreatedBy,
&i.CreatedAt,
&i.UpdatedAt,
)
return i, err
}
const getSlateMember = `-- name: GetSlateMember :one
SELECT organization_id, slate_id, candidate_id, total_score, band, clearance_score, skills_score, certs_score, customer_score, experience_score, location_score, explanation, trace, gap_summary, decision, decided_by, decided_at, rank, created_at, model_version, decision_note, status, approved_by_user_id, approved_at, withdrawn_by_user_id, withdrawn_at, withdrawal_reason FROM slate_members WHERE slate_id = $1 AND candidate_id = $2
`
type GetSlateMemberParams struct {
SlateID uuid.UUID `json:"slate_id"`
CandidateID uuid.UUID `json:"candidate_id"`
}
// PK tiebreaker => total order [review SQLC-5]
// The frozen decision record for one member: the full per component trace, rationale, and gap summary
// for the audit and candidate facing explanation.
func (q *Queries) GetSlateMember(ctx context.Context, arg GetSlateMemberParams) (SlateMember, error) {
row := q.db.QueryRow(ctx, getSlateMember, arg.SlateID, arg.CandidateID)
var i SlateMember
err := row.Scan(
&i.OrganizationID,
&i.SlateID,
&i.CandidateID,
&i.TotalScore,
&i.Band,
&i.ClearanceScore,
&i.SkillsScore,
&i.CertsScore,
&i.CustomerScore,
&i.ExperienceScore,
&i.LocationScore,
&i.Explanation,
&i.Trace,
&i.GapSummary,
&i.Decision,
&i.DecidedBy,
&i.DecidedAt,
&i.Rank,
&i.CreatedAt,
&i.ModelVersion,
&i.DecisionNote,
&i.Status,
&i.ApprovedByUserID,
&i.ApprovedAt,
&i.WithdrawnByUserID,
&i.WithdrawnAt,
&i.WithdrawalReason,
)
return i, err
}
const listSlateMembers = `-- name: ListSlateMembers :many
SELECT organization_id, slate_id, candidate_id, total_score, band, clearance_score, skills_score, certs_score, customer_score, experience_score, location_score, explanation, trace, gap_summary, decision, decided_by, decided_at, rank, created_at, model_version, decision_note, status, approved_by_user_id, approved_at, withdrawn_by_user_id, withdrawn_at, withdrawal_reason FROM slate_members
WHERE slate_id = $1
ORDER BY rank NULLS LAST, total_score DESC, candidate_id
`
func (q *Queries) ListSlateMembers(ctx context.Context, slateID uuid.UUID) ([]SlateMember, error) {
rows, err := q.db.Query(ctx, listSlateMembers, slateID)
if err != nil {
return nil, err
}
defer rows.Close()
items := []SlateMember{}
for rows.Next() {
var i SlateMember
if err := rows.Scan(
&i.OrganizationID,
&i.SlateID,
&i.CandidateID,
&i.TotalScore,
&i.Band,
&i.ClearanceScore,
&i.SkillsScore,
&i.CertsScore,
&i.CustomerScore,
&i.ExperienceScore,
&i.LocationScore,
&i.Explanation,
&i.Trace,
&i.GapSummary,
&i.Decision,
&i.DecidedBy,
&i.DecidedAt,
&i.Rank,
&i.CreatedAt,
&i.ModelVersion,
&i.DecisionNote,
&i.Status,
&i.ApprovedByUserID,
&i.ApprovedAt,
&i.WithdrawnByUserID,
&i.WithdrawnAt,
&i.WithdrawalReason,
); err != nil {
return nil, err
}
items = append(items, i)
}
if err := rows.Err(); err != nil {
return nil, err
}
return items, nil
}
const listSlateMembersWithNames = `-- name: ListSlateMembersWithNames :many
SELECT sm.organization_id, sm.slate_id, sm.candidate_id, sm.total_score, sm.band, sm.clearance_score, sm.skills_score, sm.certs_score, sm.customer_score, sm.experience_score, sm.location_score, sm.explanation, sm.trace, sm.gap_summary, sm.decision, sm.decided_by, sm.decided_at, sm.rank, sm.created_at, sm.model_version, sm.decision_note, sm.status, sm.approved_by_user_id, sm.approved_at, sm.withdrawn_by_user_id, sm.withdrawn_at, sm.withdrawal_reason, c.full_name
FROM slate_members sm
JOIN candidates c ON c.organization_id = sm.organization_id AND c.id = sm.candidate_id
WHERE sm.slate_id = $1
ORDER BY sm.rank NULLS LAST, sm.total_score DESC, sm.candidate_id
`
type ListSlateMembersWithNamesRow struct {
OrganizationID uuid.UUID `json:"organization_id"`
SlateID uuid.UUID `json:"slate_id"`
CandidateID uuid.UUID `json:"candidate_id"`
TotalScore decimal.Decimal `json:"total_score"`
Band string `json:"band"`
ClearanceScore decimal.Decimal `json:"clearance_score"`
SkillsScore decimal.Decimal `json:"skills_score"`
CertsScore decimal.Decimal `json:"certs_score"`
CustomerScore decimal.Decimal `json:"customer_score"`
ExperienceScore decimal.Decimal `json:"experience_score"`
LocationScore decimal.Decimal `json:"location_score"`
Explanation string `json:"explanation"`
Trace []byte `json:"trace"`
GapSummary []byte `json:"gap_summary"`
Decision string `json:"decision"`
DecidedBy *uuid.UUID `json:"decided_by"`
DecidedAt *time.Time `json:"decided_at"`
Rank *int32 `json:"rank"`
CreatedAt time.Time `json:"created_at"`
ModelVersion *string `json:"model_version"`
DecisionNote *string `json:"decision_note"`
Status string `json:"status"`
ApprovedByUserID *uuid.UUID `json:"approved_by_user_id"`
ApprovedAt *time.Time `json:"approved_at"`
WithdrawnByUserID *uuid.UUID `json:"withdrawn_by_user_id"`
WithdrawnAt *time.Time `json:"withdrawn_at"`
WithdrawalReason string `json:"withdrawal_reason"`
FullName string `json:"full_name"`
}
// The slate roster joined to the candidate name for the slateMATCH detail and the branded export. Both
// tables are RLS scoped to the caller's org, so the join cannot cross tenants.
func (q *Queries) ListSlateMembersWithNames(ctx context.Context, slateID uuid.UUID) ([]ListSlateMembersWithNamesRow, error) {
rows, err := q.db.Query(ctx, listSlateMembersWithNames, slateID)
if err != nil {
return nil, err
}
defer rows.Close()
items := []ListSlateMembersWithNamesRow{}
for rows.Next() {
var i ListSlateMembersWithNamesRow
if err := rows.Scan(
&i.OrganizationID,
&i.SlateID,
&i.CandidateID,
&i.TotalScore,
&i.Band,
&i.ClearanceScore,
&i.SkillsScore,
&i.CertsScore,
&i.CustomerScore,
&i.ExperienceScore,
&i.LocationScore,
&i.Explanation,
&i.Trace,
&i.GapSummary,
&i.Decision,
&i.DecidedBy,
&i.DecidedAt,
&i.Rank,
&i.CreatedAt,
&i.ModelVersion,
&i.DecisionNote,
&i.Status,
&i.ApprovedByUserID,
&i.ApprovedAt,
&i.WithdrawnByUserID,
&i.WithdrawnAt,
&i.WithdrawalReason,
&i.FullName,
); err != nil {
return nil, err
}
items = append(items, i)
}
if err := rows.Err(); err != nil {
return nil, err
}
return items, nil
}
const listSlatesForRequirement = `-- name: ListSlatesForRequirement :many
SELECT id, organization_id, requirement_id, name, status, created_by, created_at, updated_at FROM slates WHERE requirement_id = $1 ORDER BY created_at DESC, id
`
func (q *Queries) ListSlatesForRequirement(ctx context.Context, requirementID uuid.UUID) ([]Slate, error) {
rows, err := q.db.Query(ctx, listSlatesForRequirement, requirementID)
if err != nil {
return nil, err
}
defer rows.Close()
items := []Slate{}
for rows.Next() {
var i Slate
if err := rows.Scan(
&i.ID,
&i.OrganizationID,
&i.RequirementID,
&i.Name,
&i.Status,
&i.CreatedBy,
&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 setSlateMemberDecision = `-- name: SetSlateMemberDecision :one
UPDATE slate_members
SET decision = $3, decided_by = $4, decision_note = $5, decided_at = now()
WHERE slate_id = $1 AND candidate_id = $2
RETURNING organization_id, slate_id, candidate_id, total_score, band, clearance_score, skills_score, certs_score, customer_score, experience_score, location_score, explanation, trace, gap_summary, decision, decided_by, decided_at, rank, created_at, model_version, decision_note, status, approved_by_user_id, approved_at, withdrawn_by_user_id, withdrawn_at, withdrawal_reason
`
type SetSlateMemberDecisionParams struct {
SlateID uuid.UUID `json:"slate_id"`
CandidateID uuid.UUID `json:"candidate_id"`
Decision string `json:"decision"`
DecidedBy *uuid.UUID `json:"decided_by"`
DecisionNote *string `json:"decision_note"`
}
// Human-in-the-loop: a person approves/rejects each member, optionally with a note. Never auto-decided.
func (q *Queries) SetSlateMemberDecision(ctx context.Context, arg SetSlateMemberDecisionParams) (SlateMember, error) {
row := q.db.QueryRow(ctx, setSlateMemberDecision,
arg.SlateID,
arg.CandidateID,
arg.Decision,
arg.DecidedBy,
arg.DecisionNote,
)
var i SlateMember
err := row.Scan(
&i.OrganizationID,
&i.SlateID,
&i.CandidateID,
&i.TotalScore,
&i.Band,
&i.ClearanceScore,
&i.SkillsScore,
&i.CertsScore,
&i.CustomerScore,
&i.ExperienceScore,
&i.LocationScore,
&i.Explanation,
&i.Trace,
&i.GapSummary,
&i.Decision,
&i.DecidedBy,
&i.DecidedAt,
&i.Rank,
&i.CreatedAt,
&i.ModelVersion,
&i.DecisionNote,
&i.Status,
&i.ApprovedByUserID,
&i.ApprovedAt,
&i.WithdrawnByUserID,
&i.WithdrawnAt,
&i.WithdrawalReason,
)
return i, err
}
const updateSlateStatus = `-- name: UpdateSlateStatus :one
UPDATE slates SET status = $2, updated_at = now() WHERE id = $1 RETURNING id, organization_id, requirement_id, name, status, created_by, created_at, updated_at
`
type UpdateSlateStatusParams struct {
ID uuid.UUID `json:"id"`
Status string `json:"status"`
}
func (q *Queries) UpdateSlateStatus(ctx context.Context, arg UpdateSlateStatusParams) (Slate, error) {
row := q.db.QueryRow(ctx, updateSlateStatus, arg.ID, arg.Status)
var i Slate
err := row.Scan(
&i.ID,
&i.OrganizationID,
&i.RequirementID,
&i.Name,
&i.Status,
&i.CreatedBy,
&i.CreatedAt,
&i.UpdatedAt,
)
return i, err
}