Janady13/missionmatch / internal/modules/staffing/gap.go

Source identity

Field	Recorded value
Source type	GitHub source
Original record	Janady13/missionmatch / internal/modules/staffing/gap.go
Date	Not specified in source
Repository	Janady13/missionmatch
Revision	720d47fae476b0d38477ae4401697d372b1ea2bc
Branch	feature/opportunity-to-outcome
Path or archive member	internal/modules/staffing/gap.go
Original SHA-256	67d6585a5e8d73279785911e37b0efe2184550f056793eb9cba6a85a85e74732
Git blob SHA	1c72dd8571126f4d31f8926c650ffbc3428b0562
Reading-copy SHA-256	67d6585a5e8d73279785911e37b0efe2184550f056793eb9cba6a85a85e74732

Original source ↗

Every recorded occurrence

These 24 records contain identical original source bytes. Their paths and revisions remain part of the archive.

Original record	Branch or archive	Revision / identifier	Original location
Janady13/missionmatch / internal/modules/staffing/gap.go	feature/opportunity-to-outcome	720d47fae476b0d38477ae4401697d372b1ea2bc	Open original
Janady13/missionmatch / internal/modules/staffing/gap.go	per-tenant-routing	9bde0f9a74b89d01980fa658e5253acda7528d0c	Open original
Janady13/missionmatch / internal/modules/staffing/gap.go	collision-deconfliction	4ee5a09972608ed89f8377c6665542d5f450f0a6	Open original
Janady13/missionmatch / internal/modules/staffing/gap.go	ws6-retrieval	6c56e29231ec05735927fa265c97d517499dfeaf	Open original
Janady13/missionmatch / internal/modules/staffing/gap.go	m5-price-to-win	41000ad30fff4129fdaf5ec84e15ba14c27d4890	Open original
Janady13/missionmatch / internal/modules/staffing/gap.go	ws1-ontology-sync	b596f449a32a1016fbd403c36505cc00a1ac9ee6	Open original
Janady13/missionmatch / internal/modules/staffing/gap.go	master	1e9249840a4302ec82e123b9c9cb6f75badea3e4	Open original
Janady13/missionmatch / internal/modules/staffing/gap.go	ws8-teaching-loop	c823f0fb6bb2aba0f39001eb6de96f4000d9321f	Open original
Janady13/missionmatch / internal/modules/staffing/gap.go	w3-ai-staffing-recommendations	43d56387270ef4da4cabd794d97ca6a49909bc7d	Open original
Janady13/missionmatch / internal/modules/staffing/gap.go	mag-substrate	b82c7100a492dec67dfd1eda6b3f53def859be35	Open original
Janady13/missionmatch / internal/modules/staffing/gap.go	ws3-clearance	4b8e7ce594c068621867f9c9deed0ec64ae6c553	Open original
Janady13/missionmatch / internal/modules/staffing/gap.go	phase2-eval-fairness	d361af254701975fe239927656ababb56374655e	Open original
Janady13/missionmatch / internal/modules/staffing/gap.go	time-to-fill-survival	b66e1e505863d4f17741a4b9ede73509e45bd6c6	Open original
Janady13/missionmatch / internal/modules/staffing/gap.go	graphrag-foundation	b0ddeb9f633fd138d09309d1a17b7d13bc3a67f7	Open original
Janady13/missionmatch / internal/modules/staffing/gap.go	deploy-and-ops	bdacd9d0b4d5998d25fc74bf4007f4c3ec538c7a	Open original
Janady13/missionmatch / internal/modules/staffing/gap.go	ws9-bench-ingestion	f585a9ef32fa554663ce1fba9a414a54b6e49cf0	Open original
Janady13/missionmatch / internal/modules/staffing/gap.go	ws2-alias-relationship	e4dada4601c6eb101830f9d223a9655dfa120616	Open original
Janady13/missionmatch / internal/modules/staffing/gap.go	presentation-readiness	eb574acaa29d71ce4d0f852572e87c275c79fdb7	Open original
Janady13/missionmatch / internal/modules/staffing/gap.go	vendor-intelligence	fe9796a19c261951d3f2565206c0c1b5ac294465	Open original
Janady13/missionmatch / internal/modules/staffing/gap.go	ws7-federal-signal	6a9f6ce9cfb13345ffb47770d4960e7c2d9c17c2	Open original
Janady13/missionmatch / internal/modules/staffing/gap.go	ai-brain-live	aac32fc49c878cc5bca099459307611562d0bac1	Open original
Janady13/missionmatch / internal/modules/staffing/gap.go	phase2-connectors	e038d4c687aec16f8bd9bc4d907eea14d91f8704	Open original
Janady13/missionmatch / internal/modules/staffing/gap.go	feature/aioe-upgrade	2178e7298d0e5d9af83afa12402fd587f0ba6ed8	Open original
Janady13/missionmatch / internal/modules/staffing/gap.go	capture-readiness	bae6af7cb2997e819174a9e9cfff5e16067a1975	Open original

Recovered source transcript

Download complete source text ↓130 lines · 4.7 KB

package staffing

import (
	"context"

	"github.com/google/uuid"
	"github.com/jackc/pgx/v5"
	"github.com/shopspring/decimal"

	"github.com/missionworkforce/missionmatch/internal/modules/matching"
	"github.com/missionworkforce/missionmatch/internal/modules/matching/engine"
	"github.com/missionworkforce/missionmatch/internal/platform/database/dbgen"
)

// GenerateGap produces the ranked recommendations to close one named gap (POST
// /recommendations/gap/{requirementID}). It scores the eligible bench against the requirement, reads
// current commitment so a committed candidate is a reassign rather than a duplicate assign, classifies
// deterministically, narrates behind the faithfulness gate, and persists a fresh run that supersedes the
// prior pending gap rows for this requirement. A requirement that is missing, deleted, or backed by a non
// open opportunity returns ErrNotFound (404).
func (s *Service) GenerateGap(ctx context.Context, requirementID uuid.UUID, req GapRequest) (RunResponse, error) {
	if s.db == nil {
		return RunResponse{}, ErrNoDatabase
	}
	orgID, err := s.orgID(ctx)
	if err != nil {
		return RunResponse{}, err
	}
	floor, adj, verr := parseOverrides(req.StaffingFloor, req.AdjacencyThreshold)
	if verr != nil {
		return RunResponse{}, verr
	}
	cfg := s.cfg.WithOverrides(floor, adj)
	asOf := s.clock()

	var (
		recs        []Recommendation
		resByCand   map[string]engine.MatchResult
		valueSource string
	)
	// Phase A (read): load, score, classify. No writes, so a long read never blocks a writer.
	err = s.db.RunInTenantTx(ctx, func(ctx context.Context, tx pgx.Tx) error {
		q := dbgen.New(tx)
		rv, e := q.GetRequirementWithValue(ctx, requirementID)
		if e != nil {
			if e == pgx.ErrNoRows {
				return ErrNotFound
			}
			return e
		}
		if rv.DeletedAt != nil {
			return ErrNotFound
		}
		if rv.OpportunityID != nil && rv.OpportunityStatus != nil && *rv.OpportunityStatus != "open" {
			return ErrNotFound // a closed opportunity is not a real open gap
		}
		er, e := matching.LoadEngineRequirement(ctx, q, requirementID)
		if e != nil {
			return e
		}
		openRows, e := q.ListOpenRequirementsWithValue(ctx, dbgen.ListOpenRequirementsWithValueParams{Limit: openRequirementCap, Offset: 0})
		if e != nil {
			return e
		}
		priorities, vs := buildPriorities(cfg, openRows)
		valueSource = vs
		gapPriority, ok := priorities[requirementID.String()]
		if !ok { // a standalone requirement may not be in the open list; price it directly
			v := decimal.Zero
			if rv.OpportunityValue != nil {
				v = *rv.OpportunityValue
			}
			gapPriority = PriorityMultiplier(v, cfg.ValueReference, cfg.PriorityMin, cfg.PriorityMax)
			priorities[requirementID.String()] = gapPriority
		}
		commitRows, e := q.ListCommitments(ctx)
		if e != nil {
			return e
		}
		commit := buildCommitments(commitRows)
		cands, e := q.ListCandidates(ctx, dbgen.ListCandidatesParams{Limit: benchScanLimit, Offset: 0})
		if e != nil {
			return e
		}
		bench, rbc, e := s.scoreBench(ctx, tx, er, gapPriority, cands, commit, priorities, true, cfg, asOf)
		if e != nil {
			return e
		}
		resByCand = rbc
		openSlots := int(rv.Quantity) - commit.countByReq[requirementID.String()]
		if openSlots < 0 {
			openSlots = 0
		}
		recs = ClassifyForGap(cfg, GapContext{RequirementID: requirementID.String(), OpenSlots: openSlots, Priority: gapPriority}, bench)
		return nil
	})
	if err != nil {
		return RunResponse{}, err
	}

	// Phase B (no tx): narrate each recommendation behind the faithfulness gate.
	enriched := s.enrich(ctx, recs)

	// Every gap recommendation is against this one requirement, so key the frozen results by that pair.
	resByPair := make(map[string]engine.MatchResult, len(resByCand))
	for cid, res := range resByCand {
		resByPair[pairKey(cid, requirementID.String())] = res
	}

	// Phase C (write): persist the run, the frozen evaluations, and the recommendations atomically.
	scope := requirementID
	var run dbgen.RecommendationRun
	var rows []dbgen.StaffingRecommendation
	err = s.db.RunInTenantTx(ctx, func(ctx context.Context, tx pgx.Tx) error {
		// Serialize gap runs for THIS requirement so a concurrent run (a double click or a retry) cannot
		// leave two live pending sets; runs for different requirements still proceed in parallel.
		if e := acquireAdvisoryLock(ctx, tx, advisoryKey(ViewGap, orgID, requirementID.String())); e != nil {
			return e
		}
		var e error
		run, rows, e = s.persistRun(ctx, tx, orgID, ViewGap, &scope, runParams(cfg, valueSource), "staffing.gap", enriched, resByPair,
			func(ctx context.Context, q *dbgen.Queries) error { return q.SupersedePendingGap(ctx, requirementID) })
		return e
	})
	if err != nil {
		return RunResponse{}, err
	}
	return RunResponse{Run: runView(run), Recommendations: recommendationViews(rows)}, nil
}