Janady13/missionmatch / internal/modules/matching/slate_service.go

1package matching 2 3import ( 4 "context" 5 "encoding/csv" 6 "encoding/json" 7 "errors" 8 "strconv" 9 "strings" 10 11 "github.com/google/uuid" 12 "github.com/jackc/pgx/v5" 13 "github.com/shopspring/decimal" 14 15 "github.com/missionworkforce/missionmatch/internal/modules/matching/engine" 16 "github.com/missionworkforce/missionmatch/internal/platform/audit" 17 "github.com/missionworkforce/missionmatch/internal/platform/database/dbgen" 18) 19 20// ListSlates returns the slates generated for one requirement, newest first, with a member count 21// (slateMATCH slate list). It reads the stored slates, it does not rescore. 22func (s *Service) ListSlates(ctx context.Context, requirementID uuid.UUID) ([]SlateSummaryView, error) { 23 if s.db == nil { 24 return nil, ErrNoDatabase 25 } 26 var out []SlateSummaryView 27 err := s.db.RunInTenantTx(ctx, func(ctx context.Context, tx pgx.Tx) error { 28 q := dbgen.New(tx) 29 slates, e := q.ListSlatesForRequirement(ctx, requirementID) 30 if e != nil { 31 return e 32 } 33 out = make([]SlateSummaryView, 0, len(slates)) 34 for _, sl := range slates { 35 members, e := q.ListSlateMembers(ctx, sl.ID) 36 if e != nil { 37 return e 38 } 39 out = append(out, SlateSummaryView{ 40 SlateID: sl.ID.String(), 41 Name: sl.Name, 42 Status: sl.Status, 43 MemberCount: len(members), 44 CreatedAt: sl.CreatedAt.Format("2006-01-02"), 45 }) 46 } 47 return nil 48 }) 49 return out, err 50} 51 52// SlateDetail returns one slate with its ranked members (read from the persisted slate_members, never 53// rescored) and the proposal readiness rollup. ErrNotFound when the slate is not in the caller's org. 54func (s *Service) SlateDetail(ctx context.Context, slateID uuid.UUID) (SlateDetailView, error) { 55 if s.db == nil { 56 return SlateDetailView{}, ErrNoDatabase 57 } 58 var view SlateDetailView 59 err := s.db.RunInTenantTx(ctx, func(ctx context.Context, tx pgx.Tx) error { 60 q := dbgen.New(tx) 61 sl, e := q.GetSlate(ctx, slateID) 62 if errors.Is(e, pgx.ErrNoRows) { 63 return ErrNotFound 64 } 65 if e != nil { 66 return e 67 } 68 members, e := q.ListSlateMembersWithNames(ctx, slateID) 69 if e != nil { 70 return e 71 } 72 title := "" 73 if rq, e := q.GetRequirement(ctx, sl.RequirementID); e == nil { 74 title = rq.Title 75 } else if !errors.Is(e, pgx.ErrNoRows) { 76 // A missing requirement leaves the title blank; a real error must not be swallowed into a 77 // silently blank Requirement line on a branded export. 78 return e 79 } 80 view = SlateDetailView{ 81 SlateID: sl.ID.String(), 82 RequirementID: sl.RequirementID.String(), 83 RequirementTitle: title, 84 Name: sl.Name, 85 Status: sl.Status, 86 Members: make([]SlateMemberDetailView, len(members)), 87 Readiness: computeReadiness(sl.ID.String(), sl.RequirementID.String(), members), 88 } 89 for i, m := range members { 90 view.Members[i] = slateMemberDetailView(m) 91 } 92 return nil 93 }) 94 return view, err 95} 96 97// ProposalReadiness returns the readiness rollup for one slate (GET /proposal-readiness): the band and 98// human decision mix across its members, computed from the stored slate and never by rescoring. 99func (s *Service) ProposalReadiness(ctx context.Context, slateID uuid.UUID) (ProposalReadinessView, error) { 100 if s.db == nil { 101 return ProposalReadinessView{}, ErrNoDatabase 102 } 103 var out ProposalReadinessView 104 err := s.db.RunInTenantTx(ctx, func(ctx context.Context, tx pgx.Tx) error { 105 q := dbgen.New(tx) 106 sl, e := q.GetSlate(ctx, slateID) 107 if errors.Is(e, pgx.ErrNoRows) { 108 return ErrNotFound 109 } 110 if e != nil { 111 return e 112 } 113 members, e := q.ListSlateMembersWithNames(ctx, slateID) 114 if e != nil { 115 return e 116 } 117 out = computeReadiness(sl.ID.String(), sl.RequirementID.String(), members) 118 return nil 119 }) 120 return out, err 121} 122 123// ExportSlate renders a slate as a branded CSV (the proposal candidate slate a capture team submits). 124// It reads the persisted member scores and decisions, so the export always matches the frozen slate. 125func (s *Service) ExportSlate(ctx context.Context, slateID uuid.UUID) (string, error) { 126 if s.db == nil { 127 return "", ErrNoDatabase 128 } 129 var out string 130 err := s.db.RunInTenantTx(ctx, func(ctx context.Context, tx pgx.Tx) error { 131 q := dbgen.New(tx) 132 sl, e := q.GetSlate(ctx, slateID) 133 if errors.Is(e, pgx.ErrNoRows) { 134 return ErrNotFound 135 } 136 if e != nil { 137 return e 138 } 139 members, e := q.ListSlateMembersWithNames(ctx, slateID) 140 if e != nil { 141 return e 142 } 143 title := "" 144 if rq, e := q.GetRequirement(ctx, sl.RequirementID); e == nil { 145 title = rq.Title 146 } else if !errors.Is(e, pgx.ErrNoRows) { 147 // A missing requirement leaves the title blank; a real error must not be swallowed into a 148 // silently blank Requirement line on a branded export. 149 return e 150 } 151 out = renderSlateCSV(sl, title, members) 152 // The export is a bulk egress of candidate PII (names, scores, decisions). Record it in the 153 // append-only audit with the slate and the actor only, NEVER the reviewer note text or scores. 154 payload, _ := json.Marshal(map[string]any{"members": len(members)}) 155 return s.auditOnTx(ctx, tx, audit.Event{Action: "aedt.slate.exported", EntityType: "slate", EntityID: sl.ID.String(), NewValues: payload}) 156 }) 157 return out, err 158} 159 160// computeReadiness rolls a slate's persisted members into the proposal readiness view: the band mix, 161// the human decision mix, the approved and proposal ready count, and an overall label. Pure. 162func computeReadiness(slateID, requirementID string, members []dbgen.ListSlateMembersWithNamesRow) ProposalReadinessView { 163 r := ProposalReadinessView{SlateID: slateID, RequirementID: requirementID, TotalMembers: len(members)} 164 for _, m := range members { 165 switch m.Decision { 166 case "approved": 167 r.Approved++ 168 case "rejected": 169 r.Rejected++ 170 default: 171 r.Pending++ 172 } 173 switch m.Band { 174 case "green": 175 r.ProposalReady++ 176 case "yellow": 177 r.Potential++ 178 default: 179 r.Recruiting++ 180 } 181 if m.Decision == "approved" && m.Band == "green" { 182 r.ApprovedReady++ 183 } 184 } 185 r.ReadinessPct = "0" 186 if r.TotalMembers > 0 { 187 // Approved share as a percent, decimal so the rollup carries no float64. 188 pct := decimal.NewFromInt(int64(r.Approved)). 189 Div(decimal.NewFromInt(int64(r.TotalMembers))). 190 Mul(decimal.NewFromInt(100)) 191 r.ReadinessPct = pct.StringFixed(0) 192 } 193 r.Status = readinessStatus(r) 194 return r 195} 196 197func readinessStatus(r ProposalReadinessView) string { 198 switch { 199 case r.TotalMembers == 0: 200 return "Empty" 201 case r.Pending > 0: 202 return "In Review" 203 case r.Approved == 0: 204 return "Needs Recruiting" 205 default: 206 return "Proposal Ready" 207 } 208} 209 210func slateMemberDetailView(m dbgen.ListSlateMembersWithNamesRow) SlateMemberDetailView { 211 rank := 0 212 if m.Rank != nil { 213 rank = int(*m.Rank) 214 } 215 note := "" 216 if m.DecisionNote != nil { 217 note = *m.DecisionNote 218 } 219 var gaps []string 220 if len(m.GapSummary) > 0 { 221 _ = json.Unmarshal(m.GapSummary, &gaps) 222 } 223 return SlateMemberDetailView{ 224 CandidateID: m.CandidateID.String(), 225 FullName: m.FullName, 226 Rank: rank, 227 Total: m.TotalScore.StringFixed(2), 228 Band: m.Band, 229 BandLabel: bandLabel(m.Band), 230 Components: map[string]string{ 231 "Clearance": m.ClearanceScore.StringFixed(2), 232 "Skills": m.SkillsScore.StringFixed(2), 233 "Certifications": m.CertsScore.StringFixed(2), 234 "CustomerExperience": m.CustomerScore.StringFixed(2), 235 "Experience": m.ExperienceScore.StringFixed(2), 236 "LocationAvailability": m.LocationScore.StringFixed(2), 237 }, 238 Explanation: m.Explanation, 239 GapSummary: gaps, 240 Decision: m.Decision, 241 DecisionNote: note, 242 } 243} 244 245// bandLabel maps a stored band code to its human label, defaulting safely on an unknown code. 246func bandLabel(code string) string { 247 if b, err := engine.ParseBand(code); err == nil { 248 return b.Label() 249 } 250 return code 251} 252 253// renderSlateCSV writes a branded proposal candidate slate. The header carries the product and slate 254// identity and the standing clearance disclaimer; the rows are the ranked, frozen members with their 255// human decisions. encoding/csv quotes any name or note that contains a comma. 256func renderSlateCSV(sl dbgen.Slate, requirementTitle string, members []dbgen.ListSlateMembersWithNamesRow) string { 257 var b strings.Builder 258 b.WriteString("missionMATCH slateMATCH Proposal Candidate Slate\n") 259 b.WriteString("Slate," + csvField(sl.Name) + "\n") 260 b.WriteString("Requirement," + csvField(requirementTitle) + "\n") 261 b.WriteString("Clearance shown is a self reported indicator, never verified.\n") 262 b.WriteString("\n") 263 264 w := csv.NewWriter(&b) 265 _ = w.Write([]string{"Rank", "Candidate", "Total Score", "Band", "Decision", "Reviewer Note", "Explanation"}) 266 for _, m := range members { 267 rank := "" 268 if m.Rank != nil { 269 rank = strconv.Itoa(int(*m.Rank)) 270 } 271 note := "" 272 if m.DecisionNote != nil { 273 note = *m.DecisionNote 274 } 275 _ = w.Write([]string{ 276 rank, m.FullName, m.TotalScore.StringFixed(2), bandLabel(m.Band), m.Decision, note, m.Explanation, 277 }) 278 } 279 w.Flush() 280 return b.String() 281} 282 283// csvField quotes a single header value that may contain a comma (the csv writer handles the rows). 284func csvField(s string) string { 285 if strings.ContainsAny(s, ",\"\n") { 286 return "\"" + strings.ReplaceAll(s, "\"", "\"\"") + "\"" 287 } 288 return s 289} 290