dashboard/app: propagate period type generating series

2 files changed, 37 insertions, 25 deletions

diff --git a/pkg/coveragedb/time_period.go b/pkg/coveragedb/time_period.go
index 9503cf3e1..9af61d1a8 100644
--- a/pkg/coveragedb/time_period.go
+++ b/pkg/coveragedb/time_period.go
@@ -28,7 +28,7 @@ func MakeTimePeriod(targetDate civil.Date, periodType string) (TimePeriod, error
 	if err != nil {
 		return TimePeriod{}, err
 	}
-	tp := TimePeriod{DateTo: targetDate, Days: pOps.PointedPeriodDays(targetDate), Type: periodType}
+	tp := TimePeriod{DateTo: targetDate, Days: pOps.pointedPeriodDays(targetDate), Type: periodType}
 	if !pOps.IsValidPeriod(tp) {
 		return TimePeriod{}, fmt.Errorf("date %s doesn't point the period(%s) end", targetDate.String(), periodType)
 	}
@@ -72,18 +72,22 @@ func PeriodOps(periodType string) (periodOps, error) {
 type periodOps interface {
 	IsValidPeriod(p TimePeriod) bool
 	lastPeriodDate(d civil.Date) civil.Date
-	PointedPeriodDays(d civil.Date) int
+	pointedPeriodDays(d civil.Date) int
 }
 
-func GenNPeriodsTill(n int, d civil.Date, po periodOps) []TimePeriod {
+func GenNPeriodsTill(n int, d civil.Date, periodType string) ([]TimePeriod, error) {
+	pOps, err := PeriodOps(periodType)
+	if err != nil {
+		return nil, err
+	}
 	var res []TimePeriod
 	for i := 0; i < n; i++ {
-		d = po.lastPeriodDate(d)
-		res = append(res, TimePeriod{DateTo: d, Days: po.PointedPeriodDays(d)})
-		d = d.AddDays(-po.PointedPeriodDays(d))
+		d = pOps.lastPeriodDate(d)
+		res = append(res, TimePeriod{DateTo: d, Days: pOps.pointedPeriodDays(d), Type: periodType})
+		d = d.AddDays(-pOps.pointedPeriodDays(d))
 	}
 	slices.Reverse(res)
-	return res
+	return res, nil
 }
 
 type DayPeriodOps struct{}
@@ -96,7 +100,7 @@ func (dpo *DayPeriodOps) IsValidPeriod(p TimePeriod) bool {
 	return p.Days == 1
 }
 
-func (dpo *DayPeriodOps) PointedPeriodDays(d civil.Date) int {
+func (dpo *DayPeriodOps) pointedPeriodDays(d civil.Date) int {
 	return 1
 }
 
@@ -114,7 +118,7 @@ func (m *MonthPeriodOps) IsValidPeriod(p TimePeriod) bool {
 	return lmd == p.DateTo && p.Days == lmd.Day
 }
 
-func (m *MonthPeriodOps) PointedPeriodDays(d civil.Date) int {
+func (m *MonthPeriodOps) pointedPeriodDays(d civil.Date) int {
 	return m.lastPeriodDate(d).Day
 }
 
@@ -122,7 +126,7 @@ type QuarterPeriodOps struct{}
 
 func (q *QuarterPeriodOps) IsValidPeriod(p TimePeriod) bool {
 	lmd := q.lastPeriodDate(p.DateTo)
-	return lmd == p.DateTo && p.Days == q.PointedPeriodDays(lmd)
+	return lmd == p.DateTo && p.Days == q.pointedPeriodDays(lmd)
 }
 
 func (q *QuarterPeriodOps) lastPeriodDate(d civil.Date) civil.Date {
@@ -131,12 +135,12 @@ func (q *QuarterPeriodOps) lastPeriodDate(d civil.Date) civil.Date {
 	return (&MonthPeriodOps{}).lastPeriodDate(d)
 }
 
-func (q *QuarterPeriodOps) PointedPeriodDays(d civil.Date) int {
+func (q *QuarterPeriodOps) pointedPeriodDays(d civil.Date) int {
 	d = q.lastPeriodDate(d)
 	d.Day = 1
 	res := 0
 	for i := 0; i < 3; i++ {
-		res += (&MonthPeriodOps{}).PointedPeriodDays(d)
+		res += (&MonthPeriodOps{}).pointedPeriodDays(d)
 		d.Month--
 	}
 	return res
@@ -160,7 +164,7 @@ func PeriodsToMerge(srcDates, mergedPeriods []TimePeriod, srcRows, mergedRows []
 	periods := []TimePeriod{}
 	for periodEndDate := range periodRows {
 		periods = append(periods,
-			TimePeriod{DateTo: periodEndDate, Days: ops.PointedPeriodDays(periodEndDate)})
+			TimePeriod{DateTo: periodEndDate, Days: ops.pointedPeriodDays(periodEndDate)})
 	}
 	sort.Slice(periods, func(i, j int) bool {
 		return periods[i].DateTo.After(periods[j].DateTo)
diff --git a/pkg/coveragedb/time_period_test.go b/pkg/coveragedb/time_period_test.go
index e985b162a..eead66023 100644
--- a/pkg/coveragedb/time_period_test.go
+++ b/pkg/coveragedb/time_period_test.go
@@ -22,13 +22,15 @@ func TestDayPeriodOps(t *testing.T) {
 	assert.True(t, ops.IsValidPeriod(goodPeriod))
 	assert.False(t, ops.IsValidPeriod(badPeriod))
 
-	assert.Equal(t, 1, ops.PointedPeriodDays(d))
+	assert.Equal(t, 1, ops.pointedPeriodDays(d))
 
+	periods, err := GenNPeriodsTill(2, d, DayPeriod)
+	assert.NoError(t, err)
 	assert.Equal(t,
 		[]TimePeriod{
-			{DateTo: civil.Date{Year: 2024, Month: time.February, Day: 19}, Days: 1},
-			{DateTo: civil.Date{Year: 2024, Month: time.February, Day: 20}, Days: 1}},
-		GenNPeriodsTill(2, d, ops))
+			{DateTo: civil.Date{Year: 2024, Month: time.February, Day: 19}, Days: 1, Type: DayPeriod},
+			{DateTo: civil.Date{Year: 2024, Month: time.February, Day: 20}, Days: 1, Type: DayPeriod}},
+		periods)
 }
 
 func TestMonthPeriodOps(t *testing.T) {
@@ -47,13 +49,16 @@ func TestMonthPeriodOps(t *testing.T) {
 	assert.False(t, ops.IsValidPeriod(badPeriod1))
 	assert.False(t, ops.IsValidPeriod(badPeriod2))
 
-	assert.Equal(t, 29, ops.PointedPeriodDays(midMonthDate))
+	assert.Equal(t, 29, ops.pointedPeriodDays(midMonthDate))
 
+	periods, err := GenNPeriodsTill(2, goodPeriod.DateTo, MonthPeriod)
+	assert.NoError(t, err)
 	assert.Equal(t,
 		[]TimePeriod{
-			{DateTo: civil.Date{Year: 2024, Month: time.January, Day: 31}, Days: 31},
-			{DateTo: civil.Date{Year: 2024, Month: time.February, Day: 29}, Days: 29}},
-		GenNPeriodsTill(2, goodPeriod.DateTo, ops))
+			{DateTo: civil.Date{Year: 2024, Month: time.January, Day: 31}, Days: 31, Type: MonthPeriod},
+			{DateTo: civil.Date{Year: 2024, Month: time.February, Day: 29}, Days: 29, Type: MonthPeriod}},
+		periods,
+	)
 }
 
 func TestQuarterPeriodOps(t *testing.T) {
@@ -73,13 +78,16 @@ func TestQuarterPeriodOps(t *testing.T) {
 	assert.False(t, ops.IsValidPeriod(badPeriod1))
 	assert.False(t, ops.IsValidPeriod(badPeriod2))
 
-	assert.Equal(t, 31+29+31, ops.PointedPeriodDays(midQuarterDate))
+	assert.Equal(t, 31+29+31, ops.pointedPeriodDays(midQuarterDate))
 
+	periods, err := GenNPeriodsTill(2, goodPeriod.DateTo, QuarterPeriod)
+	assert.NoError(t, err)
 	assert.Equal(t,
 		[]TimePeriod{
-			{DateTo: civil.Date{Year: 2023, Month: time.December, Day: 31}, Days: 31 + 30 + 31},
-			{DateTo: civil.Date{Year: 2024, Month: time.March, Day: 31}, Days: 31 + 29 + 31}},
-		GenNPeriodsTill(2, goodPeriod.DateTo, ops))
+			{DateTo: civil.Date{Year: 2023, Month: time.December, Day: 31}, Days: 31 + 30 + 31, Type: QuarterPeriod},
+			{DateTo: civil.Date{Year: 2024, Month: time.March, Day: 31}, Days: 31 + 29 + 31, Type: QuarterPeriod}},
+		periods,
+	)
 }
 
 func TestPeriodsToMerge(t *testing.T) {