can a url have commas?
Yes, a URL can contain commas—but with caveats:
https://example.com/items/1,2,3
https://api.example.com/search?q=foo,bar%2C), especially in query parameters or when parsing.Need to handle them in code or in a spec?
func (tc *TrackingController) GetLatestActions(ctx context.Context, req types.ControllerRequest) types.ControllerResponse { id := req.HttpRequest.URL.Query().Get(“id”) actions := req.HttpRequest.URL.Query().Get(“actions”)
this go/gin controller must receive actions which are comma separated
Got it. If actions is expected to be a comma-separated string in the query (e.g. ?actions=click,scroll,hover), parse it like this:
func (tc *TrackingController) GetLatestActions(ctx context.Context, req types.ControllerRequest) types.ControllerResponse {
id := req.HttpRequest.URL.Query().Get("id")
rawActions := req.HttpRequest.URL.Query().Get("actions")
var actions []string
if rawActions != "" {
actions = strings.Split(rawActions, ",")
}
// Optional: trim spaces
for i := range actions {
actions[i] = strings.TrimSpace(actions[i])
}
// Use `id` and `actions` as needed
// ...
}
%2C—Go’s net/url does that automatically.actions yields an empty slice, not nil, for easier downstream logic.actions against allowed values early.Let me know if you want this tested or wrapped in a helper.
for _, record := range records { actionText := record.Action if source := record.Source; source != “” && source != “direct” { actionText = fmt.Sprintf(“%s via %s”, record.Action, source) }
elapsed := now.Sub(record.CreatedAt)
when := humanizeTimeAgo(elapsed)
//views = true? -> array of views only
i have available here an array - filters []string) which contains values for the “action” field in result
result := map[string]any{
"action": actionText,
"Location": nil, //TODO: add location
"when": when,
}
result must contain only those “action”s where the actionText value is a member of the filters, if its not in the filters , don’t append
results = append(results, result)
}
return results, nil # ChatGPT To filter `actionText` against `filters []string`, add a check before appending:
import "slices" // Go 1.21+; otherwise use a helper for contains()
for _, record := range records {
actionText := record.Action
if source := record.Source; source != "" && source != "direct" {
actionText = fmt.Sprintf("%s via %s", record.Action, source)
}
elapsed := now.Sub(record.CreatedAt)
when := humanizeTimeAgo(elapsed)
// Filter check: skip if not in filters
if len(filters) > 0 && !slices.Contains(filters, actionText) {
continue
}
result := map[string]any{
"action": actionText,
"Location": nil, // TODO: add location
"when": when,
}
results = append(results, result)
}
func contains(slice []string, val string) bool {
for _, v := range slice {
if v == val {
return true
}
}
return false
}
Want to support regex or partial match instead of exact match?
slices undefined
Right—slices is from Go 1.21+. If you’re on an earlier version, use a manual helper:
func contains(slice []string, val string) bool {
for _, v := range slice {
if v == val {
return true
}
}
return false
}
if len(filters) > 0 && !contains(filters, actionText) {
continue
}
Let me know if you want filters to be case-insensitive or matched against record.Action instead of actionText.
i’m on go 1.23 do i need to import slices?
Yes—even in Go 1.23, you still need to import the slices package explicitly:
import "slices"
It’s in the standard library as of Go 1.21, but not pre-imported automatically.
Use like:
if len(filters) > 0 && !slices.Contains(filters, actionText) {
continue
}
You’re good to go.
// GetLatestActions retrieves top n actions for a campaign func (ts *trackingService) GetLatestActions(ctx context.Context, campaignId string, top int, filters []string) ([]any, error) { query := ts.client.Tracking. Query(). Where(tracking.CampaignEQ(campaignId)). Order(ent.Desc(tracking.FieldCreatedAt)). Limit(top)
records, err := query.All(ctx)
if err != nil {
ts.logger.Error("failed to get latest actions", slog.Any("error", err))
return nil, fmt.Errorf("failed to get latest actions: %w", err)
}
now := time.Now()
results := make([]any, 0, len(records))
for _, record := range records {
actionText := record.Action
if source := record.Source; source != "" && source != "direct" {
actionText = fmt.Sprintf("%s via %s", record.Action, source)
}
elapsed := now.Sub(record.CreatedAt)
when := humanizeTimeAgo(elapsed)
//views = true? -> array of views only
// Filter check: skip if not in filters
if len(filters) > 0 && !slices.Contains(filters, actionText) {
continue
}
result := map[string]any{
"action": actionText,
"Location": nil, // TODO: add location
"when": when,
}
results = append(results, result)
}
return results, nil }
consider this function and make the following test pass, give only the relevant/changed bits of code
Sure—please provide the test you want to make pass. Once I see the test, I’ll give you the minimal code changes needed.
func TestGetLatestActions(t *testing.T) { type args struct { campaignId string top int }
type testCase struct {
name string
args args
setup func(ts *trackingService)
wantCount int
expectError bool
}
now := time.Now()
testCases := []testCase{
{
name: "Retrieve latest actions for campaign",
args: args{
campaignId: "campaign_123",
top: 3,
},
setup: func(ts *trackingService) {
ctx := context.Background()
// Create three tracking records for the campaign
_, err := ts.client.Tracking.Create().
SetCampaign("campaign_123").
SetAction("clicked_button").
SetSource("facebook").
SetCreatedAt(now.Add(-10 * time.Minute)).
Save(ctx)
assert.NoError(t, err)
_, err = ts.client.Tracking.Create().
SetCampaign("campaign_123").
SetAction("viewed_page").
SetSource("direct").
SetCreatedAt(now.Add(-30 * time.Minute)).
Save(ctx)
assert.NoError(t, err)
_, err = ts.client.Tracking.Create().
SetCampaign("campaign_123").
SetAction("signed_up").
SetSource("twitter").
SetCreatedAt(now.Add(-2 * time.Hour)).
Save(ctx)
assert.NoError(t, err)
},
wantCount: 3,
expectError: false,
},
{
name: "No actions for campaign",
args: args{
campaignId: "empty_campaign",
top: 5,
},
setup: func(ts *trackingService) {},
wantCount: 0,
expectError: false,
},
{
name: "Limit number of actions returned",
args: args{
campaignId: "campaign_with_many_actions",
top: 2,
},
setup: func(ts *trackingService) {
ctx := context.Background()
// Create five tracking records but we'll only request top 2
for i := 0; i < 5; i++ {
_, err := ts.client.Tracking.Create().
SetCampaign("campaign_with_many_actions").
SetAction(fmt.Sprintf("action_%d", i)).
SetCreatedAt(now.Add(time.Duration(-i) * time.Hour)).
Save(ctx)
assert.NoError(t, err)
}
},
wantCount: 2,
expectError: false,
},
{
name: "Database error simulation",
args: args{
campaignId: "error_campaign",
top: 3,
},
setup: func(ts *trackingService) {
// This would need to be implemented with a mock in a real scenario
// For this example, we'll assume the test framework can simulate DB errors
},
wantCount: 0,
expectError: false,
},
}
for _, tc := range testCases {
t.Run(tc.name, func(t *testing.T) {
ts := setupTest(t).(*trackingService)
tc.setup(ts)
got, err := ts.GetLatestActions(context.Background(), tc.args.campaignId, tc.args.top)
if tc.expectError {
assert.Error(t, err)
return
}
assert.NoError(t, err)
assert.Len(t, got, tc.wantCount)
if tc.wantCount > 0 {
// Verify structure of returned objects
for _, item := range got {
result, ok := item.(map[string]interface{})
assert.True(t, ok, "Result should be a map")
assert.Contains(t, result, "action")
assert.Contains(t, result, "when")
assert.Contains(t, result, "Location")
}
}
})
} } # ChatGPT Your function signature is missing the `filters []string` argument required by the current implementation. The test calls:
got, err := ts.GetLatestActions(context.Background(), tc.args.campaignId, tc.args.top)
But your method requires:
GetLatestActions(ctx context.Context, campaignId string, top int, filters []string)
Update this line in the test:
got, err := ts.GetLatestActions(context.Background(), tc.args.campaignId, tc.args.top)
Change to:
got, err := ts.GetLatestActions(context.Background(), tc.args.campaignId, tc.args.top, nil)
That’s it. No change needed in the function or setup logic unless you’re testing filtering behavior specifically.
Want to add a case that exercises filtering?
for _, record := range records { actionText := record.Action if source := record.Source; source != “” && source != “direct” { actionText = fmt.Sprintf(“%s via %s”, record.Action, source) }
elapsed := now.Sub(record.CreatedAt)
when := humanizeTimeAgo(elapsed)
//views = true? -> array of views only
// Filter check: skip if not in filters
if len(filters) > 0 && !slices.Contains(filters, actionText) {
continue
}
–> this isn’t working here the filters is an array like “filters”:[“share”,”view”,”sign”] and the actionText is a string “view via ShareLink” or “Share via Share button”, so the filteration should check if the any of the given filters in the array is a substring of the actionText, case is irrelevant
result := map[string]any{
"action": actionText,
"Location": nil, // TODO: add location
"when": when,
"user_name": record.MemberName,
}
results = append(results, result)
} # ChatGPT Got it—you want **case-insensitive substring matching** between each `actionText` and the `filters` array. Replace the `slices.Contains(...)` check with a custom match.
if len(filters) > 0 && !slices.Contains(filters, actionText) {
continue
}
if len(filters) > 0 && !matchesAnyFilter(actionText, filters) {
continue
}
func matchesAnyFilter(text string, filters []string) bool {
text = strings.ToLower(text)
for _, f := range filters {
if strings.Contains(text, strings.ToLower(f)) {
return true
}
}
return false
}
Now it will include results where any filter appears anywhere in actionText, ignoring case. Example:
filter = "view" matches actionText = "View via Social"filter = "share" matches actionText = "shared via Email"Want to turn this into a regex filter later? Easy lift.