Feat: Learning Record For Residents

backend/migrations/00072_create_learning_record_tables.sql

@@ -0,0 +1,39 @@
+-- +goose Up
+CREATE TABLE learning_record_entries (
+    id                    SERIAL PRIMARY KEY,
+    user_id               INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+    client_id             TEXT NOT NULL,
+    is_draft              BOOLEAN NOT NULL DEFAULT FALSE,
+    step_index            INTEGER NOT NULL DEFAULT 0,
+    ui_phase              TEXT NOT NULL DEFAULT 'survey',
+    editing_entry_id      INTEGER REFERENCES learning_record_entries(id) ON DELETE SET NULL,
+    program_name          TEXT NOT NULL DEFAULT '',
+    completion_date       TEXT NOT NULL DEFAULT '',
+    confidence            TEXT NOT NULL DEFAULT '',
+    summary               TEXT NOT NULL DEFAULT '',
+    top_skills            TEXT NOT NULL DEFAULT '[]',
+    barrier_to_completion TEXT NOT NULL DEFAULT '',
+    goal_connection       TEXT NOT NULL DEFAULT '',
+    pride                 TEXT NOT NULL DEFAULT '',
+    standout_moment       TEXT NOT NULL DEFAULT '',
+    advice_to_peer        TEXT NOT NULL DEFAULT '',
+    challenge_toggle      TEXT,
+    challenge_text        TEXT NOT NULL DEFAULT '',
+    skill_tags_before     TEXT NOT NULL DEFAULT '[]',
+    skill_tags_after      TEXT NOT NULL DEFAULT '[]',
+    skill_reflection      TEXT NOT NULL DEFAULT '',
+    growth_reflection     TEXT NOT NULL DEFAULT '',
+    support_selections    TEXT NOT NULL DEFAULT '[]',
+    next_step_selections  TEXT NOT NULL DEFAULT '[]',
+    created_at            TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    updated_at            TIMESTAMPTZ NOT NULL DEFAULT NOW()
+);
+
+CREATE INDEX IF NOT EXISTS idx_learning_record_entries_user_id
+    ON learning_record_entries(user_id);
+
+CREATE UNIQUE INDEX IF NOT EXISTS idx_learning_record_entries_client_id
+    ON learning_record_entries(user_id, client_id);
+
+-- +goose Down
+DROP TABLE IF EXISTS learning_record_entries;

backend/migrations/00073_add_learning_record_feature_flag.sql

@@ -0,0 +1,10 @@
+-- +goose Up
+-- +goose NO TRANSACTION
+ALTER TYPE feature ADD VALUE IF NOT EXISTS 'learning_record';
+
+INSERT INTO public.feature_flags (name, enabled)
+VALUES ('learning_record', FALSE)
+ON CONFLICT (name) DO NOTHING;
+
+-- +goose Down
+DELETE FROM public.feature_flags WHERE name = 'learning_record';

backend/src/database/learning_record.go

@@ -0,0 +1,88 @@
+package database
+
+import (
+	"UnlockEdv2/src/models"
+	"errors"
+
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+)
+
+func (db *DB) GetLearningRecordEntries(userID uint) ([]models.LearningRecordEntry, error) {
+	entries := make([]models.LearningRecordEntry, 0)
+	if err := db.Where("user_id = ? AND is_draft = false", userID).
+		Order("created_at DESC").
+		Find(&entries).Error; err != nil {
+		return nil, newGetRecordsDBError(err, "learning_record_entries")
+	}
+	return entries, nil
+}
+
+func (db *DB) CreateLearningRecordEntry(entry *models.LearningRecordEntry) error {
+	if err := db.Create(entry).Error; err != nil {
+		return newCreateDBError(err, "learning_record_entries")
+	}
+	return nil
+}
+
+func (db *DB) UpdateLearningRecordEntry(entry *models.LearningRecordEntry) error {
+	result := db.Model(entry).
+		Where("id = ? AND user_id = ?", entry.ID, entry.UserID).
+		Updates(entry)
+	if result.Error != nil {
+		return newUpdateDBError(result.Error, "learning_record_entries")
+	}
+	return nil
+}
+
+func (db *DB) DeleteLearningRecordEntry(id, userID uint) error {
+	if err := db.Where("id = ? AND user_id = ?", id, userID).
+		Delete(&models.LearningRecordEntry{}).Error; err != nil {
+		return newDeleteDBError(err, "learning_record_entries")
+	}
+	return nil
+}
+
+// GetLearningRecordDraft returns the most recently updated draft for the user, or nil.
+func (db *DB) GetLearningRecordDraft(userID uint) (*models.LearningRecordEntry, error) {
+	var draft models.LearningRecordEntry
+	err := db.Where("user_id = ? AND is_draft = true", userID).
+		Order("updated_at DESC").
+		First(&draft).Error
+	if err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return nil, nil
+		}
+		return nil, newGetRecordsDBError(err, "learning_record_entries")
+	}
+	return &draft, nil
+}
+
+// UpsertLearningRecordDraft inserts or updates a draft row keyed on (user_id, client_id).
+func (db *DB) UpsertLearningRecordDraft(draft *models.LearningRecordEntry) error {
+	draft.IsDraft = true
+	if err := db.Clauses(clause.OnConflict{
+		Columns: []clause.Column{{Name: "user_id"}, {Name: "client_id"}},
+		DoUpdates: clause.AssignmentColumns([]string{
+			"is_draft", "step_index", "ui_phase", "editing_entry_id",
+			"program_name", "completion_date", "confidence", "summary",
+			"top_skills", "barrier_to_completion", "goal_connection",
+			"pride", "standout_moment", "advice_to_peer",
+			"challenge_toggle", "challenge_text",
+			"skill_tags_before", "skill_tags_after", "skill_reflection",
+			"growth_reflection", "support_selections", "next_step_selections",
+			"updated_at",
+		}),
+	}).Create(draft).Error; err != nil {
+		return newCreateDBError(err, "learning_record_entries")
+	}
+	return nil
+}
+
+func (db *DB) DeleteLearningRecordDraft(userID uint, clientID string) error {
+	if err := db.Where("user_id = ? AND client_id = ? AND is_draft = true", userID, clientID).
+		Delete(&models.LearningRecordEntry{}).Error; err != nil {
+		return newDeleteDBError(err, "learning_record_entries")
+	}
+	return nil
+}

backend/src/handlers/learning_record_handler.go

@@ -0,0 +1,115 @@
+package handlers
+
+import (
+	"UnlockEdv2/src/models"
+	"encoding/json"
+	"net/http"
+	"strconv"
+)
+
+func (srv *Server) registerLearningRecordRoutes() []routeDef {
+	axx := models.LearningRecordAccess
+	return []routeDef{
+		featureRoute("GET /api/learning-record/entries", srv.handleIndexLearningRecordEntries, axx),
+		featureRoute("POST /api/learning-record/entries", srv.handleCreateLearningRecordEntry, axx),
+		featureRoute("PUT /api/learning-record/entries/{id}", srv.handleUpdateLearningRecordEntry, axx),
+		featureRoute("DELETE /api/learning-record/entries/{id}", srv.handleDeleteLearningRecordEntry, axx),
+		featureRoute("GET /api/learning-record/draft", srv.handleGetLearningRecordDraft, axx),
+		featureRoute("PUT /api/learning-record/draft", srv.handleUpsertLearningRecordDraft, axx),
+		featureRoute("DELETE /api/learning-record/draft", srv.handleDeleteLearningRecordDraft, axx),
+	}
+}
+
+func (srv *Server) handleIndexLearningRecordEntries(w http.ResponseWriter, r *http.Request, log sLog) error {
+	userID := r.Context().Value(ClaimsKey).(*Claims).UserID
+	entries, err := srv.Db.GetLearningRecordEntries(userID)
+	if err != nil {
+		log.add("user_id", userID)
+		return newDatabaseServiceError(err)
+	}
+	return writeJsonResponse(w, http.StatusOK, entries)
+}
+
+func (srv *Server) handleCreateLearningRecordEntry(w http.ResponseWriter, r *http.Request, log sLog) error {
+	var entry models.LearningRecordEntry
+	if err := json.NewDecoder(r.Body).Decode(&entry); err != nil {
+		return newJSONReqBodyServiceError(err)
+	}
+	entry.UserID = r.Context().Value(ClaimsKey).(*Claims).UserID
+	if err := srv.Db.CreateLearningRecordEntry(&entry); err != nil {
+		log.add("user_id", entry.UserID)
+		return newDatabaseServiceError(err)
+	}
+	return writeJsonResponse(w, http.StatusCreated, entry)
+}
+
+func (srv *Server) handleUpdateLearningRecordEntry(w http.ResponseWriter, r *http.Request, log sLog) error {
+	id, err := strconv.Atoi(r.PathValue("id"))
+	if err != nil {
+		return newInvalidIdServiceError(err, "entry ID")
+	}
+	var entry models.LearningRecordEntry
+	if err := json.NewDecoder(r.Body).Decode(&entry); err != nil {
+		return newJSONReqBodyServiceError(err)
+	}
+	entry.ID = uint(id)
+	entry.UserID = r.Context().Value(ClaimsKey).(*Claims).UserID
+	if err := srv.Db.UpdateLearningRecordEntry(&entry); err != nil {
+		log.add("entry_id", id)
+		log.add("user_id", entry.UserID)
+		return newDatabaseServiceError(err)
+	}
+	return writeJsonResponse(w, http.StatusOK, entry)
+}
+
+func (srv *Server) handleDeleteLearningRecordEntry(w http.ResponseWriter, r *http.Request, log sLog) error {
+	id, err := strconv.Atoi(r.PathValue("id"))
+	if err != nil {
+		return newInvalidIdServiceError(err, "entry ID")
+	}
+	userID := r.Context().Value(ClaimsKey).(*Claims).UserID
+	if err := srv.Db.DeleteLearningRecordEntry(uint(id), userID); err != nil {
+		log.add("entry_id", id)
+		log.add("user_id", userID)
+		return newDatabaseServiceError(err)
+	}
+	return writeJsonResponse(w, http.StatusOK, "Entry deleted successfully")
+}
+
+func (srv *Server) handleGetLearningRecordDraft(w http.ResponseWriter, r *http.Request, log sLog) error {
+	userID := r.Context().Value(ClaimsKey).(*Claims).UserID
+	draft, err := srv.Db.GetLearningRecordDraft(userID)
+	if err != nil {
+		log.add("user_id", userID)
+		return newDatabaseServiceError(err)
+	}
+	return writeJsonResponse(w, http.StatusOK, draft)
+}
+
+func (srv *Server) handleUpsertLearningRecordDraft(w http.ResponseWriter, r *http.Request, log sLog) error {
+	var draft models.LearningRecordEntry
+	if err := json.NewDecoder(r.Body).Decode(&draft); err != nil {
+		return newJSONReqBodyServiceError(err)
+	}
+	draft.UserID = r.Context().Value(ClaimsKey).(*Claims).UserID
+	if err := srv.Db.UpsertLearningRecordDraft(&draft); err != nil {
+		log.add("user_id", draft.UserID)
+		log.add("client_id", draft.ClientID)
+		return newDatabaseServiceError(err)
+	}
+	return writeJsonResponse(w, http.StatusOK, draft)
+}
+
+func (srv *Server) handleDeleteLearningRecordDraft(w http.ResponseWriter, r *http.Request, log sLog) error {
+	userID := r.Context().Value(ClaimsKey).(*Claims).UserID
+	clientID := r.URL.Query().Get("client_id")
+	if clientID == "" {
+		return newBadRequestServiceError(nil, "client_id query parameter is required")
+	}
+	if err := srv.Db.DeleteLearningRecordDraft(userID, clientID); err != nil {
+		log.add("user_id", userID)
+		log.add("client_id", clientID)
+		return newDatabaseServiceError(err)
+	}
+	return writeJsonResponse(w, http.StatusOK, "Draft deleted successfully")
+}

backend/src/handlers/server.go

@@ -110,6 +110,7 @@ func (srv *Server) RegisterRoutes() {
 		srv.registerOpenContentActivityRoutes,
 		srv.registerTagRoutes,
 		srv.registerReportsRoutes,
+		srv.registerLearningRecordRoutes,
 	} {
 		srv.register(route)
 	}

backend/src/models/feature_flags.go

@@ -21,17 +21,18 @@ type (
 )
 
 const (
-	OpenContentAccess FeatureAccess = "open_content"
-	ProviderAccess    FeatureAccess = "provider_platforms"
-	ProgramAccess     FeatureAccess = "program_management"
+	OpenContentAccess    FeatureAccess = "open_content"
+	ProviderAccess       FeatureAccess = "provider_platforms"
+	ProgramAccess        FeatureAccess = "program_management"
+	LearningRecordAccess FeatureAccess = "learning_record"
 
 	// these are the page level features
 	RequestContentAccess FeatureAccess = "request_content"
 	HelpfulLinksAccess   FeatureAccess = "helpful_links"
 	UploadVideoAccess    FeatureAccess = "upload_video"
 )
 
-var AllFeatures = []FeatureAccess{OpenContentAccess, ProviderAccess, ProgramAccess, RequestContentAccess, HelpfulLinksAccess, UploadVideoAccess}
+var AllFeatures = []FeatureAccess{OpenContentAccess, ProviderAccess, ProgramAccess, LearningRecordAccess, RequestContentAccess, HelpfulLinksAccess, UploadVideoAccess}
 
 func Feature(kinds ...FeatureAccess) []FeatureAccess {
 	return kinds

backend/src/models/learning_record.go

@@ -0,0 +1,63 @@
+package models
+
+import (
+	"database/sql/driver"
+	"encoding/json"
+	"time"
+)
+
+// StringSlice persists a Go string slice as a JSON text column.
+type StringSlice []string
+
+func (s StringSlice) Value() (driver.Value, error) {
+	if s == nil {
+		return "[]", nil
+	}
+	b, err := json.Marshal(s)
+	return string(b), err
+}
+
+func (s *StringSlice) Scan(value any) error {
+	var raw string
+	switch v := value.(type) {
+	case string:
+		raw = v
+	case []byte:
+		raw = string(v)
+	default:
+		raw = "[]"
+	}
+	return json.Unmarshal([]byte(raw), s)
+}
+
+type LearningRecordEntry struct {
+	ID                  uint        `gorm:"primaryKey"        json:"id"`
+	UserID              uint        `gorm:"not null"          json:"user_id"`
+	ClientID            string      `gorm:"not null"          json:"client_id"`
+	IsDraft             bool        `gorm:"not null;default:false" json:"is_draft"`
+	StepIndex           int         `                         json:"step_index"`
+	UiPhase             string      `                         json:"ui_phase"`
+	EditingEntryID      *uint       `                         json:"editing_entry_id"`
+	ProgramName         string      `                         json:"program_name"`
+	CompletionDate      string      `                         json:"completion_date"`
+	Confidence          string      `                         json:"confidence"`
+	Summary             string      `                         json:"summary"`
+	TopSkills           StringSlice `gorm:"type:text"         json:"top_skills"`
+	BarrierToCompletion string      `                         json:"barrier_to_completion"`
+	GoalConnection      string      `                         json:"goal_connection"`
+	Pride               string      `                         json:"pride"`
+	StandoutMoment      string      `                         json:"standout_moment"`
+	AdviceToPeer        string      `                         json:"advice_to_peer"`
+	ChallengeToggle     *string     `                         json:"challenge_toggle"`
+	ChallengeText       string      `                         json:"challenge_text"`
+	SkillTagsBefore     StringSlice `gorm:"type:text"         json:"skill_tags_before"`
+	SkillTagsAfter      StringSlice `gorm:"type:text"         json:"skill_tags_after"`
+	SkillReflection     string      `                         json:"skill_reflection"`
+	GrowthReflection    string      `                         json:"growth_reflection"`
+	SupportSelections   StringSlice `gorm:"type:text"         json:"support_selections"`
+	NextStepSelections  StringSlice `gorm:"type:text"         json:"next_step_selections"`
+	CreatedAt           time.Time   `                         json:"created_at"`
+	UpdatedAt           time.Time   `                         json:"updated_at"`
+}
+
+func (LearningRecordEntry) TableName() string { return "learning_record_entries" }

config/dev.nginx.conf

@@ -4,9 +4,10 @@ server {
   proxy_headers_hash_bucket_size 256;
   access_log /var/log/nginx/access.log;
   error_log /var/log/nginx/error.log;
+  resolver 127.0.0.11 ipv6=off valid=10s;
 
    location /api/ {
-        proxy_pass http://server:8080;
+        proxy_pass http://host.docker.internal:8080;
         proxy_buffering on;
         proxy_cache_methods GET HEAD;
         proxy_http_version 1.1;
@@ -62,7 +63,7 @@ server {
     }
 
     location / {
-        proxy_pass http://frontend:5173;
+        proxy_pass http://host.docker.internal:5173;
         proxy_http_version 1.1;
         proxy_set_header Upgrade $http_upgrade;
         proxy_set_header Connection 'upgrade';

docker-compose.yml

@@ -48,6 +48,8 @@ services:
     volumes:
       - ./config/dev.nginx.conf:/etc/nginx/conf.d/default.conf
       - logs:/var/log/nginx/
+    extra_hosts:
+      - "host.docker.internal:host-gateway"
     networks:
       - intranet
     restart: unless-stopped

frontend/package.json

@@ -46,7 +46,10 @@
         "date-fns": "^4.1.0",
         "date-fns-tz": "^3.2.0",
         "embla-carousel-react": "^8.6.0",
+        "html2canvas": "^1.4.1",
+        "html2pdf.js": "^0.14.0",
         "input-otp": "^1.4.2",
+        "jspdf": "^4.2.1",
         "lucide-react": "^0.487.0",
         "moment": "^2.30.1",
         "next-themes": "^0.4.6",