675 lines
15 KiB
Go
675 lines
15 KiB
Go
package repository
|
|
|
|
import (
|
|
"context"
|
|
"sort"
|
|
"strings"
|
|
"sync"
|
|
"time"
|
|
|
|
"apps/backend/internal/module/growth/domain"
|
|
)
|
|
|
|
type Memory struct {
|
|
mu sync.Mutex
|
|
outcomes map[string]*domain.OutcomeEvent
|
|
bySource map[string]string
|
|
checkups map[string]*domain.WeeklyCheckup
|
|
health map[string]*domain.AccountHealth
|
|
workspaces map[string]*domain.Workspace
|
|
wsState map[int64]*domain.MemberWorkspaceState
|
|
reviews map[string]*domain.DraftReview
|
|
rewards map[string]*domain.InviteReward
|
|
playbooks map[string]*domain.Playbook
|
|
utm map[string]*domain.UtmLink
|
|
wsMembers map[string]*domain.WorkspaceMember
|
|
bench map[string]*domain.BenchmarkSample
|
|
}
|
|
|
|
func NewMemory() *Memory {
|
|
return &Memory{
|
|
outcomes: map[string]*domain.OutcomeEvent{},
|
|
bySource: map[string]string{},
|
|
checkups: map[string]*domain.WeeklyCheckup{},
|
|
health: map[string]*domain.AccountHealth{},
|
|
workspaces: map[string]*domain.Workspace{},
|
|
wsState: map[int64]*domain.MemberWorkspaceState{},
|
|
reviews: map[string]*domain.DraftReview{},
|
|
rewards: map[string]*domain.InviteReward{},
|
|
playbooks: map[string]*domain.Playbook{},
|
|
utm: map[string]*domain.UtmLink{},
|
|
wsMembers: map[string]*domain.WorkspaceMember{},
|
|
bench: map[string]*domain.BenchmarkSample{},
|
|
}
|
|
}
|
|
|
|
func sourceKey(t, id string) string { return t + ":" + id }
|
|
|
|
func (m *Memory) UpsertOutcomeBySource(_ context.Context, e *domain.OutcomeEvent) error {
|
|
m.mu.Lock()
|
|
defer m.mu.Unlock()
|
|
sk := sourceKey(e.SourceType, e.SourceID)
|
|
if id, ok := m.bySource[sk]; ok {
|
|
// 發佈 hook 可能重送；已存在就保持原 sent_at 與所有觀測／成交訊號。
|
|
*e = *m.outcomes[id]
|
|
return nil
|
|
} else if e.ID == "" {
|
|
e.ID = domain.NewID()
|
|
}
|
|
cp := *e
|
|
m.outcomes[e.ID] = &cp
|
|
m.bySource[sk] = e.ID
|
|
return nil
|
|
}
|
|
|
|
func (m *Memory) GetOutcome(_ context.Context, id string) (*domain.OutcomeEvent, error) {
|
|
m.mu.Lock()
|
|
defer m.mu.Unlock()
|
|
e, ok := m.outcomes[id]
|
|
if !ok {
|
|
return nil, domain.ErrNotFound
|
|
}
|
|
cp := *e
|
|
return &cp, nil
|
|
}
|
|
|
|
func (m *Memory) ListOutcomes(_ context.Context, ownerUID int64, f domain.OutcomeListFilter) ([]*domain.OutcomeEvent, int64, error) {
|
|
m.mu.Lock()
|
|
defer m.mu.Unlock()
|
|
var all []*domain.OutcomeEvent
|
|
for _, e := range m.outcomes {
|
|
if e.OwnerUID != ownerUID {
|
|
continue
|
|
}
|
|
if f.Kind != "" && e.Kind != f.Kind {
|
|
continue
|
|
}
|
|
if f.Confidence != "" && e.Confidence != f.Confidence {
|
|
continue
|
|
}
|
|
if f.SourceType != "" && e.SourceType != f.SourceType {
|
|
continue
|
|
}
|
|
if f.From > 0 && e.SentAt < f.From {
|
|
continue
|
|
}
|
|
if f.To > 0 && e.SentAt > f.To {
|
|
continue
|
|
}
|
|
cp := *e
|
|
all = append(all, &cp)
|
|
}
|
|
sort.Slice(all, func(i, j int) bool { return all[i].SentAt > all[j].SentAt })
|
|
total := int64(len(all))
|
|
page, ps := f.Page, f.PageSize
|
|
if page < 1 {
|
|
page = 1
|
|
}
|
|
if ps < 1 {
|
|
ps = 20
|
|
}
|
|
start := (page - 1) * ps
|
|
if start >= len(all) {
|
|
return nil, total, nil
|
|
}
|
|
end := start + ps
|
|
if end > len(all) {
|
|
end = len(all)
|
|
}
|
|
return all[start:end], total, nil
|
|
}
|
|
|
|
func (m *Memory) SaveOutcome(_ context.Context, e *domain.OutcomeEvent) error {
|
|
m.mu.Lock()
|
|
defer m.mu.Unlock()
|
|
cp := *e
|
|
m.outcomes[e.ID] = &cp
|
|
m.bySource[sourceKey(e.SourceType, e.SourceID)] = e.ID
|
|
return nil
|
|
}
|
|
|
|
func (m *Memory) ListObservingDue(_ context.Context, now int64, limit int) ([]*domain.OutcomeEvent, error) {
|
|
m.mu.Lock()
|
|
defer m.mu.Unlock()
|
|
var out []*domain.OutcomeEvent
|
|
for _, e := range m.outcomes {
|
|
if e.Status != domain.StatusObserving {
|
|
continue
|
|
}
|
|
cp := *e
|
|
out = append(out, &cp)
|
|
if limit > 0 && len(out) >= limit {
|
|
break
|
|
}
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (m *Memory) SaveCheckup(_ context.Context, c *domain.WeeklyCheckup) error {
|
|
m.mu.Lock()
|
|
defer m.mu.Unlock()
|
|
cp := *c
|
|
m.checkups[c.ID] = &cp
|
|
return nil
|
|
}
|
|
|
|
func (m *Memory) GetCheckup(_ context.Context, id string) (*domain.WeeklyCheckup, error) {
|
|
m.mu.Lock()
|
|
defer m.mu.Unlock()
|
|
c, ok := m.checkups[id]
|
|
if !ok {
|
|
return nil, domain.ErrNotFound
|
|
}
|
|
cp := *c
|
|
return &cp, nil
|
|
}
|
|
|
|
func (m *Memory) LatestCheckup(_ context.Context, ownerUID int64) (*domain.WeeklyCheckup, error) {
|
|
m.mu.Lock()
|
|
defer m.mu.Unlock()
|
|
var best *domain.WeeklyCheckup
|
|
for _, c := range m.checkups {
|
|
if c.OwnerUID != ownerUID {
|
|
continue
|
|
}
|
|
if best == nil || c.CreatedAt > best.CreatedAt {
|
|
cp := *c
|
|
best = &cp
|
|
}
|
|
}
|
|
if best == nil {
|
|
return nil, domain.ErrNotFound
|
|
}
|
|
return best, nil
|
|
}
|
|
|
|
func (m *Memory) ListCheckups(_ context.Context, ownerUID int64, page, pageSize int) ([]*domain.WeeklyCheckup, int64, error) {
|
|
m.mu.Lock()
|
|
defer m.mu.Unlock()
|
|
var all []*domain.WeeklyCheckup
|
|
for _, c := range m.checkups {
|
|
if c.OwnerUID == ownerUID {
|
|
cp := *c
|
|
all = append(all, &cp)
|
|
}
|
|
}
|
|
sort.Slice(all, func(i, j int) bool { return all[i].CreatedAt > all[j].CreatedAt })
|
|
total := int64(len(all))
|
|
if page < 1 {
|
|
page = 1
|
|
}
|
|
if pageSize < 1 {
|
|
pageSize = 20
|
|
}
|
|
start := (page - 1) * pageSize
|
|
if start >= len(all) {
|
|
return nil, total, nil
|
|
}
|
|
end := start + pageSize
|
|
if end > len(all) {
|
|
end = len(all)
|
|
}
|
|
return all[start:end], total, nil
|
|
}
|
|
|
|
func (m *Memory) CountCheckupGenerations(_ context.Context, ownerUID int64, sinceNano int64) (int64, error) {
|
|
m.mu.Lock()
|
|
defer m.mu.Unlock()
|
|
var n int64
|
|
for _, c := range m.checkups {
|
|
if c.OwnerUID == ownerUID && c.CreatedAt >= sinceNano {
|
|
n++
|
|
}
|
|
}
|
|
return n, nil
|
|
}
|
|
|
|
func (m *Memory) SaveHealth(_ context.Context, h *domain.AccountHealth) error {
|
|
m.mu.Lock()
|
|
defer m.mu.Unlock()
|
|
cp := *h
|
|
m.health[h.ThreadsAccountID] = &cp
|
|
return nil
|
|
}
|
|
|
|
func (m *Memory) GetHealth(_ context.Context, accountID string) (*domain.AccountHealth, error) {
|
|
m.mu.Lock()
|
|
defer m.mu.Unlock()
|
|
h, ok := m.health[accountID]
|
|
if !ok {
|
|
return nil, domain.ErrNotFound
|
|
}
|
|
cp := *h
|
|
return &cp, nil
|
|
}
|
|
|
|
func (m *Memory) ListHealth(_ context.Context, ownerUID int64) ([]*domain.AccountHealth, error) {
|
|
m.mu.Lock()
|
|
defer m.mu.Unlock()
|
|
var out []*domain.AccountHealth
|
|
for _, h := range m.health {
|
|
if h.OwnerUID == ownerUID {
|
|
cp := *h
|
|
out = append(out, &cp)
|
|
}
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (m *Memory) SaveWorkspace(_ context.Context, w *domain.Workspace) error {
|
|
m.mu.Lock()
|
|
defer m.mu.Unlock()
|
|
cp := *w
|
|
m.workspaces[w.ID] = &cp
|
|
return nil
|
|
}
|
|
|
|
func (m *Memory) GetWorkspace(_ context.Context, id string) (*domain.Workspace, error) {
|
|
m.mu.Lock()
|
|
defer m.mu.Unlock()
|
|
w, ok := m.workspaces[id]
|
|
if !ok {
|
|
return nil, domain.ErrNotFound
|
|
}
|
|
cp := *w
|
|
return &cp, nil
|
|
}
|
|
|
|
func (m *Memory) ListWorkspaces(_ context.Context, ownerUID int64, includeArchived bool) ([]*domain.Workspace, error) {
|
|
m.mu.Lock()
|
|
defer m.mu.Unlock()
|
|
var out []*domain.Workspace
|
|
for _, w := range m.workspaces {
|
|
if w.OwnerUID != ownerUID {
|
|
continue
|
|
}
|
|
if w.Archived && !includeArchived {
|
|
continue
|
|
}
|
|
cp := *w
|
|
out = append(out, &cp)
|
|
}
|
|
sort.Slice(out, func(i, j int) bool { return out[i].CreatedAt < out[j].CreatedAt })
|
|
return out, nil
|
|
}
|
|
|
|
func (m *Memory) CountActiveWorkspaces(_ context.Context, ownerUID int64) (int64, error) {
|
|
m.mu.Lock()
|
|
defer m.mu.Unlock()
|
|
var n int64
|
|
for _, w := range m.workspaces {
|
|
if w.OwnerUID == ownerUID && !w.Archived {
|
|
n++
|
|
}
|
|
}
|
|
return n, nil
|
|
}
|
|
|
|
func (m *Memory) GetMemberWSState(_ context.Context, ownerUID int64) (*domain.MemberWorkspaceState, error) {
|
|
m.mu.Lock()
|
|
defer m.mu.Unlock()
|
|
s, ok := m.wsState[ownerUID]
|
|
if !ok {
|
|
return nil, domain.ErrNotFound
|
|
}
|
|
cp := *s
|
|
return &cp, nil
|
|
}
|
|
|
|
func (m *Memory) SaveMemberWSState(_ context.Context, s *domain.MemberWorkspaceState) error {
|
|
m.mu.Lock()
|
|
defer m.mu.Unlock()
|
|
cp := *s
|
|
m.wsState[s.OwnerUID] = &cp
|
|
return nil
|
|
}
|
|
|
|
func (m *Memory) SaveReview(_ context.Context, r *domain.DraftReview) error {
|
|
m.mu.Lock()
|
|
defer m.mu.Unlock()
|
|
cp := *r
|
|
m.reviews[r.ID] = &cp
|
|
return nil
|
|
}
|
|
|
|
func (m *Memory) GetReview(_ context.Context, id string) (*domain.DraftReview, error) {
|
|
m.mu.Lock()
|
|
defer m.mu.Unlock()
|
|
r, ok := m.reviews[id]
|
|
if !ok {
|
|
return nil, domain.ErrNotFound
|
|
}
|
|
cp := *r
|
|
return &cp, nil
|
|
}
|
|
|
|
func (m *Memory) FindReviewByRef(_ context.Context, ownerUID int64, refType, refID string) (*domain.DraftReview, error) {
|
|
m.mu.Lock()
|
|
defer m.mu.Unlock()
|
|
var best *domain.DraftReview
|
|
for _, r := range m.reviews {
|
|
if r.OwnerUID == ownerUID && r.RefType == refType && r.RefID == refID {
|
|
if best == nil || r.UpdatedAt > best.UpdatedAt {
|
|
cp := *r
|
|
best = &cp
|
|
}
|
|
}
|
|
}
|
|
if best == nil {
|
|
return nil, domain.ErrNotFound
|
|
}
|
|
return best, nil
|
|
}
|
|
|
|
func (m *Memory) ListReviews(_ context.Context, ownerUID int64, status string, page, pageSize int) ([]*domain.DraftReview, int64, error) {
|
|
m.mu.Lock()
|
|
defer m.mu.Unlock()
|
|
var all []*domain.DraftReview
|
|
for _, r := range m.reviews {
|
|
if r.OwnerUID != ownerUID {
|
|
continue
|
|
}
|
|
if status != "" && r.Status != status {
|
|
continue
|
|
}
|
|
cp := *r
|
|
all = append(all, &cp)
|
|
}
|
|
total := int64(len(all))
|
|
if page < 1 {
|
|
page = 1
|
|
}
|
|
if pageSize < 1 {
|
|
pageSize = 20
|
|
}
|
|
start := (page - 1) * pageSize
|
|
if start >= len(all) {
|
|
return nil, total, nil
|
|
}
|
|
end := start + pageSize
|
|
if end > len(all) {
|
|
end = len(all)
|
|
}
|
|
return all[start:end], total, nil
|
|
}
|
|
|
|
func (m *Memory) SaveInviteReward(_ context.Context, r *domain.InviteReward) error {
|
|
m.mu.Lock()
|
|
defer m.mu.Unlock()
|
|
cp := *r
|
|
m.rewards[r.ID] = &cp
|
|
return nil
|
|
}
|
|
|
|
func (m *Memory) ListInviteRewards(_ context.Context, inviterUID int64, limit int) ([]*domain.InviteReward, error) {
|
|
m.mu.Lock()
|
|
defer m.mu.Unlock()
|
|
var all []*domain.InviteReward
|
|
for _, r := range m.rewards {
|
|
if r.InviterUID == inviterUID {
|
|
cp := *r
|
|
all = append(all, &cp)
|
|
}
|
|
}
|
|
sort.Slice(all, func(i, j int) bool { return all[i].CreatedAt > all[j].CreatedAt })
|
|
if limit > 0 && len(all) > limit {
|
|
all = all[:limit]
|
|
}
|
|
return all, nil
|
|
}
|
|
|
|
func (m *Memory) SumInviteRewardPointsMonth(_ context.Context, inviterUID int64, monthStartNano int64) (int, error) {
|
|
m.mu.Lock()
|
|
defer m.mu.Unlock()
|
|
sum := 0
|
|
for _, r := range m.rewards {
|
|
if r.InviterUID == inviterUID && r.Status == domain.RewardCredited && r.CreatedAt >= monthStartNano {
|
|
sum += r.Points
|
|
}
|
|
}
|
|
return sum, nil
|
|
}
|
|
|
|
func (m *Memory) SumInviteRewardPointsTotal(_ context.Context, inviterUID int64) (int, error) {
|
|
m.mu.Lock()
|
|
defer m.mu.Unlock()
|
|
sum := 0
|
|
for _, r := range m.rewards {
|
|
if r.InviterUID == inviterUID && r.Status == domain.RewardCredited {
|
|
sum += r.Points
|
|
}
|
|
}
|
|
return sum, nil
|
|
}
|
|
|
|
func (m *Memory) HasInviteRewardForInvitee(_ context.Context, inviteeUID int64) (bool, error) {
|
|
m.mu.Lock()
|
|
defer m.mu.Unlock()
|
|
for _, r := range m.rewards {
|
|
if r.InviteeUID == inviteeUID && (r.Status == domain.RewardCredited || r.Status == domain.RewardCapped) {
|
|
return true, nil
|
|
}
|
|
}
|
|
return false, nil
|
|
}
|
|
|
|
// Ensure compile-time interface
|
|
var _ domain.Repository = (*Memory)(nil)
|
|
|
|
// MonthStartNano helper for tests
|
|
func MonthStartNano(t time.Time) int64 {
|
|
u := t.UTC()
|
|
return time.Date(u.Year(), u.Month(), 1, 0, 0, 0, 0, time.UTC).UnixNano()
|
|
}
|
|
|
|
// --- P2 ---
|
|
|
|
func (m *Memory) SavePlaybook(_ context.Context, p *domain.Playbook) error {
|
|
m.mu.Lock()
|
|
defer m.mu.Unlock()
|
|
if m.playbooks == nil {
|
|
m.playbooks = map[string]*domain.Playbook{}
|
|
}
|
|
cp := *p
|
|
m.playbooks[p.ID] = &cp
|
|
return nil
|
|
}
|
|
|
|
func (m *Memory) GetPlaybook(_ context.Context, id string) (*domain.Playbook, error) {
|
|
m.mu.Lock()
|
|
defer m.mu.Unlock()
|
|
p, ok := m.playbooks[id]
|
|
if !ok {
|
|
return nil, domain.ErrNotFound
|
|
}
|
|
cp := *p
|
|
return &cp, nil
|
|
}
|
|
|
|
func (m *Memory) ListPlaybooks(_ context.Context, kind, niche string, ownerOnlyUID int64, page, pageSize int) ([]*domain.Playbook, int64, error) {
|
|
m.mu.Lock()
|
|
defer m.mu.Unlock()
|
|
var all []*domain.Playbook
|
|
for _, p := range m.playbooks {
|
|
if kind != "" && p.Kind != kind {
|
|
continue
|
|
}
|
|
if niche != "" && !stringsContainsFold(p.Niche, niche) {
|
|
continue
|
|
}
|
|
if ownerOnlyUID > 0 && p.OwnerUID != ownerOnlyUID {
|
|
continue
|
|
}
|
|
cp := *p
|
|
all = append(all, &cp)
|
|
}
|
|
sort.Slice(all, func(i, j int) bool { return all[i].CreatedAt > all[j].CreatedAt })
|
|
total := int64(len(all))
|
|
if page < 1 {
|
|
page = 1
|
|
}
|
|
if pageSize < 1 {
|
|
pageSize = 20
|
|
}
|
|
start := (page - 1) * pageSize
|
|
if start >= len(all) {
|
|
return nil, total, nil
|
|
}
|
|
end := start + pageSize
|
|
if end > len(all) {
|
|
end = len(all)
|
|
}
|
|
return all[start:end], total, nil
|
|
}
|
|
|
|
func stringsContainsFold(s, sub string) bool {
|
|
return strings.Contains(strings.ToLower(s), strings.ToLower(sub))
|
|
}
|
|
|
|
func (m *Memory) DeletePlaybook(_ context.Context, id string) error {
|
|
m.mu.Lock()
|
|
defer m.mu.Unlock()
|
|
if _, ok := m.playbooks[id]; !ok {
|
|
return domain.ErrNotFound
|
|
}
|
|
delete(m.playbooks, id)
|
|
return nil
|
|
}
|
|
|
|
func (m *Memory) IncPlaybookImport(_ context.Context, id string) error {
|
|
m.mu.Lock()
|
|
defer m.mu.Unlock()
|
|
p, ok := m.playbooks[id]
|
|
if !ok {
|
|
return domain.ErrNotFound
|
|
}
|
|
p.ImportCount++
|
|
return nil
|
|
}
|
|
|
|
func (m *Memory) SaveUtmLink(_ context.Context, u *domain.UtmLink) error {
|
|
m.mu.Lock()
|
|
defer m.mu.Unlock()
|
|
if m.utm == nil {
|
|
m.utm = map[string]*domain.UtmLink{}
|
|
}
|
|
cp := *u
|
|
m.utm[u.Code] = &cp
|
|
return nil
|
|
}
|
|
|
|
func (m *Memory) GetUtmByCode(_ context.Context, code string) (*domain.UtmLink, error) {
|
|
m.mu.Lock()
|
|
defer m.mu.Unlock()
|
|
u, ok := m.utm[code]
|
|
if !ok {
|
|
return nil, domain.ErrNotFound
|
|
}
|
|
cp := *u
|
|
return &cp, nil
|
|
}
|
|
|
|
func (m *Memory) ListUtmLinks(_ context.Context, ownerUID int64) ([]*domain.UtmLink, error) {
|
|
m.mu.Lock()
|
|
defer m.mu.Unlock()
|
|
var out []*domain.UtmLink
|
|
for _, u := range m.utm {
|
|
if u.OwnerUID == ownerUID {
|
|
cp := *u
|
|
out = append(out, &cp)
|
|
}
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (m *Memory) IncUtmClick(_ context.Context, code string) (*domain.UtmLink, error) {
|
|
m.mu.Lock()
|
|
defer m.mu.Unlock()
|
|
u, ok := m.utm[code]
|
|
if !ok {
|
|
return nil, domain.ErrNotFound
|
|
}
|
|
u.Clicks++
|
|
cp := *u
|
|
return &cp, nil
|
|
}
|
|
|
|
func (m *Memory) SaveWorkspaceMember(_ context.Context, mem *domain.WorkspaceMember) error {
|
|
m.mu.Lock()
|
|
defer m.mu.Unlock()
|
|
if m.wsMembers == nil {
|
|
m.wsMembers = map[string]*domain.WorkspaceMember{}
|
|
}
|
|
cp := *mem
|
|
m.wsMembers[mem.ID] = &cp
|
|
return nil
|
|
}
|
|
|
|
func (m *Memory) ListWorkspaceMembers(_ context.Context, workspaceID string) ([]*domain.WorkspaceMember, error) {
|
|
m.mu.Lock()
|
|
defer m.mu.Unlock()
|
|
var out []*domain.WorkspaceMember
|
|
for _, mem := range m.wsMembers {
|
|
if mem.WorkspaceID == workspaceID {
|
|
cp := *mem
|
|
out = append(out, &cp)
|
|
}
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (m *Memory) RemoveWorkspaceMember(_ context.Context, workspaceID string, uid int64) error {
|
|
m.mu.Lock()
|
|
defer m.mu.Unlock()
|
|
for id, mem := range m.wsMembers {
|
|
if mem.WorkspaceID == workspaceID && mem.UID == uid {
|
|
delete(m.wsMembers, id)
|
|
return nil
|
|
}
|
|
}
|
|
return domain.ErrNotFound
|
|
}
|
|
|
|
func (m *Memory) IsWorkspaceMember(_ context.Context, workspaceID string, uid int64) (bool, string, error) {
|
|
m.mu.Lock()
|
|
defer m.mu.Unlock()
|
|
if w, ok := m.workspaces[workspaceID]; ok && w.OwnerUID == uid {
|
|
return true, domain.WSRoleOwner, nil
|
|
}
|
|
for _, mem := range m.wsMembers {
|
|
if mem.WorkspaceID == workspaceID && mem.UID == uid {
|
|
return true, mem.Role, nil
|
|
}
|
|
}
|
|
return false, "", nil
|
|
}
|
|
|
|
func (m *Memory) UpsertBenchmarkSample(_ context.Context, s *domain.BenchmarkSample) error {
|
|
m.mu.Lock()
|
|
defer m.mu.Unlock()
|
|
if m.bench == nil {
|
|
m.bench = map[string]*domain.BenchmarkSample{}
|
|
}
|
|
key := s.Niche + ":" + s.OwnerHash
|
|
s.ID = key
|
|
cp := *s
|
|
m.bench[key] = &cp
|
|
return nil
|
|
}
|
|
|
|
func (m *Memory) ListBenchmarkSamples(_ context.Context, niche string, limit int) ([]*domain.BenchmarkSample, error) {
|
|
m.mu.Lock()
|
|
defer m.mu.Unlock()
|
|
var out []*domain.BenchmarkSample
|
|
for _, s := range m.bench {
|
|
if niche == "" || s.Niche == niche {
|
|
cp := *s
|
|
out = append(out, &cp)
|
|
}
|
|
}
|
|
if limit > 0 && len(out) > limit {
|
|
out = out[:limit]
|
|
}
|
|
return out, nil
|
|
}
|