@johnnyboy11234/esg-idea-contest 0.2.4 → 0.3.1

package/backend/internal/idea/internal/store/store.go

@@ -0,0 +1,166 @@
+// Package store holds the SQL of the idea module. Only the idea module may
+// import it (Go's internal rule); no other module touches the idea table.
+package store
+
+import (
+	"context"
+	"database/sql"
+	"errors"
+	"fmt"
+	"time"
+
+	"github.com/google/uuid"
+)
+
+// ErrNotFound is returned when no row exists or the viewer may not see it. The
+// two cases are deliberately indistinguishable (PRD 6.6, Backend.md 8).
+var ErrNotFound = errors.New("idea not found")
+
+// Querier is satisfied by *sql.DB, *sql.Tx and *sql.Conn.
+type Querier interface {
+	QueryRowContext(ctx context.Context, query string, args ...any) *sql.Row
+}
+
+// NewIdea is a row to insert. Every value is already validated and cleaned;
+// the table's CHECKs are the second line of defence (V005).
+type NewIdea struct {
+	ID        uuid.UUID
+	LeaderID  uuid.UUID
+	Category  string
+	Org       string
+	Direction string
+	Name      string
+	Summary   string
+	Slides    Slides
+}
+
+// Slides is the slide metadata stored on the idea row (D22).
+type Slides struct {
+	ObjectKey string // slides/{ideaId}/{uuid}.{ext}
+	Ext       string // pdf | pptx
+	Size      int64
+	SHA256    string // lower-case hex
+}
+
+// Idea is a row of idea joined with its Leader's public fields.
+type Idea struct {
+	ID              uuid.UUID
+	Category        string
+	Org             string
+	Direction       string
+	Name            string
+	Summary         string
+	LeaderID        uuid.UUID
+	LeaderEmpNo     string
+	LeaderName      string
+	Slides          Slides
+	SlidesUpdatedAt time.Time
+	Version         uint32
+	CreatedAt       time.Time
+	UpdatedAt       time.Time
+}
+
+// InsertIdea inserts an Idea in the caller's transaction. A unique-key
+// violation on uq_idea_leader_name is returned as the driver error; the
+// service maps it with db.DuplicateKey to IDEA_DUPLICATE.
+func InsertIdea(ctx context.Context, tx *sql.Tx, n NewIdea) error {
+	_, err := tx.ExecContext(ctx,
+		`INSERT INTO idea (id, leader_id, category, org, direction, name, summary,
+		                   slides_object_key, slides_ext, slides_size, slides_sha256)
+		 VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+		n.ID.String(), n.LeaderID.String(), n.Category, n.Org, n.Direction, n.Name, n.Summary,
+		n.Slides.ObjectKey, n.Slides.Ext, n.Slides.Size, n.Slides.SHA256)
+	if err != nil {
+		return fmt.Errorf("insert idea: %w", err)
+	}
+	return nil
+}
+
+// VisibleWhere is the one visibility predicate (PRD 6.6: an Idea is visible to
+// its Leader, its approved Members and Admins). Every read of an Idea, single
+// or list, is built on it; no other code decides who may see an Idea.
+// Arguments, in order: is_admin (0/1, CAST AS SIGNED in sqlc terms, rule R4),
+// viewer user id. It assumes the idea table is aliased i.
+//
+// TODO(B5-01): add the approved-Member branch
+//
+//	OR EXISTS (SELECT 1 FROM idea_member m WHERE m.idea_id = i.id
+//	           AND m.user_id = ? AND m.status = 'ACCEPTED')
+//
+// when the idea_member table exists. Until then Members cannot exist.
+const VisibleWhere = `(? = 1 OR i.leader_id = ?)`
+
+const selectIdea = `
+SELECT i.id, i.category, i.org, i.direction, i.name, i.summary,
+       i.leader_id, u.emp_no, u.name,
+       i.slides_object_key, i.slides_ext, i.slides_size, i.slides_sha256, i.slides_updated_at,
+       i.version, i.created_at, i.updated_at
+  FROM idea i
+  JOIN app_user u ON u.id = i.leader_id`
+
+// GetVisible is the single visibility query for one Idea. A missing Idea and
+// an Idea the viewer may not see both return ErrNotFound.
+func GetVisible(ctx context.Context, q Querier, id, viewer uuid.UUID, isAdmin bool) (Idea, error) {
+	var (
+		out           Idea
+		sid, lid, vid string
+		admin         int
+	)
+	admin = 0
+	if isAdmin {
+		admin = 1
+	}
+	vid = viewer.String()
+	err := q.QueryRowContext(ctx, selectIdea+` WHERE i.id = ? AND `+VisibleWhere,
+		id.String(), admin, vid).Scan(
+		&sid, &out.Category, &out.Org, &out.Direction, &out.Name, &out.Summary,
+		&lid, &out.LeaderEmpNo, &out.LeaderName,
+		&out.Slides.ObjectKey, &out.Slides.Ext, &out.Slides.Size, &out.Slides.SHA256, &out.SlidesUpdatedAt,
+		&out.Version, &out.CreatedAt, &out.UpdatedAt)
+	if errors.Is(err, sql.ErrNoRows) {
+		return Idea{}, ErrNotFound
+	}
+	if err != nil {
+		return Idea{}, fmt.Errorf("select idea: %w", err)
+	}
+	if out.ID, err = uuid.Parse(sid); err != nil {
+		return Idea{}, fmt.Errorf("idea id: %w", err)
+	}
+	if out.LeaderID, err = uuid.Parse(lid); err != nil {
+		return Idea{}, fmt.Errorf("idea leader id: %w", err)
+	}
+	return out, nil
+}
+
+// ErrNoLeader is returned by LeaderName when the user row is gone, which a
+// valid session rules out; the caller treats it as an internal error.
+var ErrNoLeader = errors.New("leader account not found")
+
+// LeaderName returns the account name of user id: the expected filename takes
+// the Leader's name from the account, never from the form (PRD 6.6).
+func LeaderName(ctx context.Context, q Querier, id uuid.UUID) (string, error) {
+	var name string
+	err := q.QueryRowContext(ctx, `SELECT name FROM app_user WHERE id = ?`, id.String()).Scan(&name)
+	if errors.Is(err, sql.ErrNoRows) {
+		return "", ErrNoLeader
+	}
+	if err != nil {
+		return "", fmt.Errorf("select leader name: %w", err)
+	}
+	return name, nil
+}
+
+// NameTaken is the read-only duplicate pre-check of create: it saves an upload
+// in the common case, while uq_idea_leader_name stays authoritative.
+func NameTaken(ctx context.Context, q Querier, leader uuid.UUID, name string) (bool, error) {
+	var one int
+	err := q.QueryRowContext(ctx, `SELECT 1 FROM idea WHERE leader_id = ? AND name = ?`,
+		leader.String(), name).Scan(&one)
+	if errors.Is(err, sql.ErrNoRows) {
+		return false, nil
+	}
+	if err != nil {
+		return false, fmt.Errorf("select idea name: %w", err)
+	}
+	return true, nil
+}

package/backend/internal/idea/list.go

@@ -0,0 +1,166 @@
+package idea
+
+import (
+	"math"
+	"net/http"
+	"regexp"
+	"slices"
+	"time"
+
+	"github.com/brian-huanggg/AwardRegistration/backend/internal/api"
+	"github.com/brian-huanggg/AwardRegistration/backend/internal/shared/security"
+	"github.com/brian-huanggg/AwardRegistration/backend/internal/shared/web"
+)
+
+const (
+	defaultPageSize = 20
+	maxPageSize     = 100
+	maxPage         = math.MaxInt32 // keeps (page-1)*size far from int overflow
+)
+
+// Closed value sets (PRD 6.6); the idea table's CHECKs list the same values.
+var (
+	categories = []string{"COOL_IDEA", "OUTSTANDING_IMPACT"}
+	orgs       = []string{"AAID", "BSID", "ICSD", "TSID", "PLED", "DEID"}
+	directions = []string{"GREEN_MANUFACTURING", "RESPONSIBLE_SUPPLY_CHAIN", "INCLUSIVE_WORKPLACE",
+		"TALENT_DEVELOPMENT", "CARING_FOR_DISADVANTAGED"}
+	sorts       = []string{"createdAt", "name"}
+	order       = []string{"asc", "desc"}
+	empNoFormat = regexp.MustCompile(`^[0-9]{6}$`)
+)
+
+type summary struct {
+	ID              string `json:"id"`
+	Name            string `json:"name"`
+	Category        string `json:"category"`
+	Org             string `json:"org"`
+	Direction       string `json:"direction"`
+	Leader          person `json:"leader"`
+	MemberCount     int    `json:"memberCount"`
+	MyRelation      any    `json:"myRelation"`
+	CreatedAt       string `json:"createdAt"`
+	SlidesUpdatedAt string `json:"slidesUpdatedAt"`
+}
+
+type page struct {
+	Items []summary `json:"items"`
+	Page  int       `json:"page"`
+	Size  int       `json:"size"`
+	Total int       `json:"total"`
+}
+
+// listQuery is the validated query of GET /ideas.
+type listQuery struct {
+	page, size int
+	filter     ListFilter
+}
+
+// parseList validates every parameter and reports all failures at once, in
+// parameter order, each parameter with its first error (PRD 6.2, 6.6). No
+// invalid value is ignored.
+func parseList(p api.ListIdeasParams) (listQuery, []web.FieldError) {
+	q := listQuery{page: 1, size: defaultPageSize}
+	var errs []web.FieldError
+	bad := func(field string, code web.ErrorCode) {
+		errs = append(errs, web.FieldError{Field: field, Code: code})
+	}
+	if p.Page != nil {
+		if *p.Page < 1 || *p.Page > maxPage {
+			bad("page", web.CodeOutOfRange)
+		} else {
+			q.page = *p.Page
+		}
+	}
+	if p.Size != nil {
+		if *p.Size < 1 || *p.Size > maxPageSize {
+			bad("size", web.CodeOutOfRange)
+		} else {
+			q.size = *p.Size
+		}
+	}
+	enum := func(field string, v *string, allowed []string, dst *string) {
+		if v == nil {
+			return
+		}
+		if !slices.Contains(allowed, *v) {
+			bad(field, web.CodeInvalidEnum)
+			return
+		}
+		*dst = *v
+	}
+	enum("org", p.Org, orgs, &q.filter.Org)
+	enum("category", p.Category, categories, &q.filter.Category)
+	enum("direction", p.Direction, directions, &q.filter.Direction)
+	if p.LeaderEmpNo != nil {
+		if !empNoFormat.MatchString(*p.LeaderEmpNo) {
+			bad("leaderEmpNo", web.CodeInvalidFormat)
+		} else {
+			q.filter.LeaderEmpNo = *p.LeaderEmpNo
+		}
+	}
+	instant := func(field string, v *string) *time.Time {
+		if v == nil {
+			return nil
+		}
+		// RFC 3339 requires the offset or Z, so a bare date or local time fails.
+		t, err := time.Parse(time.RFC3339, *v)
+		if err != nil {
+			bad(field, web.CodeInvalidFormat)
+			return nil
+		}
+		return &t
+	}
+	q.filter.CreatedFrom = instant("createdFrom", p.CreatedFrom)
+	q.filter.CreatedTo = instant("createdTo", p.CreatedTo)
+	if p.Q != nil {
+		q.filter.Q = *p.Q
+	}
+	sort := "createdAt"
+	enum("sort", p.Sort, sorts, &sort)
+	q.filter.SortName = sort == "name"
+	dir := "desc"
+	if q.filter.SortName {
+		dir = "asc"
+	}
+	enum("order", p.Order, order, &dir)
+	q.filter.Desc = dir == "desc"
+	return q, errs
+}
+
+// ListIdeas serves GET /ideas.
+func (h Handler) ListIdeas(w http.ResponseWriter, r *http.Request, params api.ListIdeasParams) {
+	p, ok := security.PrincipalFrom(r.Context())
+	if !ok {
+		h.Fail(w, r, web.NewError(web.CodeUnauthenticated, "authentication required"))
+		return
+	}
+	q, errs := parseList(params)
+	if len(errs) > 0 {
+		e := web.NewError(web.CodeValidationFailed, "invalid query parameter")
+		e.Fields = errs
+		h.Fail(w, r, e)
+		return
+	}
+	rows, total, err := h.Service.List(r.Context(), p, q.filter, q.size, (q.page-1)*q.size)
+	if err != nil {
+		h.Fail(w, r, err)
+		return
+	}
+	out := page{Items: make([]summary, 0, len(rows)), Page: q.page, Size: q.size, Total: total}
+	for _, s := range rows {
+		var rel any // null for Admin
+		if !p.IsAdmin() {
+			rel = "MEMBER"
+			if s.LeaderID == p.UserID {
+				rel = "LEADER"
+			}
+		}
+		out.Items = append(out.Items, summary{
+			ID: s.ID.String(), Name: s.Name, Category: s.Category, Org: s.Org, Direction: s.Direction,
+			Leader:      person{EmpNo: s.LeaderEmpNo, Name: s.LeaderName},
+			MemberCount: s.MemberCount, MyRelation: rel,
+			CreatedAt: web.FormatTime(s.CreatedAt), SlidesUpdatedAt: web.FormatTime(s.SlidesUpdatedAt),
+		})
+	}
+	web.WriteJSON(w, http.StatusOK, out)
+}

package/backend/internal/idea/list_integration_test.go

@@ -0,0 +1,252 @@
+//go:build integration
+
+package idea_test
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"net/url"
+	"slices"
+	"testing"
+
+	"github.com/brian-huanggg/AwardRegistration/backend/internal/api"
+	"github.com/brian-huanggg/AwardRegistration/backend/internal/audit"
+	"github.com/brian-huanggg/AwardRegistration/backend/internal/idea"
+	"github.com/brian-huanggg/AwardRegistration/backend/internal/server"
+	"github.com/brian-huanggg/AwardRegistration/backend/internal/shared/dbtest"
+	"github.com/brian-huanggg/AwardRegistration/backend/internal/shared/security"
+)
+
+func TestListIdeasHandler(t *testing.T) {
+	d := dbtest.New(t)
+	a := addUser(t, d, "100001", "USER")
+	b := addUser(t, d, "100002", "USER")
+	admin := addUser(t, d, "900001", "ADMIN")
+
+	// a owns 3 Ideas, b owns 1 (different org/category). created_at is set explicitly.
+	mk := func(leader security.Principal, name, org, cat, at string) string {
+		n := newIdea(leader.UserID, name)
+		n.Org, n.Category = org, cat
+		if err := insert(d, n); err != nil {
+			t.Fatal(err)
+		}
+		if _, err := d.Exec(`UPDATE idea SET created_at = ? WHERE id = ?`, at, n.ID.String()); err != nil {
+			t.Fatal(err)
+		}
+		return n.ID.String()
+	}
+	a1 := mk(a, "A1", "BSID", "COOL_IDEA", "2026-03-01 00:00:00.000000")
+	a2 := mk(a, "A2", "BSID", "COOL_IDEA", "2026-03-02 00:00:00.000000")
+	a3 := mk(a, "A3", "AAID", "OUTSTANDING_IMPACT", "2026-03-03 00:00:00.000000")
+	b1 := mk(b, "B1", "AAID", "COOL_IDEA", "2026-03-04 00:00:00.000000")
+
+	aud := audit.New(d, nil)
+	errs := server.ErrorAdapter{Audit: aud}
+	h := idea.Handler{Service: &idea.Service{DB: d, Audit: aud}, ExpectedFilename: expectedBase, Fail: errs.Write}
+
+	call := func(p security.Principal, query string) (int, map[string]any) {
+		v, _ := url.ParseQuery(query)
+		var params api.ListIdeasParams
+		get := func(k string) *string {
+			if !v.Has(k) {
+				return nil
+			}
+			s := v.Get(k)
+			return &s
+		}
+		geti := func(k string) *int {
+			if !v.Has(k) {
+				return nil
+			}
+			var n int
+			_, _ = fmt.Sscan(v.Get(k), &n)
+			return &n
+		}
+		params.Page, params.Size = geti("page"), geti("size")
+		params.Org, params.Category, params.Direction = get("org"), get("category"), get("direction")
+		params.LeaderEmpNo, params.CreatedFrom, params.CreatedTo = get("leaderEmpNo"), get("createdFrom"), get("createdTo")
+		params.Q, params.Sort, params.Order = get("q"), get("sort"), get("order")
+		req := httptest.NewRequest(http.MethodGet, "/ideas?"+query, nil)
+		req = req.WithContext(security.WithPrincipal(context.Background(), p))
+		rec := httptest.NewRecorder()
+		h.ListIdeas(rec, req, params)
+		var body map[string]any
+		_ = json.Unmarshal(rec.Body.Bytes(), &body)
+		return rec.Code, body
+	}
+	ids := func(body map[string]any) (out []string) {
+		for _, it := range body["items"].([]any) {
+			out = append(out, it.(map[string]any)["id"].(string))
+		}
+		return out
+	}
+	eq := func(got, want []string) bool {
+		if len(got) != len(want) {
+			return false
+		}
+		for i := range got {
+			if got[i] != want[i] {
+				return false
+			}
+		}
+		return true
+	}
+
+	// User sees only own Ideas, newest first; myRelation LEADER; envelope.
+	code, body := call(a, "")
+	if code != 200 || !eq(ids(body), []string{a3, a2, a1}) || body["total"].(float64) != 3 ||
+		body["page"].(float64) != 1 || body["size"].(float64) != 20 {
+		t.Fatalf("user list: %d %v", code, body)
+	}
+	if rel := body["items"].([]any)[0].(map[string]any)["myRelation"]; rel != "LEADER" {
+		t.Errorf("myRelation = %v", rel)
+	}
+	// Admin sees all, myRelation null.
+	code, body = call(admin, "")
+	if code != 200 || !eq(ids(body), []string{b1, a3, a2, a1}) {
+		t.Fatalf("admin list: %d %v", code, body)
+	}
+	if rel, ok := body["items"].([]any)[0].(map[string]any)["myRelation"]; !ok || rel != nil {
+		t.Errorf("admin myRelation = %v", rel)
+	}
+	// A user with nothing gets [] not null.
+	if _, body = call(addUser(t, d, "100003", "USER"), ""); body["items"] == nil || body["total"].(float64) != 0 {
+		t.Errorf("empty: %v", body)
+	}
+
+	// Paging: size 2, page 2; beyond last page is 200 and empty with total intact.
+	_, body = call(admin, "size=2&page=2")
+	if !eq(ids(body), []string{a2, a1}) || body["total"].(float64) != 4 {
+		t.Errorf("page 2: %v", body)
+	}
+	code, body = call(admin, "size=2&page=3")
+	if code != 200 || len(ids(body)) != 0 || body["total"].(float64) != 4 {
+		t.Errorf("page 3: %d %v", code, body)
+	}
+
+	// Filters.
+	for q, want := range map[string][]string{
+		"org=BSID":                      {a2, a1},
+		"category=OUTSTANDING_IMPACT":   {a3},
+		"leaderEmpNo=100002":            {b1},
+		"org=AAID&category=COOL_IDEA":   {b1},
+		"direction=TALENT_DEVELOPMENT":  {b1, a3, a2, a1},
+		"direction=GREEN_MANUFACTURING": nil,
+		// [from, to) is half-open: 03-02 is included, 03-04 (== to) is not.
+		"createdFrom=2026-03-02T00:00:00Z&createdTo=2026-03-04T00:00:00Z": {a3, a2},
+		// Offset is honoured: 08:00+08:00 is 00:00Z.
+		"createdFrom=2026-03-04T08:00:00%2B08:00": {b1},
+	} {
+		if _, body = call(admin, q); !eq(ids(body), want) {
+			t.Errorf("%s: got %v want %v", q, ids(body), want)
+		}
+	}
+	// Filters never widen visibility.
+	if _, body = call(a, "leaderEmpNo=100002"); len(ids(body)) != 0 {
+		t.Errorf("user saw another Leader's Idea: %v", body)
+	}
+
+	// 422 with the right field code; top-level VALIDATION_FAILED.
+	for q, field := range map[string]string{
+		"size=101": "size", "page=0": "page", "org=XXXX": "org", "category=": "category",
+		"createdFrom=2026-03-01": "createdFrom", "leaderEmpNo=1": "leaderEmpNo",
+		"sort=id": "sort", "sort=": "sort", "order=up": "order", "order=ASC": "order",
+	} {
+		code, body = call(admin, q)
+		if code != 422 || body["code"] != "VALIDATION_FAILED" ||
+			body["errors"].([]any)[0].(map[string]any)["field"] != field {
+			t.Errorf("%s: %d %v", q, code, body)
+		}
+	}
+	if _, body = call(admin, "org=X"); body["errors"].([]any)[0].(map[string]any)["code"] != "INVALID_ENUM" {
+		t.Errorf("org code: %v", body)
+	}
+}
+
+func TestListIdeasSearchSort(t *testing.T) {
+	d := dbtest.New(t)
+	u := addUser(t, d, "100001", "USER")
+	admin := addUser(t, d, "900001", "ADMIN")
+	svc := &idea.Service{DB: d}
+
+	mk := func(name, at string) string {
+		n := newIdea(u.UserID, name)
+		if err := insert(d, n); err != nil {
+			t.Fatal(err)
+		}
+		if _, err := d.Exec(`UPDATE idea SET created_at = ? WHERE id = ?`, at, n.ID.String()); err != nil {
+			t.Fatal(err)
+		}
+		return n.ID.String()
+	}
+	pct := mk("100% green", "2026-03-01 00:00:00.000000")
+	und := mk("a_b", "2026-03-02 00:00:00.000000")
+	axb := mk("axb", "2026-03-03 00:00:00.000000")
+	bang := mk("Hi!", "2026-03-04 00:00:00.000000")
+	upper := mk("ZETA Solar", "2026-03-05 00:00:00.000000")
+	zh := mk("綠能創意", "2026-03-06 00:00:00.000000")
+
+	names := func(f idea.ListFilter) (out []string) {
+		rows, _, err := svc.List(context.Background(), admin, f, 100, 0)
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, r := range rows {
+			out = append(out, r.ID.String())
+		}
+		return out
+	}
+	same := func(got, want []string) bool { return fmt.Sprint(got) == fmt.Sprint(want) }
+
+	for _, tc := range []struct {
+		q    string
+		want []string
+	}{
+		{"%", []string{pct}},      // not a wildcard
+		{"_", []string{und}},      // not a wildcard: axb does not match
+		{"a_b", []string{und}},    // axb does not match
+		{"!", []string{bang}},     // the escape character itself is literal
+		{"zeta", []string{upper}}, // case-insensitive
+		{"SOLAR", []string{upper}},
+		{"綠能", []string{zh}},
+		{"nothing", nil},
+		{"", []string{zh, upper, bang, axb, und, pct}}, // empty term is no filter
+	} {
+		if got := names(idea.ListFilter{Q: tc.q, Desc: true}); !same(got, tc.want) {
+			t.Errorf("q=%q: got %v want %v", tc.q, got, tc.want)
+		}
+	}
+
+	// created_at both ways; name by code point (digits < upper < lower < CJK).
+	if got := names(idea.ListFilter{Desc: false}); !same(got, []string{pct, und, axb, bang, upper, zh}) {
+		t.Errorf("createdAt asc: %v", got)
+	}
+	if got := names(idea.ListFilter{SortName: true}); !same(got, []string{pct, bang, upper, und, axb, zh}) {
+		t.Errorf("name asc: %v", got)
+	}
+	if got := names(idea.ListFilter{SortName: true, Desc: true}); !same(got, []string{zh, axb, und, upper, bang, pct}) {
+		t.Errorf("name desc: %v", got)
+	}
+
+	// Equal sort keys fall back to id (MariaDB UUID order, not text order), in the sort direction. Same created_at for all.
+	if _, err := d.Exec(`UPDATE idea SET created_at = '2026-04-01 00:00:00.000000'`); err != nil {
+		t.Fatal(err)
+	}
+	asc, desc := names(idea.ListFilter{}), names(idea.ListFilter{Desc: true})
+	if len(asc) != 6 {
+		t.Errorf("tie-break asc: %v", asc)
+	}
+	slices.Reverse(desc)
+	if !same(asc, desc) {
+		t.Errorf("tie-break desc is not the reverse of asc: %v vs %v", asc, desc)
+	}
+
+	// A User's search never reaches another Leader's Ideas.
+	other := addUser(t, d, "100002", "USER")
+	if rows, _, err := svc.List(context.Background(), other, idea.ListFilter{Q: "zeta"}, 10, 0); err != nil || len(rows) != 0 {
+		t.Errorf("search widened visibility: %v %v", rows, err)
+	}
+}

package/backend/internal/idea/list_test.go

@@ -0,0 +1,96 @@
+package idea
+
+import (
+	"testing"
+	"time"
+
+	"github.com/brian-huanggg/AwardRegistration/backend/internal/api"
+	"github.com/brian-huanggg/AwardRegistration/backend/internal/shared/web"
+)
+
+func ptr[T any](v T) *T { return &v }
+
+func TestParseListDefaults(t *testing.T) {
+	q, errs := parseList(api.ListIdeasParams{})
+	if len(errs) != 0 || q.page != 1 || q.size != 20 {
+		t.Fatalf("q=%+v errs=%v", q, errs)
+	}
+}
+
+func TestParseListErrors(t *testing.T) {
+	tests := []struct {
+		name string
+		p    api.ListIdeasParams
+		want []web.FieldError
+	}{
+		{"page 0", api.ListIdeasParams{Page: ptr(0)}, []web.FieldError{{Field: "page", Code: web.CodeOutOfRange}}},
+		{"size 101", api.ListIdeasParams{Size: ptr(101)}, []web.FieldError{{Field: "size", Code: web.CodeOutOfRange}}},
+		{"size 0", api.ListIdeasParams{Size: ptr(0)}, []web.FieldError{{Field: "size", Code: web.CodeOutOfRange}}},
+		{"bad org", api.ListIdeasParams{Org: ptr("XXXX")}, []web.FieldError{{Field: "org", Code: web.CodeInvalidEnum}}},
+		{"empty org not ignored", api.ListIdeasParams{Org: ptr("")}, []web.FieldError{{Field: "org", Code: web.CodeInvalidEnum}}},
+		{"lower-case category", api.ListIdeasParams{Category: ptr("cool_idea")}, []web.FieldError{{Field: "category", Code: web.CodeInvalidEnum}}},
+		{"bad direction", api.ListIdeasParams{Direction: ptr("X")}, []web.FieldError{{Field: "direction", Code: web.CodeInvalidEnum}}},
+		{"short emp no", api.ListIdeasParams{LeaderEmpNo: ptr("12345")}, []web.FieldError{{Field: "leaderEmpNo", Code: web.CodeInvalidFormat}}},
+		{"date only", api.ListIdeasParams{CreatedFrom: ptr("2026-01-01")}, []web.FieldError{{Field: "createdFrom", Code: web.CodeInvalidFormat}}},
+		{"no offset", api.ListIdeasParams{CreatedTo: ptr("2026-01-01T00:00:00")}, []web.FieldError{{Field: "createdTo", Code: web.CodeInvalidFormat}}},
+		{"all, in parameter order", api.ListIdeasParams{Size: ptr(500), Page: ptr(-1), Org: ptr("x"), CreatedTo: ptr("nope")},
+			[]web.FieldError{{Field: "page", Code: web.CodeOutOfRange}, {Field: "size", Code: web.CodeOutOfRange},
+				{Field: "org", Code: web.CodeInvalidEnum}, {Field: "createdTo", Code: web.CodeInvalidFormat}}},
+	}
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			_, got := parseList(tc.p)
+			if len(got) != len(tc.want) {
+				t.Fatalf("got %v, want %v", got, tc.want)
+			}
+			for i := range got {
+				if got[i] != tc.want[i] {
+					t.Errorf("[%d] got %v, want %v", i, got[i], tc.want[i])
+				}
+			}
+		})
+	}
+}
+
+func TestParseListValid(t *testing.T) {
+	q, errs := parseList(api.ListIdeasParams{
+		Page: ptr(3), Size: ptr(100), Org: ptr("BSID"), Category: ptr("COOL_IDEA"), Direction: ptr("TALENT_DEVELOPMENT"),
+		LeaderEmpNo: ptr("000123"), CreatedFrom: ptr("2026-01-01T08:00:00+08:00"), CreatedTo: ptr("2026-02-01T00:00:00.5Z"),
+	})
+	if len(errs) != 0 {
+		t.Fatal(errs)
+	}
+	if q.page != 3 || q.size != 100 || q.filter.Org != "BSID" || q.filter.LeaderEmpNo != "000123" {
+		t.Errorf("q = %+v", q)
+	}
+	if !q.filter.CreatedFrom.Equal(time.Date(2026, 1, 1, 0, 0, 0, 0, time.UTC)) {
+		t.Errorf("from = %v", q.filter.CreatedFrom)
+	}
+}
+
+func TestParseListSortOrder(t *testing.T) {
+	for _, tc := range []struct {
+		sort, order *string
+		name, desc  bool
+	}{
+		{nil, nil, false, true},
+		{ptr("createdAt"), nil, false, true},
+		{ptr("createdAt"), ptr("asc"), false, false},
+		{ptr("name"), nil, true, false},
+		{ptr("name"), ptr("desc"), true, true},
+		{nil, ptr("asc"), false, false},
+	} {
+		q, errs := parseList(api.ListIdeasParams{Sort: tc.sort, Order: tc.order})
+		if len(errs) != 0 || q.filter.SortName != tc.name || q.filter.Desc != tc.desc {
+			t.Errorf("%v %v: %+v %v", tc.sort, tc.order, q.filter, errs)
+		}
+	}
+	_, errs := parseList(api.ListIdeasParams{Sort: ptr("id"), Order: ptr("DESC"), Q: ptr("x")})
+	if len(errs) != 2 || errs[0] != (web.FieldError{Field: "sort", Code: web.CodeInvalidEnum}) ||
+		errs[1] != (web.FieldError{Field: "order", Code: web.CodeInvalidEnum}) {
+		t.Errorf("errs = %v", errs)
+	}
+	if q, _ := parseList(api.ListIdeasParams{Q: ptr("50%_")}); q.filter.Q != "50%_" {
+		t.Errorf("q = %q", q.filter.Q)
+	}
+}