Janady13/missionmatch / internal/modules/commandcenter/service_federal_signal.go

1package commandcenter 2 3import ( 4 "context" 5 "fmt" 6 "strings" 7 8 "github.com/jackc/pgx/v5" 9 10 "github.com/missionworkforce/missionmatch/internal/platform/database/dbgen" 11 "github.com/missionworkforce/missionmatch/internal/platform/missionclass" 12) 13 14// openByMissionLimit caps the open requirements by mission panel. 15const openByMissionLimit = 25 16 17// incumbentMixLimit caps the incumbent staffing mix panel. It bounds the number of joined role rows the 18// recompete query returns before grouping, so a heavily tagged award catalog cannot flood the panel. 19const incumbentMixLimit = 200 20 21// federalSignalProvenanceNote is the standing label on every federal signal panel, so the surface always 22// reads as public federal data carrying its own provenance, never a verified or fabricated figure. It 23// mirrors the clearance and demo data disclaimers on the rest of the Command Center. 24const federalSignalProvenanceNote = "Public federal data. Mission tags and incumbent roles are deterministic inferences carrying their source evidence, never a scoring input and never a verified figure. Clearance is a self reported indicator confirmed by the hiring client FSO through DISS at onboarding." 25 26// errUnknownMission is returned when a caller asks for a mission code that is not in the controlled 27// vocabulary. The handler maps it to a bad request so the panel never silently runs an empty filter. 28var errUnknownMission = fmt.Errorf("commandcenter: unknown mission code") 29 30// validMissionCode reports whether code is one of the controlled mission_areas codes. The vocabulary is 31// the single source of truth shared with the classifier, so the panel cannot drift from the tag tables. 32func validMissionCode(code string) bool { 33 for _, c := range missionclass.Codes { 34 if c == code { 35 return true 36 } 37 } 38 return false 39} 40 41// FederalSignal builds the additive WS7 panel for the caller's org: the open solicitations tagged to the 42// requested mission code, and the incumbent staffing mix on recompete relevant awards. It is read only and 43// RLS scoped (both reads run inside one tenant transaction), never alters the readiness math, and never 44// reaches the eeo schema. The mission code is validated against the controlled vocabulary first so an 45// unknown code is rejected rather than silently returning everything. 46// 47// The opportunity_records and usaspending_awards catalogs are global public reference data; federal_mission_tags 48// and award_incumbent_roles are global app SELECT tables. They are read inside RunInTenantTx only so the 49// transaction is the same correctness boundary the rest of the dashboard uses, not because the rows are 50// tenant scoped. 51func (s *Service) FederalSignal(ctx context.Context, mission string) (FederalSignal, error) { 52 if s.db == nil { 53 return FederalSignal{}, ErrNoDatabase 54 } 55 mission = strings.ToUpper(strings.TrimSpace(mission)) 56 if mission != "" && !validMissionCode(mission) { 57 return FederalSignal{}, errUnknownMission 58 } 59 60 out := FederalSignal{Mission: mission, Notes: []string{federalSignalProvenanceNote}} 61 err := s.db.RunInTenantTx(ctx, func(ctx context.Context, tx pgx.Tx) error { 62 var err error 63 if mission != "" { 64 if out.OpenByMission, err = openByMission(ctx, tx, mission); err != nil { 65 return err 66 } 67 } else { 68 out.OpenByMission = []OpenMissionOpp{} 69 } 70 if out.IncumbentMix, err = incumbentMix(ctx, tx); err != nil { 71 return err 72 } 73 return nil 74 }) 75 if err != nil { 76 return FederalSignal{}, err 77 } 78 return out, nil 79} 80 81// openByMission lists active solicitations tagged to one mission code via the WS7 ListOpportunityRecords 82// missions narg, then enriches each row with the mission tag mechanism and evidence so the founder facing 83// question open SIGINT requirements is traceable to the tag that matched. Soonest closing first, then id 84// as the unique tiebreaker the query already carries, so output is byte stable. 85func openByMission(ctx context.Context, tx pgx.Tx, mission string) ([]OpenMissionOpp, error) { 86 q := dbgen.New(tx) 87 recs, err := q.ListOpportunityRecords(ctx, dbgen.ListOpportunityRecordsParams{ 88 Kinds: []string{"active_solicitation"}, 89 Missions: []string{mission}, 90 Lim: openByMissionLimit, 91 }) 92 if err != nil { 93 return nil, fmt.Errorf("open by mission: %w", err) 94 } 95 out := make([]OpenMissionOpp, 0, len(recs)) 96 for _, r := range recs { 97 o := OpenMissionOpp{ 98 RecordID: r.ID.String(), 99 Title: r.Title, 100 Agency: r.Agency, 101 NAICS: r.Naics, 102 PSC: r.Psc, 103 PlaceOfPerformance: r.PopState, 104 SetAside: r.SetAside, 105 ValueSource: r.ValueSource, 106 UILink: r.UiLink, 107 MissionCode: mission, 108 Source: r.SourceName, 109 } 110 if r.EstimatedValue != nil { 111 vs := r.EstimatedValue.StringFixed(2) 112 o.Value = &vs 113 } 114 if r.ResponseDeadline != nil { 115 o.ResponseDeadline = r.ResponseDeadline.Format("2006-01-02") 116 } 117 // Read the mission tag provenance for this record and code so the row is traceable to the 118 // mechanism and evidence the classifier recorded, the WS7 acceptance criterion. 119 if err := tx.QueryRow(ctx, 120 `SELECT mechanism, evidence FROM federal_mission_tags 121 WHERE record_table='opportunity_records' AND record_id=$1 AND mission_code=$2`, 122 r.ID.String(), mission).Scan(&o.MissionMechanism, &o.MissionEvidence); err != nil { 123 if err != pgx.ErrNoRows { 124 return nil, fmt.Errorf("open by mission tag provenance: %w", err) 125 } 126 } 127 out = append(out, o) 128 } 129 return out, nil 130} 131 132// incumbentMix reads the incumbent labor roles on recompete relevant USASpending awards (the recompete 133// signal is the period of performance end date) and groups the flat role rows into one entry per award. 134// The query returns rows ordered by pop_end_date then award id then labor category, so the grouping 135// preserves that byte stable order. Each role carries its evidence phrase, the WS7 traceability criterion. 136func incumbentMix(ctx context.Context, tx pgx.Tx) ([]IncumbentMixAward, error) { 137 rows, err := dbgen.New(tx).ListIncumbentRolesByRecompete(ctx, dbgen.ListIncumbentRolesByRecompeteParams{ 138 RowLimit: incumbentMixLimit, 139 }) 140 if err != nil { 141 return nil, fmt.Errorf("incumbent mix: %w", err) 142 } 143 return groupIncumbentMix(rows), nil 144} 145 146// groupIncumbentMix folds the flat (award, role) rows into one IncumbentMixAward per award, preserving the 147// query's pop_end_date ordering. It is a pure function so the grouping is unit tested without a DB. The 148// rows arrive grouped by award id (the query orders by pop_end_date, then award id, then labor category), 149// so a single pass keyed on the award id is sufficient and stable. 150func groupIncumbentMix(rows []dbgen.ListIncumbentRolesByRecompeteRow) []IncumbentMixAward { 151 out := make([]IncumbentMixAward, 0) 152 idx := map[string]int{} 153 for _, r := range rows { 154 i, seen := idx[r.RecordID] 155 if !seen { 156 a := IncumbentMixAward{ 157 RecordID: r.RecordID, 158 RecipientName: r.RecipientName, 159 Agency: r.AwardingAgency, 160 NAICS: r.NaicsCode, 161 Source: "USASpending", 162 Roles: []IncumbentRole{}, 163 } 164 if r.AwardAmount != nil { 165 vs := r.AwardAmount.StringFixed(2) 166 a.AwardValue = &vs 167 } 168 if r.PopEndDate.Valid { 169 a.PopEndDate = r.PopEndDate.Time.Format("2006-01-02") 170 } 171 out = append(out, a) 172 i = len(out) - 1 173 idx[r.RecordID] = i 174 } 175 out[i].Roles = append(out[i].Roles, IncumbentRole{ 176 LaborCategory: r.LaborCategory, 177 RoleCount: int(r.RoleCount), 178 Evidence: r.Evidence, 179 }) 180 } 181 return out 182} 183