diff --git a/graphql/schema/torrent_content.graphqls b/graphql/schema/torrent_content.graphqls index 3c5b57cc..ceab4a68 100644 --- a/graphql/schema/torrent_content.graphqls +++ b/graphql/schema/torrent_content.graphqls @@ -74,6 +74,7 @@ input TorrentContentFacetsInput { releaseYear: ReleaseYearFacetInput videoResolution: VideoResolutionFacetInput videoSource: VideoSourceFacetInput + publishedAt: String } type ContentTypeAgg { diff --git a/internal/database/search/criteria_torrent_content_published_at.go b/internal/database/search/criteria_torrent_content_published_at.go new file mode 100644 index 00000000..630c2985 --- /dev/null +++ b/internal/database/search/criteria_torrent_content_published_at.go @@ -0,0 +1,222 @@ +package search + +import ( + "errors" + "regexp" + "strconv" + "strings" + "time" + + "github.com/bitmagnet-io/bitmagnet/internal/database/query" + "gorm.io/gen/field" +) + +// timeNow is a replaceable function for time.Now, making testing easier +var timeNow = time.Now + +// TorrentContentPublishedAtCriteria returns a criteria that filters torrents by published_at timestamp +func TorrentContentPublishedAtCriteria(timeFrame string) query.Criteria { + return query.DaoCriteria{ + Conditions: func(ctx query.DbContext) ([]field.Expr, error) { + if timeFrame == "" { + return nil, nil + } + + startTime, endTime, err := parseTimeFrame(timeFrame) + if err != nil { + return nil, err + } + + return []field.Expr{ + ctx.Query().TorrentContent.PublishedAt.Gte(startTime), + ctx.Query().TorrentContent.PublishedAt.Lte(endTime), + }, nil + }, + } +} + +// ParseTimeFrame parses a time frame string into start and end times +func parseTimeFrame(timeFrame string) (time.Time, time.Time, error) { + timeFrame = strings.TrimSpace(timeFrame) + + // Default end time is now + endTime := timeNow().UTC() + var startTime time.Time + + // Empty string means no time filter + if timeFrame == "" { + return time.Time{}, time.Time{}, nil + } + + // Handle relative time expressions (e.g., "3h", "7d") + if relativeMatch, _ := regexp.MatchString(`^\d+[smhdwMy]$`, timeFrame); relativeMatch { + duration, err := parseRelativeTime(timeFrame) + if err != nil { + return time.Time{}, time.Time{}, err + } + startTime = endTime.Add(-duration) + return startTime, endTime, nil + } + + // Handle special expressions + switch timeFrame { + case "today": + startTime = time.Date(endTime.Year(), endTime.Month(), endTime.Day(), 0, 0, 0, 0, time.UTC) + return startTime, endTime, nil + + case "yesterday": + yesterday := endTime.AddDate(0, 0, -1) + startTime = time.Date(yesterday.Year(), yesterday.Month(), yesterday.Day(), 0, 0, 0, 0, time.UTC) + endTime = time.Date(yesterday.Year(), yesterday.Month(), yesterday.Day(), 23, 59, 59, 999999999, time.UTC) + return startTime, endTime, nil + + case "this week": + // Calculate days since start of week (Monday) + daysSinceMonday := int(endTime.Weekday()) + if daysSinceMonday == 0 { // Sunday + daysSinceMonday = 6 + } else { + daysSinceMonday-- + } + startTime = time.Date(endTime.Year(), endTime.Month(), endTime.Day()-daysSinceMonday, 0, 0, 0, 0, time.UTC) + return startTime, endTime, nil + + case "last week": + // Calculate days since start of week (Monday) + daysSinceMonday := int(endTime.Weekday()) + if daysSinceMonday == 0 { // Sunday + daysSinceMonday = 6 + } else { + daysSinceMonday-- + } + // Start of this week + thisWeekStart := time.Date(endTime.Year(), endTime.Month(), endTime.Day()-daysSinceMonday, 0, 0, 0, 0, time.UTC) + // Start of last week is 7 days before start of this week + startTime = thisWeekStart.AddDate(0, 0, -7) + // End of last week is 1 second before start of this week + endTime = thisWeekStart.Add(-time.Second) + return startTime, endTime, nil + + case "this month": + startTime = time.Date(endTime.Year(), endTime.Month(), 1, 0, 0, 0, 0, time.UTC) + return startTime, endTime, nil + + case "last month": + // Start of this month + thisMonthStart := time.Date(endTime.Year(), endTime.Month(), 1, 0, 0, 0, 0, time.UTC) + // Start of last month + startTime = thisMonthStart.AddDate(0, -1, 0) + // End of last month is 1 second before start of this month + endTime = thisMonthStart.Add(-time.Second) + return startTime, endTime, nil + + case "this year": + startTime = time.Date(endTime.Year(), 1, 1, 0, 0, 0, 0, time.UTC) + return startTime, endTime, nil + + case "last year": + // Start of this year + thisYearStart := time.Date(endTime.Year(), 1, 1, 0, 0, 0, 0, time.UTC) + // Start of last year + startTime = thisYearStart.AddDate(-1, 0, 0) + // End of last year is 1 second before start of this year + endTime = thisYearStart.Add(-time.Second) + return startTime, endTime, nil + } + + // Try to parse as absolute date range (e.g., "2023-01-01 to 2023-01-31") + if strings.Contains(timeFrame, " to ") { + parts := strings.Split(timeFrame, " to ") + if len(parts) != 2 { + return time.Time{}, time.Time{}, errors.New("invalid date range format. Expected 'start to end'") + } + + var err error + startTime, err = parseDateString(strings.TrimSpace(parts[0])) + if err != nil { + return time.Time{}, time.Time{}, err + } + + endTime, err = parseDateString(strings.TrimSpace(parts[1])) + if err != nil { + return time.Time{}, time.Time{}, err + } + + // If end time doesn't have a time component, set it to end of day + if endTime.Hour() == 0 && endTime.Minute() == 0 && endTime.Second() == 0 { + endTime = time.Date(endTime.Year(), endTime.Month(), endTime.Day(), 23, 59, 59, 999999999, endTime.Location()) + } + + return startTime, endTime, nil + } + + // Try to parse as a single date (e.g., "2023-01-01") + parsedDate, err := parseDateString(timeFrame) + if err == nil { + startTime = parsedDate + endTime = time.Date(parsedDate.Year(), parsedDate.Month(), parsedDate.Day(), 23, 59, 59, 999999999, parsedDate.Location()) + return startTime, endTime, nil + } + + return time.Time{}, time.Time{}, errors.New("could not parse time frame") +} + +// parseRelativeTime parses a relative time string (e.g., "3h", "7d") into a time.Duration +func parseRelativeTime(relTime string) (time.Duration, error) { + // Extract the number and unit + re := regexp.MustCompile(`^(\d+)([smhdwMy])$`) + matches := re.FindStringSubmatch(relTime) + if len(matches) != 3 { + return 0, errors.New("invalid relative time format. Expected format: '3h', '7d', etc.") + } + + value, err := strconv.Atoi(matches[1]) + if err != nil { + return 0, err + } + + unit := matches[2] + + // Convert to duration + switch unit { + case "s": // seconds + return time.Duration(value) * time.Second, nil + case "m": // minutes + return time.Duration(value) * time.Minute, nil + case "h": // hours + return time.Duration(value) * time.Hour, nil + case "d": // days + return time.Duration(value) * 24 * time.Hour, nil + case "w": // weeks + return time.Duration(value) * 7 * 24 * time.Hour, nil + case "M": // months (approximate) + return time.Duration(value) * 30 * 24 * time.Hour, nil + case "y": // years (approximate) + return time.Duration(value) * 365 * 24 * time.Hour, nil + default: + return 0, errors.New("unknown time unit. Valid units: s, m, h, d, w, M, y") + } +} + +// parseDateString attempts to parse a date string in various formats +func parseDateString(dateStr string) (time.Time, error) { + // Try standard formats + formats := []string{ + "2006-01-02", + "2006-01-02T15:04:05Z", + "2006-01-02 15:04:05", + "2006/01/02", + "01/02/2006", + "2-Jan-2006", + "Jan 2, 2006", + } + + for _, format := range formats { + t, err := time.Parse(format, dateStr) + if err == nil { + return t, nil + } + } + + return time.Time{}, errors.New("could not parse date string") +} \ No newline at end of file diff --git a/internal/database/search/criteria_torrent_content_published_at_test.go b/internal/database/search/criteria_torrent_content_published_at_test.go new file mode 100644 index 00000000..2af297f9 --- /dev/null +++ b/internal/database/search/criteria_torrent_content_published_at_test.go @@ -0,0 +1,371 @@ +package search + +import ( + "testing" + "time" + + "github.com/stretchr/testify/assert" +) + +// This file contains tests for the torrent published date filter criteria + +func TestTorrentContentPublishedAtCriteria(t *testing.T) { + // Test basic creation of criteria + criteria := TorrentContentPublishedAtCriteria("7d") + assert.NotNil(t, criteria, "Criteria should not be nil") + + // Also test empty string handling + emptyTimeFrame := TorrentContentPublishedAtCriteria("") + assert.NotNil(t, emptyTimeFrame) +} + +// TestParseTimeFrameWithFixedTime tests parseTimeFrame with a fixed time to verify time-based calculations +func TestParseTimeFrameWithFixedTime(t *testing.T) { + // Define a fixed time for consistent testing: January 15, 2023 10:30:00 UTC + fixedTime := time.Date(2023, 1, 15, 10, 30, 0, 0, time.UTC) + + // Store the original timeNow function + originalTimeNow := timeNow + + // Replace with our fixed time function + timeNow = func() time.Time { + return fixedTime + } + + // Restore original function when we're done + defer func() { timeNow = originalTimeNow }() + + // Test cases for different time frames + testCases := []struct { + name string + timeFrame string + expectedErr bool + expectedGteTime time.Time + expectedLteTime time.Time + }{ + { + name: "7 days relative time", + timeFrame: "7d", + expectedGteTime: fixedTime.AddDate(0, 0, -7), + expectedLteTime: fixedTime, + }, + { + name: "24 hours relative time", + timeFrame: "24h", + expectedGteTime: fixedTime.Add(-24 * time.Hour), + expectedLteTime: fixedTime, + }, + { + name: "today special time", + timeFrame: "today", + expectedGteTime: time.Date(2023, 1, 15, 0, 0, 0, 0, time.UTC), + expectedLteTime: fixedTime, + }, + { + name: "yesterday special time", + timeFrame: "yesterday", + expectedGteTime: time.Date(2023, 1, 14, 0, 0, 0, 0, time.UTC), + expectedLteTime: time.Date(2023, 1, 14, 23, 59, 59, 999999999, time.UTC), + }, + { + name: "this month special time", + timeFrame: "this month", + expectedGteTime: time.Date(2023, 1, 1, 0, 0, 0, 0, time.UTC), + expectedLteTime: fixedTime, + }, + { + name: "this year special time", + timeFrame: "this year", + expectedGteTime: time.Date(2023, 1, 1, 0, 0, 0, 0, time.UTC), + expectedLteTime: fixedTime, + }, + { + name: "date range", + timeFrame: "2023-01-01 to 2023-01-31", + expectedGteTime: time.Date(2023, 1, 1, 0, 0, 0, 0, time.UTC), + expectedLteTime: time.Date(2023, 1, 31, 23, 59, 59, 999999999, time.UTC), + }, + { + name: "single date", + timeFrame: "2023-01-01", + expectedGteTime: time.Date(2023, 1, 1, 0, 0, 0, 0, time.UTC), + expectedLteTime: time.Date(2023, 1, 1, 23, 59, 59, 999999999, time.UTC), + }, + { + name: "empty time frame", + timeFrame: "", + expectedErr: false, // Should not produce an error, just zero times + }, + { + name: "invalid time frame", + timeFrame: "invalid_format", + expectedErr: true, + }, + } + + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + startTime, endTime, err := parseTimeFrame(tc.timeFrame) + + if tc.expectedErr { + assert.Error(t, err, "Expected error for timeFrame: %s", tc.timeFrame) + return + } + + assert.NoError(t, err, "Unexpected error for timeFrame: %s", tc.timeFrame) + + if tc.timeFrame == "" { + // Empty time frame returns zero times + assert.True(t, startTime.IsZero(), "Start time should be zero for empty time frame") + assert.True(t, endTime.IsZero(), "End time should be zero for empty time frame") + return + } + + // Round to seconds for consistent comparison + startTime = startTime.Truncate(time.Second) + endTime = endTime.Truncate(time.Second) + expectedGteTime := tc.expectedGteTime.Truncate(time.Second) + expectedLteTime := tc.expectedLteTime.Truncate(time.Second) + + assert.Equal(t, expectedGteTime, startTime, + "Start time does not match expected for timeFrame: %s", tc.timeFrame) + assert.Equal(t, expectedLteTime, endTime, + "End time does not match expected for timeFrame: %s", tc.timeFrame) + }) + } +} + +func TestParseTimeFrame(t *testing.T) { + // Define a fixed time for consistent testing + fixedTime := time.Date(2023, 1, 15, 10, 30, 0, 0, time.UTC) + + // Store the original timeNow function + originalTimeNow := timeNow + + // Replace with our fixed time function + timeNow = func() time.Time { + return fixedTime + } + + // Restore original function when we're done + defer func() { timeNow = originalTimeNow }() + + // Define test cases + tests := []struct { + name string + timeFrame string + expectNonEmpty bool + expectError bool + }{ + { + name: "empty string", + timeFrame: "", + expectNonEmpty: false, + }, + { + name: "invalid format", + timeFrame: "invalid_format", + expectNonEmpty: false, + expectError: true, + }, + { + name: "relative time - 7 days", + timeFrame: "7d", + expectNonEmpty: true, + }, + { + name: "relative time - 24 hours", + timeFrame: "24h", + expectNonEmpty: true, + }, + { + name: "relative time - 2 weeks", + timeFrame: "2w", + expectNonEmpty: true, + }, + { + name: "relative time - 3 months", + timeFrame: "3M", + expectNonEmpty: true, + }, + { + name: "relative time - 1 year", + timeFrame: "1y", + expectNonEmpty: true, + }, + { + name: "date range", + timeFrame: "2023-01-01 to 2023-01-31", + expectNonEmpty: true, + }, + { + name: "date range with slashes", + timeFrame: "2023/01/01 to 2023/01/31", + expectNonEmpty: true, + }, + { + name: "single date", + timeFrame: "2023-01-01", + expectNonEmpty: true, + }, + { + name: "special time - today", + timeFrame: "today", + expectNonEmpty: true, + }, + { + name: "special time - yesterday", + timeFrame: "yesterday", + expectNonEmpty: true, + }, + { + name: "special time - this week", + timeFrame: "this week", + expectNonEmpty: true, + }, + { + name: "special time - last week", + timeFrame: "last week", + expectNonEmpty: true, + }, + { + name: "special time - this month", + timeFrame: "this month", + expectNonEmpty: true, + }, + { + name: "special time - last month", + timeFrame: "last month", + expectNonEmpty: true, + }, + { + name: "special time - this year", + timeFrame: "this year", + expectNonEmpty: true, + }, + { + name: "special time - last year", + timeFrame: "last year", + expectNonEmpty: true, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + startTime, endTime, err := parseTimeFrame(tt.timeFrame) + + if tt.expectError { + assert.Error(t, err) + return + } + + assert.NoError(t, err) + + if !tt.expectNonEmpty { + assert.True(t, startTime.IsZero()) + assert.True(t, endTime.IsZero()) + return + } + + // Verify non-zero times + assert.False(t, startTime.IsZero()) + assert.False(t, endTime.IsZero()) + assert.True(t, endTime.After(startTime) || endTime.Equal(startTime)) + + // For special time frames, do additional validation + switch tt.timeFrame { + case "today": + assert.Equal(t, fixedTime.Year(), startTime.Year()) + assert.Equal(t, fixedTime.Month(), startTime.Month()) + assert.Equal(t, fixedTime.Day(), startTime.Day()) + assert.Equal(t, 0, startTime.Hour()) + assert.Equal(t, 0, startTime.Minute()) + case "yesterday": + yesterday := fixedTime.AddDate(0, 0, -1) + assert.Equal(t, yesterday.Year(), startTime.Year()) + assert.Equal(t, yesterday.Month(), startTime.Month()) + assert.Equal(t, yesterday.Day(), startTime.Day()) + assert.Equal(t, 0, startTime.Hour()) + assert.Equal(t, 0, startTime.Minute()) + assert.Equal(t, 23, endTime.Hour()) + assert.Equal(t, 59, endTime.Minute()) + case "this month": + assert.Equal(t, fixedTime.Year(), startTime.Year()) + assert.Equal(t, fixedTime.Month(), startTime.Month()) + assert.Equal(t, 1, startTime.Day()) + case "this year": + assert.Equal(t, fixedTime.Year(), startTime.Year()) + assert.Equal(t, time.January, startTime.Month()) + assert.Equal(t, 1, startTime.Day()) + } + }) + } +} + +func TestParseRelativeTime(t *testing.T) { + tests := []struct { + input string + expected time.Duration + hasError bool + }{ + {"1s", time.Second, false}, + {"60s", 60 * time.Second, false}, + {"5m", 5 * time.Minute, false}, + {"24h", 24 * time.Hour, false}, + {"7d", 7 * 24 * time.Hour, false}, + {"2w", 2 * 7 * 24 * time.Hour, false}, + {"3M", 3 * 30 * 24 * time.Hour, false}, + {"1y", 365 * 24 * time.Hour, false}, + {"invalid", 0, true}, + {"10x", 0, true}, // Invalid unit + {"-5d", 0, true}, // Negative value will fail regex + } + + for _, tt := range tests { + t.Run(tt.input, func(t *testing.T) { + duration, err := parseRelativeTime(tt.input) + + if tt.hasError { + assert.Error(t, err) + return + } + + assert.NoError(t, err) + assert.Equal(t, tt.expected, duration) + }) + } +} + +func TestParseDateString(t *testing.T) { + tests := []struct { + input string + year int + month time.Month + day int + hasError bool + }{ + {"2023-01-15", 2023, time.January, 15, false}, + {"2023/01/15", 2023, time.January, 15, false}, + {"01/15/2023", 2023, time.January, 15, false}, + {"15-Jan-2023", 2023, time.January, 15, false}, + {"Jan 15, 2023", 2023, time.January, 15, false}, + {"2023-01-15T12:30:45Z", 2023, time.January, 15, false}, + {"Invalid date", 0, 0, 0, true}, + } + + for _, tt := range tests { + t.Run(tt.input, func(t *testing.T) { + date, err := parseDateString(tt.input) + + if tt.hasError { + assert.Error(t, err) + return + } + + assert.NoError(t, err) + assert.Equal(t, tt.year, date.Year()) + assert.Equal(t, tt.month, date.Month()) + assert.Equal(t, tt.day, date.Day()) + }) + } +} \ No newline at end of file diff --git a/internal/gql/gql.gen.go b/internal/gql/gql.gen.go index 41fedd79..dc7074f0 100644 --- a/internal/gql/gql.gen.go +++ b/internal/gql/gql.gen.go @@ -2865,6 +2865,7 @@ input TorrentContentFacetsInput { releaseYear: ReleaseYearFacetInput videoResolution: VideoResolutionFacetInput videoSource: VideoSourceFacetInput + publishedAt: String } type ContentTypeAgg { @@ -16452,7 +16453,7 @@ func (ec *executionContext) unmarshalInputTorrentContentFacetsInput(ctx context. asMap[k] = v } - fieldsInOrder := [...]string{"contentType", "torrentSource", "torrentTag", "torrentFileType", "language", "genre", "releaseYear", "videoResolution", "videoSource"} + fieldsInOrder := [...]string{"contentType", "torrentSource", "torrentTag", "torrentFileType", "language", "genre", "releaseYear", "videoResolution", "videoSource", "publishedAt"} for _, k := range fieldsInOrder { v, ok := asMap[k] if !ok { @@ -16522,6 +16523,13 @@ func (ec *executionContext) unmarshalInputTorrentContentFacetsInput(ctx context. return it, err } it.VideoSource = graphql.OmittableOf(data) + case "publishedAt": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("publishedAt")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.PublishedAt = graphql.OmittableOf(data) } } diff --git a/internal/gql/gqlmodel/gen/model.gen.go b/internal/gql/gqlmodel/gen/model.gen.go index f177022f..4e28a6d0 100644 --- a/internal/gql/gqlmodel/gen/model.gen.go +++ b/internal/gql/gqlmodel/gen/model.gen.go @@ -158,6 +158,7 @@ type TorrentContentFacetsInput struct { ReleaseYear graphql.Omittable[*ReleaseYearFacetInput] `json:"releaseYear,omitempty"` VideoResolution graphql.Omittable[*VideoResolutionFacetInput] `json:"videoResolution,omitempty"` VideoSource graphql.Omittable[*VideoSourceFacetInput] `json:"videoSource,omitempty"` + PublishedAt graphql.Omittable[*string] `json:"publishedAt,omitempty"` } type TorrentContentOrderByInput struct { diff --git a/internal/gql/gqlmodel/torrent_content.go b/internal/gql/gqlmodel/torrent_content.go index 21ae873f..6a22108c 100644 --- a/internal/gql/gqlmodel/torrent_content.go +++ b/internal/gql/gqlmodel/torrent_content.go @@ -2,6 +2,8 @@ package gqlmodel import ( "context" + "time" + "github.com/99designs/gqlgen/graphql" q "github.com/bitmagnet-io/bitmagnet/internal/database/query" "github.com/bitmagnet-io/bitmagnet/internal/database/search" @@ -9,7 +11,6 @@ import ( "github.com/bitmagnet-io/bitmagnet/internal/maps" "github.com/bitmagnet-io/bitmagnet/internal/model" "github.com/bitmagnet-io/bitmagnet/internal/protocol" - "time" ) type TorrentContentQuery struct { @@ -162,6 +163,11 @@ func (t TorrentContentQuery) Search( qFacets = append(qFacets, videoSourceFacet(*videoSource)) } options = append(options, q.WithFacet(qFacets...)) + + // Handle publishedAt filter + if publishedAt, ok := input.Facets.PublishedAt.ValueOK(); ok && *publishedAt != "" { + options = append(options, q.Where(search.TorrentContentPublishedAtCriteria(*publishedAt))) + } } if infoHashes, ok := input.InfoHashes.ValueOK(); ok { options = append(options, q.Where(search.TorrentContentInfoHashCriteria(infoHashes...))) diff --git a/webui/src/app/dates/parse-timeframe.spec.ts b/webui/src/app/dates/parse-timeframe.spec.ts new file mode 100644 index 00000000..9d112db0 --- /dev/null +++ b/webui/src/app/dates/parse-timeframe.spec.ts @@ -0,0 +1,126 @@ +import { parseTimeFrame, formatTimeFrameDescription } from "./parse-timeframe"; + +describe("parseTimeFrame", () => { + it("should handle empty", () => { + const emptyResult = parseTimeFrame(""); + expect(emptyResult.isValid).toBeTrue(); + expect(emptyResult.expression).toBe(""); + }); + + it("should parse relative time expressions", () => { + const testCases = [ + { input: "1h", expectValid: true }, + { input: "24h", expectValid: true }, + { input: "7d", expectValid: true }, + { input: "2w", expectValid: true }, + { input: "6m", expectValid: true }, + { input: "1y", expectValid: true }, + { input: "0d", expectValid: true }, + { input: "-1d", expectValid: false }, // Negative values not supported + { input: "1x", expectValid: false }, // Invalid unit + ]; + + for (const tc of testCases) { + const result = parseTimeFrame(tc.input); + expect(result.isValid).toBe(tc.expectValid); + if (tc.expectValid) { + expect(result.expression).toBe(tc.input); + expect(result.startDate).toBeDefined(); + expect(result.endDate).toBeDefined(); + expect(result.startDate <= result.endDate).toBeTrue(); + } + } + }); + + it("should parse special time expressions", () => { + const specialCases = [ + "today", + "yesterday", + "this week", + "last week", + "this month", + "last month", + "this year", + "last year", + ]; + + for (const expression of specialCases) { + const result = parseTimeFrame(expression); + expect(result.isValid).toBeTrue(); + expect(result.expression).toBe(expression); + expect(result.startDate).toBeDefined(); + expect(result.endDate).toBeDefined(); + expect(result.startDate <= result.endDate).toBeTrue(); + } + }); + + it("should parse date ranges", () => { + const result = parseTimeFrame("2023-01-01 to 2023-01-31"); + expect(result.isValid).toBeTrue(); + expect(result.expression).toBe("2023-01-01 to 2023-01-31"); + + // Check properties without exact values since some browsers/environments + // may parse differently + expect(result.startDate instanceof Date).toBeTrue(); + expect(result.endDate instanceof Date).toBeTrue(); + + // Just verify dates are correctly ordered + expect(result.startDate <= result.endDate).toBeTrue(); + }); + + it("should handle human-readable dates and formats", () => { + // Testing various date formats + const testCases = [ + { input: "Jan 1, 2023 to Jan 31, 2023", expectValid: true }, + { input: "2023-01-01", expectValid: true }, // Single date + { input: "Jan 1, 2023", expectValid: true }, // Single date in human format + { input: "1/1/2023", expectValid: true }, // MM/DD/YYYY + { input: "2023/01/01", expectValid: true }, // YYYY/MM/DD + { input: "invalid date", expectValid: false }, + ]; + + for (const tc of testCases) { + const result = parseTimeFrame(tc.input); + expect(result.isValid).toBe(tc.expectValid); + if (tc.expectValid) { + expect(result.expression).toBe(tc.input); + } + } + }); + + it("should handle invalid inputs", () => { + const result = parseTimeFrame("completely invalid"); + expect(result.isValid).toBeFalse(); + expect(result.error).toBeDefined(); + }); +}); + +describe("formatTimeFrameDescription", () => { + it("should format relative times", () => { + const timeFrame = parseTimeFrame("7d"); + const result = formatTimeFrameDescription(timeFrame); + expect(result).toBe("Last 7 days"); + }); + + it("should pass through special expressions", () => { + const timeFrame = parseTimeFrame("today"); + const result = formatTimeFrameDescription(timeFrame); + expect(result).toBe("today"); + }); + + it("should format date ranges nicely", () => { + const timeFrame = parseTimeFrame("2023-01-01 to 2023-01-31"); + const result = formatTimeFrameDescription(timeFrame); + + // The exact format may depend on locale, but should contain the months and dates + expect(result).toContain("Jan"); + expect(result).toContain("2023"); + expect(result).toContain("to"); + }); + + it("should handle invalid time frames", () => { + const timeFrame = parseTimeFrame("invalid"); + const result = formatTimeFrameDescription(timeFrame); + expect(result).toContain("Invalid"); + }); +}); diff --git a/webui/src/app/dates/parse-timeframe.ts b/webui/src/app/dates/parse-timeframe.ts new file mode 100644 index 00000000..ef0e3037 --- /dev/null +++ b/webui/src/app/dates/parse-timeframe.ts @@ -0,0 +1,439 @@ +export type TimeFrame = { + startDate: Date; + endDate: Date; + expression: string; + isValid: boolean; + error?: string; +}; + +/** + * Keywords for relative times + */ +type UnitSingular = + | "second" + | "minute" + | "hour" + | "day" + | "week" + | "month" + | "year"; +type UnitPlural = + | "seconds" + | "minutes" + | "hours" + | "days" + | "weeks" + | "months" + | "years"; +type Unit = UnitSingular | UnitPlural; + +// Unit abbreviations +type UnitAbbreviation = "s" | "m" | "h" | "d" | "w" | "mo" | "y"; + +// Map of abbreviations to full unit names +const unitMap: Record = { + s: "seconds", + m: "minutes", + h: "hours", + d: "days", + w: "weeks", + mo: "months", + y: "years", +}; + +// Special time frames +type SpecialTimeFrame = + | "today" + | "yesterday" + | "this week" + | "last week" + | "this month" + | "last month" + | "this year" + | "last year"; + +/** + * Creates a time frame with error + */ +function errorTimeFrame(expression: string, error: string): TimeFrame { + return { + startDate: new Date(), + endDate: new Date(), + expression, + isValid: false, + error, + }; +} + +/** + * Parse a relative time expression like "3h", "2d", "1w", etc. + * @param expression The expression to parse + */ +function parseRelativeTime(expression: string): TimeFrame { + // Extract numeric value and unit from expression + const match = expression.match(/^(\d+)([a-z]+)$/i); + if (!match) { + return errorTimeFrame( + expression, + "Invalid relative time format. Expected format: '3h', '2d', etc.", + ); + } + + const value = parseInt(match[1], 10); + const unitAbbr = match[2].toLowerCase() as UnitAbbreviation; + + if (!(unitAbbr in unitMap)) { + return errorTimeFrame( + expression, + `Unknown time unit: '${unitAbbr}'. Valid units: s, m, h, d, w, mo, y`, + ); + } + + const unit = unitMap[unitAbbr]; + const endDate = new Date(); + const startDate = new Date(); + + // Calculate the start date based on the unit and value + switch (unit) { + case "seconds": + startDate.setSeconds(startDate.getSeconds() - value); + break; + case "minutes": + startDate.setMinutes(startDate.getMinutes() - value); + break; + case "hours": + startDate.setHours(startDate.getHours() - value); + break; + case "days": + startDate.setDate(startDate.getDate() - value); + break; + case "weeks": + startDate.setDate(startDate.getDate() - value * 7); + break; + case "months": + startDate.setMonth(startDate.getMonth() - value); + break; + case "years": + startDate.setFullYear(startDate.getFullYear() - value); + break; + } + + return { + startDate, + endDate, + expression, + isValid: true, + }; +} + +/** + * Parse a special time expression like "today", "this week", etc. + * @param expression The expression to parse + */ +function parseSpecialTimeFrame(expression: string): TimeFrame { + const now = new Date(); + const startDate = new Date(now); + const endDate = new Date(now); + + // Default - end of today + endDate.setHours(23, 59, 59, 999); + + switch (expression.toLowerCase()) { + case "today": + startDate.setHours(0, 0, 0, 0); + break; + + case "yesterday": + startDate.setDate(startDate.getDate() - 1); + startDate.setHours(0, 0, 0, 0); + endDate.setDate(endDate.getDate() - 1); + break; + + case "this week": + // Start of week (Sunday or Monday depending on locale) + const dayOfWeek = startDate.getDay(); // 0 is Sunday + const diff = dayOfWeek === 0 ? 6 : dayOfWeek - 1; // Adjust for Monday as start of week + startDate.setDate(startDate.getDate() - diff); + startDate.setHours(0, 0, 0, 0); + break; + + case "last week": + // Start of previous week + const currentDayOfWeek = startDate.getDay(); + const diffToStartOfThisWeek = + currentDayOfWeek === 0 ? 6 : currentDayOfWeek - 1; + startDate.setDate(startDate.getDate() - diffToStartOfThisWeek - 7); + startDate.setHours(0, 0, 0, 0); + + // End of previous week + endDate.setDate(endDate.getDate() - diffToStartOfThisWeek - 1); + endDate.setHours(23, 59, 59, 999); + break; + + case "this month": + startDate.setDate(1); + startDate.setHours(0, 0, 0, 0); + + // End of month + endDate.setMonth(endDate.getMonth() + 1); + endDate.setDate(0); + break; + + case "last month": + // Start of previous month + startDate.setMonth(startDate.getMonth() - 1); + startDate.setDate(1); + startDate.setHours(0, 0, 0, 0); + + // End of previous month + endDate.setDate(0); + break; + + case "this year": + startDate.setMonth(0, 1); + startDate.setHours(0, 0, 0, 0); + + // End of year + endDate.setMonth(11, 31); + break; + + case "last year": + // Start of previous year + startDate.setFullYear(startDate.getFullYear() - 1); + startDate.setMonth(0, 1); + startDate.setHours(0, 0, 0, 0); + + // End of previous year + endDate.setFullYear(endDate.getFullYear() - 1); + endDate.setMonth(11, 31); + break; + + default: + return errorTimeFrame( + expression, + `Unknown special time frame: '${expression}'`, + ); + } + + return { + startDate, + endDate, + expression, + isValid: true, + }; +} + +/** + * Try to parse a date string in various formats + */ +function tryParseDate(dateStr: string): Date | null { + // Try to parse ISO dates like "2023-01-01" + const isoDate = new Date(dateStr); + if (!isNaN(isoDate.getTime())) { + return isoDate; + } + + // Try to parse more human-readable formats like "Jan 1, 2023" + const formats = [ + // Add more date formats as needed + /^(\w{3})\s+(\d{1,2}),?\s+(\d{4})$/, // Jan 1, 2023 + /^(\d{1,2})\s+(\w{3})\s+(\d{4})$/, // 1 Jan 2023 + /^(\d{1,2})\/(\d{1,2})\/(\d{4})$/, // MM/DD/YYYY or DD/MM/YYYY + /^(\d{1,2})-(\d{1,2})-(\d{4})$/, // MM-DD-YYYY or DD-MM-YYYY + ]; + + // Try each format + for (const format of formats) { + const match = dateStr.match(format); + if (match) { + const parsed = new Date(dateStr); + if (!isNaN(parsed.getTime())) { + return parsed; + } + } + } + + return null; +} + +/** + * Parse an absolute time range with a start and end date + */ +function parseAbsoluteTimeRange(expression: string): TimeFrame { + const parts = expression.split(" to "); + if (parts.length !== 2) { + return errorTimeFrame( + expression, + "Invalid absolute time range. Expected format: 'start to end'", + ); + } + + const startStr = parts[0].trim(); + const endStr = parts[1].trim(); + + const startDate = tryParseDate(startStr); + const endDate = tryParseDate(endStr); + + if (!startDate) { + return errorTimeFrame( + expression, + `Could not parse start date: '${startStr}'`, + ); + } + + if (!endDate) { + return errorTimeFrame(expression, `Could not parse end date: '${endStr}'`); + } + + // For dates without time components, set end date to end of day + if ( + endDate.getHours() === 0 && + endDate.getMinutes() === 0 && + endDate.getSeconds() === 0 + ) { + endDate.setHours(23, 59, 59, 999); + } + + return { + startDate, + endDate, + expression, + isValid: true, + }; +} + +/** + * Parse a time frame expression and return a TimeFrame object + * @param expression The time frame expression + */ +export function parseTimeFrame(expression: string): TimeFrame { + if (!expression || expression.trim() === "") { + // Return current date for both start and end when empty + const now = new Date(); + return { + startDate: now, + endDate: now, + expression: "", + isValid: true, + }; + } + + expression = expression.trim(); + + // Check if it's a special time frame + const specialTimeFrames: SpecialTimeFrame[] = [ + "today", + "yesterday", + "this week", + "last week", + "this month", + "last month", + "this year", + "last year", + ]; + + if ( + specialTimeFrames.includes(expression.toLowerCase() as SpecialTimeFrame) + ) { + return parseSpecialTimeFrame(expression); + } + + // Check if it's a relative time (e.g., "3h", "2d") + const relativeTimePattern = /^\d+[a-z]+$/i; + if (relativeTimePattern.test(expression)) { + return parseRelativeTime(expression); + } + + // Check if it contains "to" for absolute time range + if (expression.includes(" to ")) { + return parseAbsoluteTimeRange(expression); + } + + // Try to parse as a single date + const date = tryParseDate(expression); + if (date) { + const endDate = new Date(date); + endDate.setHours(23, 59, 59, 999); + + return { + startDate: date, + endDate, + expression, + isValid: true, + }; + } + + // If nothing matches, return an error + return errorTimeFrame( + expression, + "Could not parse time frame. Try formats like '3h', 'today', or 'Jan 1, 2023 to Jan 2, 2023'", + ); +} + +/** + * Get a human-friendly description of a TimeFrame + */ +export function formatTimeFrameDescription(timeFrame: TimeFrame): string { + if (!timeFrame.isValid) { + return `Invalid: ${timeFrame.error}`; + } + + // For special expressions, just return the expression + const specialExpressions = [ + "today", + "yesterday", + "this week", + "last week", + "this month", + "last month", + "this year", + "last year", + ]; + + if (specialExpressions.includes(timeFrame.expression.toLowerCase())) { + return timeFrame.expression; + } + + // For relative expressions (like 3h, 2d), make it more readable + const relativeMatch = timeFrame.expression.match(/^(\d+)([a-z]+)$/i); + if (relativeMatch) { + const value = relativeMatch[1]; + const unitAbbr = relativeMatch[2].toLowerCase(); + const unit = unitMap[unitAbbr as UnitAbbreviation] || unitAbbr; + + return `Last ${value} ${unit}`; + } + + // For absolute ranges, format nicely + const formatDate = (date: Date) => { + return date.toLocaleDateString(undefined, { + year: "numeric", + month: "short", + day: "numeric", + }); + }; + + return `${formatDate(timeFrame.startDate)} to ${formatDate(timeFrame.endDate)}`; +} + +/** + * Common time frame presets + */ +export const timeFramePresets = [ + { label: "Last hour", value: "1h" }, + { label: "Last 6 hours", value: "6h" }, + { label: "Last 12 hours", value: "12h" }, + { label: "Last 24 hours", value: "24h" }, + { label: "Last 2 days", value: "2d" }, + { label: "Last 7 days", value: "7d" }, + { label: "Last 30 days", value: "30d" }, + { label: "Last 90 days", value: "90d" }, + { label: "Today", value: "today" }, + { label: "Yesterday", value: "yesterday" }, + { label: "This week", value: "this week" }, + { label: "Last week", value: "last week" }, + { label: "This month", value: "this month" }, + { label: "Last month", value: "last month" }, + { label: "This year", value: "this year" }, + { label: "Last year", value: "last year" }, +]; diff --git a/webui/src/app/dates/time-frame-selector.component.spec.ts b/webui/src/app/dates/time-frame-selector.component.spec.ts new file mode 100644 index 00000000..e7d2dd57 --- /dev/null +++ b/webui/src/app/dates/time-frame-selector.component.spec.ts @@ -0,0 +1,79 @@ +import { TestBed } from "@angular/core/testing"; +import { + CUSTOM_ELEMENTS_SCHEMA, + Component, + NO_ERRORS_SCHEMA, +} from "@angular/core"; +import { ReactiveFormsModule } from "@angular/forms"; +import { TranslocoService, TRANSLOCO_CONFIG } from "@jsverse/transloco"; +import { TimeFrameSelectorComponent } from "./time-frame-selector.component"; + +const translationsMock: Record = { + "dates.title": "Date Filter", + "dates.time_frame": "Time Frame", +}; + +@Component({ + template: "", +}) +class TestComponent {} + +describe("TimeFrameSelectorComponent (No DOM)", () => { + let component: TimeFrameSelectorComponent; + + beforeEach(() => { + TestBed.configureTestingModule({ + declarations: [TestComponent], + imports: [ReactiveFormsModule], + schemas: [NO_ERRORS_SCHEMA, CUSTOM_ELEMENTS_SCHEMA], + providers: [ + TimeFrameSelectorComponent, + { + provide: TranslocoService, + useValue: { + translate: (key: string) => translationsMock[key] || key, + selectTranslate: () => (key: string) => + translationsMock[key] || key, + getActiveLang: () => "en", + load: () => Promise.resolve({}), + getLangs: () => ["en"], + events$: { + pipe: () => ({ + subscribe: () => {}, + }), + }, + }, + }, + { + provide: TRANSLOCO_CONFIG, + useValue: { + reRenderOnLangChange: false, + defaultLang: "en", + availableLangs: ["en"], + missingHandler: { + logMissingKey: false, + }, + }, + }, + ], + }); + + component = TestBed.inject(TimeFrameSelectorComponent); + // Initialize component manually + component.ngOnInit(); + }); + + it("should create", () => { + expect(component).toBeTruthy(); + }); + + it("should initialize with empty time frame", () => { + expect(component.timeFrameControl.value).toBe(""); + }); + + it("should emit when updateTimeFrameAndEmit is called", () => { + const spy = spyOn(component.timeFrameChanged, "emit"); + component.updateTimeFrameAndEmit("7d"); + expect(spy).toHaveBeenCalled(); + }); +}); diff --git a/webui/src/app/dates/time-frame-selector.component.ts b/webui/src/app/dates/time-frame-selector.component.ts new file mode 100644 index 00000000..71edd53a --- /dev/null +++ b/webui/src/app/dates/time-frame-selector.component.ts @@ -0,0 +1,808 @@ +import { + ChangeDetectionStrategy, + Component, + EventEmitter, + Input, + OnChanges, + OnDestroy, + OnInit, + Output, + SimpleChanges, +} from "@angular/core"; +import { CommonModule, JsonPipe } from "@angular/common"; +import { FormControl, FormGroup, ReactiveFormsModule } from "@angular/forms"; +import { MatButtonModule } from "@angular/material/button"; +import { MatFormFieldModule } from "@angular/material/form-field"; +import { MatInputModule } from "@angular/material/input"; +import { MatSelectModule } from "@angular/material/select"; +import { MatChipsModule } from "@angular/material/chips"; +import { MatIconModule } from "@angular/material/icon"; +import { MatTooltipModule } from "@angular/material/tooltip"; +import { MatDatepickerModule } from "@angular/material/datepicker"; +import { + MatNativeDateModule, + provideNativeDateAdapter, + MAT_DATE_FORMATS, +} from "@angular/material/core"; +import { MatTabsModule } from "@angular/material/tabs"; +import { MatDividerModule } from "@angular/material/divider"; +import { MatExpansionModule } from "@angular/material/expansion"; +import { TranslocoModule } from "@jsverse/transloco"; +import { + Subject, + Subscription, + debounceTime, + distinctUntilChanged, +} from "rxjs"; +import { + TimeFrame, + formatTimeFrameDescription, + parseTimeFrame, + timeFramePresets, +} from "./parse-timeframe"; + +// Custom date format to match our app's style +export const MY_DATE_FORMATS = { + parse: { + dateInput: "MM/DD/YYYY", + }, + display: { + dateInput: "MMM D, YYYY", + monthYearLabel: "MMM YYYY", + dateA11yLabel: "LL", + monthYearA11yLabel: "MMMM YYYY", + }, +}; + +@Component({ + selector: "app-time-frame-selector", + standalone: true, + imports: [ + CommonModule, + JsonPipe, + ReactiveFormsModule, + MatButtonModule, + MatFormFieldModule, + MatInputModule, + MatSelectModule, + MatChipsModule, + MatIconModule, + MatTooltipModule, + MatDatepickerModule, + MatNativeDateModule, + MatTabsModule, + MatDividerModule, + MatExpansionModule, + TranslocoModule, + ], + providers: [ + provideNativeDateAdapter(), + { provide: MAT_DATE_FORMATS, useValue: MY_DATE_FORMATS }, + ], + template: ` + +
+ +
+ +
+ + + + + + + + date_range {{ t("dates.more_presets") }} + + +
+ +
+ + + + + + + calendar_month {{ t("dates.date_range") }} + + +
+ + {{ t("dates.select_date_range") }} + + + + + {{ t("dates.date_range_hint") }} + + + + + + + + + + {{ t("dates.invalid_start_date") }} + + + {{ t("dates.invalid_end_date") }} + + + +
+ + + + +
+ + +
+ + + + + + + edit {{ t("dates.custom") }} + + +
+ + {{ t("dates.time_frame") }} + + help_outline + {{ t("dates.custom_time_hint") }} + + + +
+ + + + +
+ + event + {{ + formatTimeFrameDescription(currentTimeFrame) + }} + + +
+ +
+ + {{ t("dates.time_frame_error") }}: {{ currentTimeFrame.error }} + +
+
+ + `, + styles: [ + ` + .time-frame-container { + display: flex; + flex-direction: column; + gap: 16px; + } + + .quick-presets-grid { + display: grid; + grid-template-columns: repeat(auto-fill, minmax(120px, 1fr)); + gap: 8px; + } + + .more-presets-grid { + display: grid; + grid-template-columns: repeat(auto-fill, minmax(140px, 1fr)); + gap: 8px; + margin-top: 8px; + } + + .preset-button { + height: auto; + line-height: 1.2; + padding: 8px 12px; + white-space: normal; + text-align: center; + } + + .preset-button.selected { + background-color: rgba(103, 58, 183, 0.1); + border-color: rgba(103, 58, 183, 0.5); + font-weight: 500; + } + + .preset-label { + white-space: normal; + display: block; + } + + .filter-accordion { + width: 100%; + } + + .full-width { + width: 100%; + } + + .date-range-container { + padding: 8px 0; + display: flex; + flex-direction: column; + gap: 16px; + } + + .date-shortcuts { + display: flex; + flex-wrap: wrap; + gap: 8px; + } + + .date-shortcuts button { + min-width: auto; + padding: 0 8px; + } + + .date-shortcuts button.active { + background-color: rgba(103, 58, 183, 0.1); + font-weight: 500; + } + + .date-range-field { + width: 100%; + } + + .custom-expression { + padding: 8px 0; + display: flex; + flex-direction: column; + gap: 16px; + } + + .apply-button { + align-self: flex-start; + } + + .selected-time-frame { + margin-top: 8px; + } + + .range-chip { + padding: 8px 12px; + gap: 8px; + } + + .time-frame-value { + font-weight: normal; + } + + .error-message { + margin-top: 8px; + } + + .error-message mat-chip { + padding: 8px 12px; + } + + @media (max-width: 599px) { + .quick-presets-grid { + grid-template-columns: repeat(2, 1fr); + } + + .more-presets-grid { + grid-template-columns: repeat(2, 1fr); + } + + .date-shortcuts { + flex-direction: column; + align-items: flex-start; + } + + .date-shortcuts button { + width: 100%; + } + } + `, + ], + changeDetection: ChangeDetectionStrategy.OnPush, +}) +export class TimeFrameSelectorComponent + implements OnInit, OnDestroy, OnChanges +{ + @Input() initialTimeFrame: string = ""; + @Output() timeFrameChanged = new EventEmitter(); + + timeFrameControl = new FormControl(""); + + // Date range form group + dateRange = new FormGroup({ + start: new FormControl(null), + end: new FormControl(null), + }); + + // Comparison date range for highlighting in the calendar + comparisonStart: Date | null = null; + comparisonEnd: Date | null = null; + + // State tracking for date shortcut active states + isThisMonthSelected = false; + isLastMonthSelected = false; + isThisYearSelected = false; + isLastYearSelected = false; + + currentTimeFrame: TimeFrame | null = null; + + // Split presets into quick and more categories + quickPresets = timeFramePresets.slice(0, 4); // First 4 presets for immediate access + morePresets = timeFramePresets.slice(4); // Remaining presets in expandable panel + + private _manualChange = new Subject(); + private _subscriptions: Subscription[] = []; + + // Function to apply custom date class for highlighting in the calendar + dateClass = (date: Date): string => { + // Highlight today's date + if (this.isToday(date)) { + return 'today-date'; + } + + // Highlight dates in the current selection range + if (this.comparisonStart && this.comparisonEnd) { + if (date >= this.comparisonStart && date <= this.comparisonEnd) { + return 'comparison-date'; + } + } + + return ''; + }; + + // Helper to check if a date is today + private isToday(date: Date): boolean { + const today = new Date(); + return date.getDate() === today.getDate() && + date.getMonth() === today.getMonth() && + date.getFullYear() === today.getFullYear(); + } + + ngOnInit(): void { + if (this.initialTimeFrame) { + this.timeFrameControl.setValue(this.initialTimeFrame, { + emitEvent: false, + }); + this.updateTimeFrame(this.initialTimeFrame, true); // Pass true to emit initial value + + // If there's an initial time frame, set the date range control accordingly + if (this.currentTimeFrame?.isValid) { + this.dateRange.setValue({ + start: this.currentTimeFrame.startDate, + end: this.currentTimeFrame.endDate, + }); + + // Set comparison dates for highlighting + this.comparisonStart = this.currentTimeFrame.startDate; + this.comparisonEnd = this.currentTimeFrame.endDate; + + // Update shortcut button states + this.updateShortcutButtonStates(); + } + } + + // Handle form control changes - only update UI, don't emit events + this._subscriptions.push( + this.timeFrameControl.valueChanges + .pipe(debounceTime(300), distinctUntilChanged()) + .subscribe((value) => { + if (value !== null) { + this.updateTimeFrame(value, false); // Don't emit events during typing + + // Update date range picker when text input changes + if (this.currentTimeFrame?.isValid) { + this.dateRange.setValue({ + start: this.currentTimeFrame.startDate, + end: this.currentTimeFrame.endDate, + }); + + // Update comparison dates for highlighting + this.comparisonStart = this.currentTimeFrame.startDate; + this.comparisonEnd = this.currentTimeFrame.endDate; + + // Update shortcut button states + this.updateShortcutButtonStates(); + } + } + }), + ); + + // Handle date range form changes + this._subscriptions.push( + this.dateRange.valueChanges.subscribe(range => { + if (range.start && range.end) { + // Update comparison dates for highlighting + this.comparisonStart = range.start; + this.comparisonEnd = range.end; + + // Update shortcut button states when user selects dates + this.updateShortcutButtonStates(); + } + }) + ); + + // Handle manual changes (for presets) + this._subscriptions.push( + this._manualChange.pipe(distinctUntilChanged()).subscribe((value) => { + this.timeFrameControl.setValue(value); + this.updateTimeFrame(value, true); // Emit events for preset selection + }), + ); + } + + ngOnChanges(changes: SimpleChanges): void { + if ( + changes["initialTimeFrame"] && + !changes["initialTimeFrame"].firstChange + ) { + // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment + const newValue = changes["initialTimeFrame"].currentValue; + + // Update the form control without triggering valueChanges + // eslint-disable-next-line @typescript-eslint/no-unsafe-argument + this.timeFrameControl.setValue(newValue || "", { + emitEvent: false, + }); + + if (newValue) { + // Update the time frame - emit=true for query param changes + // eslint-disable-next-line @typescript-eslint/no-unsafe-argument + this.updateTimeFrame(newValue, true); + + // If valid, update date range + if (this.currentTimeFrame?.isValid) { + this.dateRange.setValue({ + start: this.currentTimeFrame.startDate, + end: this.currentTimeFrame.endDate, + }); + + // Update comparison dates for highlighting + this.comparisonStart = this.currentTimeFrame.startDate; + this.comparisonEnd = this.currentTimeFrame.endDate; + + // Update shortcut button states + this.updateShortcutButtonStates(); + } + } else { + // Clear the time frame if empty + this.currentTimeFrame = null; + this.dateRange.reset(); + this.comparisonStart = null; + this.comparisonEnd = null; + this.resetShortcutButtonStates(); + } + } + } + + ngOnDestroy(): void { + this._subscriptions.forEach((sub) => sub.unsubscribe()); + this._subscriptions = []; + } + + onPresetSelected(event: { value: string }): void { + this._manualChange.next(event.value); + } + + // Date range preset methods + selectThisMonth(): void { + const now = new Date(); + const startOfMonth = new Date(now.getFullYear(), now.getMonth(), 1); + const endOfMonth = new Date(now.getFullYear(), now.getMonth() + 1, 0); + endOfMonth.setHours(23, 59, 59, 999); + + this.dateRange.setValue({ + start: startOfMonth, + end: endOfMonth + }); + + this.applyDateRangePicker(); + } + + selectLastMonth(): void { + const now = new Date(); + const startOfLastMonth = new Date(now.getFullYear(), now.getMonth() - 1, 1); + const endOfLastMonth = new Date(now.getFullYear(), now.getMonth(), 0); + endOfLastMonth.setHours(23, 59, 59, 999); + + this.dateRange.setValue({ + start: startOfLastMonth, + end: endOfLastMonth + }); + + this.applyDateRangePicker(); + } + + selectThisYear(): void { + const now = new Date(); + const startOfYear = new Date(now.getFullYear(), 0, 1); + const endOfYear = new Date(now.getFullYear(), 11, 31); + endOfYear.setHours(23, 59, 59, 999); + + this.dateRange.setValue({ + start: startOfYear, + end: endOfYear + }); + + this.applyDateRangePicker(); + } + + selectLastYear(): void { + const now = new Date(); + const startOfLastYear = new Date(now.getFullYear() - 1, 0, 1); + const endOfLastYear = new Date(now.getFullYear() - 1, 11, 31); + endOfLastYear.setHours(23, 59, 59, 999); + + this.dateRange.setValue({ + start: startOfLastYear, + end: endOfLastYear + }); + + this.applyDateRangePicker(); + } + + // Update the shortcut button active states based on current date range + updateShortcutButtonStates(): void { + this.resetShortcutButtonStates(); + + const { start, end } = this.dateRange.value; + if (!start || !end) return; + + const now = new Date(); + + // Check for this month + const startOfMonth = new Date(now.getFullYear(), now.getMonth(), 1); + const endOfMonth = new Date(now.getFullYear(), now.getMonth() + 1, 0); + endOfMonth.setHours(23, 59, 59, 999); + + if (this.isSameDay(start, startOfMonth) && this.isSameDay(end, endOfMonth)) { + this.isThisMonthSelected = true; + } + + // Check for last month + const startOfLastMonth = new Date(now.getFullYear(), now.getMonth() - 1, 1); + const endOfLastMonth = new Date(now.getFullYear(), now.getMonth(), 0); + endOfLastMonth.setHours(23, 59, 59, 999); + + if (this.isSameDay(start, startOfLastMonth) && this.isSameDay(end, endOfLastMonth)) { + this.isLastMonthSelected = true; + } + + // Check for this year + const startOfYear = new Date(now.getFullYear(), 0, 1); + const endOfYear = new Date(now.getFullYear(), 11, 31); + endOfYear.setHours(23, 59, 59, 999); + + if (this.isSameDay(start, startOfYear) && this.isSameDay(end, endOfYear)) { + this.isThisYearSelected = true; + } + + // Check for last year + const startOfLastYear = new Date(now.getFullYear() - 1, 0, 1); + const endOfLastYear = new Date(now.getFullYear() - 1, 11, 31); + endOfLastYear.setHours(23, 59, 59, 999); + + if (this.isSameDay(start, startOfLastYear) && this.isSameDay(end, endOfLastYear)) { + this.isLastYearSelected = true; + } + } + + // Helper to check if two dates represent the same day + private isSameDay(date1: Date, date2: Date): boolean { + return date1.getDate() === date2.getDate() && + date1.getMonth() === date2.getMonth() && + date1.getFullYear() === date2.getFullYear(); + } + + // Reset all shortcut button states + resetShortcutButtonStates(): void { + this.isThisMonthSelected = false; + this.isLastMonthSelected = false; + this.isThisYearSelected = false; + this.isLastYearSelected = false; + } + + applyDateRangePicker(): void { + const { start, end } = this.dateRange.value; + + if (!start || !end) { + return; + } + + // Format dates for the expression + const formatDate = (date: Date) => { + return date.toLocaleDateString("en-US", { + year: "numeric", + month: "short", + day: "numeric", + }); + }; + + // Create a date range expression like "Jan 1, 2023 to Jan 31, 2023" + const expression = `${formatDate(start)} to ${formatDate(end)}`; + + // Update the time frame control without emitting change events + this.timeFrameControl.setValue(expression, { emitEvent: false }); + + // Parse the expression and emit directly + const timeFrame = parseTimeFrame(expression); + this.currentTimeFrame = timeFrame; + + if (timeFrame.isValid) { + this.timeFrameChanged.emit(timeFrame); + + // Update comparison dates for highlighting + this.comparisonStart = timeFrame.startDate; + this.comparisonEnd = timeFrame.endDate; + + // Update shortcut button states + this.updateShortcutButtonStates(); + } + } + + updateTimeFrameAndEmit(value: string | null): void { + if (!value) { + this.clearTimeFrame(); + return; + } + + // First update the time frame without emitting + this.updateTimeFrame(value, false); + + // Then only emit if it's valid + if (this.currentTimeFrame && this.currentTimeFrame.isValid) { + this.timeFrameChanged.emit(this.currentTimeFrame); + } + } + + clearTimeFrame(): void { + // Reset all controls + this.timeFrameControl.setValue(""); + this.dateRange.reset(); + this.currentTimeFrame = null; + this.comparisonStart = null; + this.comparisonEnd = null; + this.resetShortcutButtonStates(); + + this.timeFrameChanged.emit({ + startDate: new Date(), + endDate: new Date(), + expression: "", + isValid: true, + }); + } + + updateTimeFrame(value: string | null, emit: boolean): void { + if (!value) { + return; + } + + const timeFrame = parseTimeFrame(value); + this.currentTimeFrame = timeFrame; + + // Only emit if requested and the time frame is valid + if (emit && timeFrame.isValid) { + this.timeFrameChanged.emit(timeFrame); + } + } + + // Helper to format time frame description + formatTimeFrameDescription(timeFrame: TimeFrame): string { + return formatTimeFrameDescription(timeFrame); + } +} diff --git a/webui/src/app/graphql/generated/index.ts b/webui/src/app/graphql/generated/index.ts index 254ecd55..1060dd44 100644 --- a/webui/src/app/graphql/generated/index.ts +++ b/webui/src/app/graphql/generated/index.ts @@ -522,6 +522,7 @@ export type TorrentContentFacetsInput = { contentType?: InputMaybe; genre?: InputMaybe; language?: InputMaybe; + publishedAt?: InputMaybe; releaseYear?: InputMaybe; torrentFileType?: InputMaybe; torrentSource?: InputMaybe; diff --git a/webui/src/app/i18n/translations/en.json b/webui/src/app/i18n/translations/en.json index 7f67182c..2b95b5aa 100644 --- a/webui/src/app/i18n/translations/en.json +++ b/webui/src/app/i18n/translations/en.json @@ -26,6 +26,37 @@ "xxx": "XXX" } }, + "dates": { + "time_frame": "Time Frame", + "time_frame_placeholder": "e.g. 7d, today, last month", + "time_frame_tooltip": "Enter a time frame like '7d', 'today', or '2023-01-01 to 2023-01-31'", + "time_frame_error": "Invalid time frame", + "presets": "Presets", + "quick_presets": "Quick Presets", + "more_presets": "More Options", + "date_range": "Date Range", + "select_date_range": "Enter a date range", + "date_range_hint": "MM/DD/YYYY – MM/DD/YYYY", + "invalid_start_date": "Invalid start date", + "invalid_end_date": "Invalid end date", + "custom": "Custom", + "custom_time_hint": "Example: '7d', 'today', 'Jan 1, 2023 to Jan 31, 2023'", + "selected_range": "Selected Range", + "calendar": "Calendar", + "date_picker": "Select dates using calendar", + "start_date": "Start Date", + "end_date": "End Date", + "to": "to", + "this_month": "This Month", + "last_month": "Last Month", + "this_year": "This Year", + "last_year": "Last Year", + "last_x_hours": "Last {{x}} hours", + "last_x_days": "Last {{x}} days", + "last_x_weeks": "Last {{x}} weeks", + "last_x_months": "Last {{x}} months", + "custom_range": "Custom Range" + }, "dashboard": { "event": { "created": "Created", @@ -106,6 +137,7 @@ }, "general": { "all": "All", + "apply": "Apply", "dismiss": "Dismiss", "error": "Error", "none": "None", @@ -239,6 +271,7 @@ "copy": "Copy", "copy_to_clipboard": "Copy to clipboard", "delete": "Delete", + "published_date_filter": "Published Date", "delete_action_cannot_be_undone": "This action cannot be undone", "delete_are_you_sure": "Are you sure you want to delete this torrent?", "deselect_all": "Deselect All", diff --git a/webui/src/app/torrents/torrents-search.component.html b/webui/src/app/torrents/torrents-search.component.html index d6d0ad14..fcd1d68f 100644 --- a/webui/src/app/torrents/torrents-search.component.html +++ b/webui/src/app/torrents/torrents-search.component.html @@ -69,6 +69,20 @@ + + + + + calendar_today {{ t("torrents.published_date_filter") }} + + +
+ +
+ @for (facet of facets$ | async; track facet.key) { @if (facet.relevant) { { this.queryString.setValue(stringParam(params, "query") ?? null); + + // Get time frame + const timeFrame = stringParam(params, "published_at"); + if (timeFrame) { + this.timeFrameExpression = timeFrame; + } else { + this.timeFrameExpression = ""; + } + + // Update controller with all params this.controller.update(() => paramsToControls(params)); }), this.controller.controls$.subscribe((ctrl) => { @@ -204,6 +227,8 @@ const initControls: TorrentSearchControls = { const paramsToControls = (params: Params): TorrentSearchControls => { const queryString = stringParam(params, "query"); const activeFacets = stringListParam(params, "facets"); + const publishedAt = stringParam(params, "published_at"); + let selectedTorrent: TorrentSelection | undefined; const selectedTorrentParam = stringParam(params, "torrent"); if (selectedTorrentParam) { @@ -224,6 +249,7 @@ const paramsToControls = (params: Params): TorrentSearchControls => { limit: intParam(params, "limit") ?? defaultLimit, page: intParam(params, "page") ?? 1, selectedTorrent, + publishedAt, facets: facets.reduce((acc, facet) => { const active = activeFacets?.includes(facet.key) ?? false; const filter = stringListParam(params, facet.key); @@ -256,6 +282,7 @@ const controlsToParams = (ctrl: TorrentSearchControls): Params => { content_type: ctrl.contentType, order: orderBy?.field, desc, + published_at: ctrl.publishedAt, ...(ctrl.selectedTorrent ? { torrent: ctrl.selectedTorrent.infoHash, diff --git a/webui/src/app/torrents/torrents-search.controller.spec.ts b/webui/src/app/torrents/torrents-search.controller.spec.ts new file mode 100644 index 00000000..fff4e0ed --- /dev/null +++ b/webui/src/app/torrents/torrents-search.controller.spec.ts @@ -0,0 +1,163 @@ +import { + TorrentsSearchController, + defaultOrderBy, + TorrentSearchControls, +} from "./torrents-search.controller"; + +describe("TorrentsSearchController", () => { + let controller: TorrentsSearchController; + + beforeEach(() => { + controller = new TorrentsSearchController({ + limit: 20, + page: 1, + contentType: null, + orderBy: defaultOrderBy, + facets: { + genre: { active: false }, + language: { active: false }, + fileType: { active: false }, + torrentSource: { active: false }, + torrentTag: { active: false }, + videoResolution: { active: false }, + videoSource: { active: false }, + }, + }); + }); + + describe("setPublishedAt", () => { + it("should update controls with publishedAt time frame", () => { + controller.setPublishedAt("7d"); + + let currentControls: TorrentSearchControls = {} as TorrentSearchControls; + const subscription = controller.controls$.subscribe((controls) => { + currentControls = controls; + }); + + expect(currentControls.publishedAt).toBe("7d"); + expect(currentControls.page).toBe(1); // Should reset to page 1 + + subscription.unsubscribe(); + }); + + it("should update controls with special time frame", () => { + controller.setPublishedAt("this month"); + + let currentControls: TorrentSearchControls = {} as TorrentSearchControls; + const subscription = controller.controls$.subscribe((controls) => { + currentControls = controls; + }); + + expect(currentControls.publishedAt).toBe("this month"); + + subscription.unsubscribe(); + }); + + it("should update controls with date range", () => { + controller.setPublishedAt("2023-01-01 to 2023-01-31"); + + let currentControls: TorrentSearchControls = {} as TorrentSearchControls; + const subscription = controller.controls$.subscribe((controls) => { + currentControls = controls; + }); + + expect(currentControls.publishedAt).toBe("2023-01-01 to 2023-01-31"); + + subscription.unsubscribe(); + }); + + it("should remove publishedAt when value is undefined or empty", () => { + // First set a time frame + controller.setPublishedAt("7d"); + + let currentControls: TorrentSearchControls = {} as TorrentSearchControls; + const subscription = controller.controls$.subscribe((controls) => { + currentControls = controls; + }); + + expect(currentControls.publishedAt).toBe("7d"); + + // Then clear it + controller.setPublishedAt(undefined); + expect(currentControls.publishedAt).toBeUndefined(); + + // Set it again and clear with empty string + controller.setPublishedAt("30d"); + expect(currentControls.publishedAt).toBe("30d"); + + controller.setPublishedAt(""); + expect(currentControls.publishedAt).toBeUndefined(); + + subscription.unsubscribe(); + }); + }); + + describe("controlsToQueryVariables", () => { + it("should add publishedAt to facets when set", (done) => { + let foundPublishedAt = false; + let checkCount = 0; + + // Set up subscription + const subscription = controller.params$.subscribe((params) => { + checkCount++; + + // Check structure exists + expect(params).toBeDefined(); + expect(params.input).toBeDefined(); + expect(params.input.facets).toBeDefined(); + + // Type assertion for accessing facets properties + // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-assignment + const facets = params.input.facets as any; + + // On the second emission, we should have publishedAt + if (checkCount === 2) { + // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access + expect(facets.publishedAt).toBe("7d"); + foundPublishedAt = true; + done(); // Signal test completion + } + }); + + // Initial check should not have publishedAt + + // Now set the published date - this should trigger the params$ observable + controller.setPublishedAt("7d"); + + // Cleanup subscription in case the test times out + setTimeout(() => { + subscription.unsubscribe(); + if (!foundPublishedAt) { + done.fail("Timeout: did not find publishedAt in facets"); + } + }, 2000); + }); + + it("should set the correct value of publishedAt in facets", (done) => { + const testValue = "this month"; + // eslint-disable-next-line @typescript-eslint/no-explicit-any + let latestParams: any = null; + + // Set up subscription + const subscription = controller.params$.subscribe((params) => { + latestParams = params; + }); + + // Set the published date + controller.setPublishedAt(testValue); + + // Check the result + setTimeout(() => { + subscription.unsubscribe(); + try { + expect(latestParams).toBeDefined(); + // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access + expect(latestParams.input.facets.publishedAt).toBe(testValue); + done(); + } catch (e) { + done.fail(e instanceof Error ? e.message : String(e)); + } + }, 500); + }); + }); +}); diff --git a/webui/src/app/torrents/torrents-search.controller.ts b/webui/src/app/torrents/torrents-search.controller.ts index 49625585..0df5510a 100644 --- a/webui/src/app/torrents/torrents-search.controller.ts +++ b/webui/src/app/torrents/torrents-search.controller.ts @@ -51,71 +51,84 @@ export type TorrentSearchControls = { videoResolution: FacetInput; videoSource: FacetInput; }; + publishedAt?: string; selectedTorrent?: TorrentSelection; }; const controlsToQueryVariables = ( ctrl: TorrentSearchControls, -): generated.TorrentContentSearchQueryVariables => ({ - input: { +): generated.TorrentContentSearchQueryVariables => { + // Build facets object using the types we know are available + const facets: generated.TorrentContentFacetsInput = { + contentType: { + aggregate: true, + filter: ctrl.contentType + ? [ctrl.contentType === "null" ? null : ctrl.contentType] + : undefined, + }, + genre: ctrl.facets.genre.active + ? { + aggregate: true, + filter: ctrl.facets.genre.filter, + } + : undefined, + language: ctrl.facets.language.active + ? { + aggregate: ctrl.facets.language.active, + filter: ctrl.facets.language.filter, + } + : undefined, + torrentFileType: ctrl.facets.fileType.active + ? { + aggregate: true, + filter: ctrl.facets.fileType.filter, + } + : undefined, + torrentSource: ctrl.facets.torrentSource.active + ? { + aggregate: true, + filter: ctrl.facets.torrentSource.filter, + } + : undefined, + torrentTag: ctrl.facets.torrentTag.active + ? { + aggregate: true, + filter: ctrl.facets.torrentTag.filter, + } + : undefined, + videoResolution: ctrl.facets.videoResolution.active + ? { + aggregate: true, + filter: ctrl.facets.videoResolution.filter, + } + : undefined, + videoSource: ctrl.facets.videoSource.active + ? { + aggregate: true, + filter: ctrl.facets.videoSource.filter, + } + : undefined, + }; + + // Create the standard input object with proper typing from the generated types + const inputObject: generated.TorrentContentSearchQueryInput = { queryString: ctrl.queryString, limit: ctrl.limit, page: ctrl.page, totalCount: true, hasNextPage: true, orderBy: [ctrl.orderBy], - facets: { - contentType: { - aggregate: true, - filter: ctrl.contentType - ? [ctrl.contentType === "null" ? null : ctrl.contentType] - : undefined, - }, - genre: ctrl.facets.genre.active - ? { - aggregate: true, - filter: ctrl.facets.genre.filter, - } - : undefined, - language: ctrl.facets.language.active - ? { - aggregate: ctrl.facets.language.active, - filter: ctrl.facets.language.filter, - } - : undefined, - torrentFileType: ctrl.facets.fileType.active - ? { - aggregate: true, - filter: ctrl.facets.fileType.filter, - } - : undefined, - torrentSource: ctrl.facets.torrentSource.active - ? { - aggregate: true, - filter: ctrl.facets.torrentSource.filter, - } - : undefined, - torrentTag: ctrl.facets.torrentTag.active - ? { - aggregate: true, - filter: ctrl.facets.torrentTag.filter, - } - : undefined, - videoResolution: ctrl.facets.videoResolution.active - ? { - aggregate: true, - filter: ctrl.facets.videoResolution.filter, - } - : undefined, - videoSource: ctrl.facets.videoSource.active - ? { - aggregate: true, - filter: ctrl.facets.videoSource.filter, - } - : undefined, - }, - }, -}); + facets, + }; + + if (ctrl.publishedAt) { + facets.publishedAt = ctrl.publishedAt; + } + + return { + input: inputObject, + }; +}; export const inactiveFacet = { active: false, @@ -326,6 +339,14 @@ export class TorrentsSearchController { page: event.page, })); } + + setPublishedAt(timeFrame?: string) { + this.update((ctrl) => ({ + ...ctrl, + page: 1, + publishedAt: timeFrame || undefined, + })); + } } export type FacetDefinition = { diff --git a/webui/src/styles.scss b/webui/src/styles.scss index 996ce133..499968ec 100644 --- a/webui/src/styles.scss +++ b/webui/src/styles.scss @@ -141,3 +141,24 @@ mat-drawer-content { overflow: visible; padding-bottom: 20px; } + +/* Date picker custom styles for time-frame-selector */ +.today-date { + background-color: rgba(103, 58, 183, 0.2); + border-radius: 50%; +} + +.comparison-date { + background-color: rgba(103, 58, 183, 0.05); +} + +/* Active selected date in date picker */ +.mat-calendar-body-selected { + background-color: #673ab7 !important; + color: white !important; +} + +/* Date range selection highlight in datepicker */ +.mat-calendar-body-in-range::before { + background: rgba(103, 58, 183, 0.2); +}