snapshot of https://github.com/traggo/server.git (master, 2026-09-16; blobs > 131072B omitted)

dashboard/entry/add.go

@@ -0,0 +1,77 @@
+package entry
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"strings"
+
+	"github.com/traggo/server/time"
+
+	"github.com/traggo/server/dashboard/convert"
+	"github.com/traggo/server/dashboard/util"
+
+	"github.com/traggo/server/auth"
+	"github.com/traggo/server/generated/gqlmodel"
+	"github.com/traggo/server/model"
+)
+
+// AddDashboardEntry adds a dashboard entry.
+func (r *ResolverForEntry) AddDashboardEntry(ctx context.Context, dashboardID int, entryType gqlmodel.EntryType, title string, total bool, stats gqlmodel.InputStatsSelection, pos *gqlmodel.InputResponsiveDashboardEntryPos) (*gqlmodel.DashboardEntry, error) {
+	userID := auth.GetUser(ctx).ID
+
+	if _, err := util.FindDashboard(r.DB, userID, dashboardID); err != nil {
+		return nil, err
+	}
+
+	tagFilters := convert.TagFiltersToInternal(stats.ExcludeTags, false)
+	tagFilters = append(tagFilters, convert.TagFiltersToInternal(stats.IncludeTags, true)...)
+
+	if err := tagsDuplicates(tagFilters); err != nil {
+		return nil, err
+	}
+
+	entry := model.DashboardEntry{
+		Keys:            strings.Join(stats.Tags, ","),
+		Type:            convert.InternalEntryType(entryType),
+		Title:           title,
+		Total:           total,
+		DashboardID:     dashboardID,
+		Interval:        convert.InternalInterval(stats.Interval),
+		MobilePosition:  convert.EmptyPos(),
+		DesktopPosition: convert.EmptyPos(),
+		RangeID:         -1,
+		TagFilters:      tagFilters,
+	}
+
+	if len(stats.Tags) == 0 {
+		return nil, errors.New("at least one tag is required")
+	}
+
+	if err := convert.ApplyPos(&entry, pos); err != nil {
+		return &gqlmodel.DashboardEntry{}, err
+	}
+
+	if stats.RangeID != nil {
+		if _, err := util.FindDashboardRange(r.DB, *stats.RangeID); err != nil {
+			return nil, err
+		}
+		entry.RangeID = *stats.RangeID
+	} else if stats.Range != nil {
+		entry.RangeID = model.NoRangeIDDefined
+		if err := time.Validate(stats.Range.From); err != nil {
+			return nil, fmt.Errorf("range from (%s) invalid: %s", stats.Range.From, err)
+		}
+		if err := time.Validate(stats.Range.To); err != nil {
+			return nil, fmt.Errorf("range to (%s) invalid: %s", stats.Range.To, err)
+		}
+		entry.RangeFrom = stats.Range.From
+		entry.RangeTo = stats.Range.To
+	}
+
+	if err := r.DB.Save(&entry).Error; err != nil {
+		return nil, err
+	}
+
+	return convert.ToExternalEntry(entry)
+}

dashboard/entry/dbentryresolver.go

@@ -0,0 +1,8 @@
+package entry
+
+import "github.com/jinzhu/gorm"
+
+// ResolverForEntry resolves dashboard entry things.
+type ResolverForEntry struct {
+	DB *gorm.DB
+}

dashboard/entry/entries_test.go

@@ -0,0 +1,526 @@
+package entry_test
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"github.com/traggo/server/dashboard"
+	"github.com/traggo/server/generated/gqlmodel"
+	"github.com/traggo/server/test"
+	"github.com/traggo/server/test/fake"
+)
+
+func TestEntries(t *testing.T) {
+	db := test.InMemoryDB(t)
+	defer db.Close()
+	var bVal bool
+
+	resolver := dashboard.NewResolverForDashboard(db.DB)
+
+	// initial no dashboards
+	user1 := fake.User(1)
+	user2 := fake.User(2)
+	db.User(1)
+	db.User(2)
+	dashboards, err := resolver.Dashboards(user1)
+	require.NoError(t, err)
+	require.Empty(t, dashboards)
+
+	dashboard, err := resolver.CreateDashboard(user1, "cool dashboard")
+	require.NoError(t, err)
+	expectAdded := &gqlmodel.Dashboard{
+		ID:     1,
+		Name:   "cool dashboard",
+		Ranges: []*gqlmodel.NamedDateRange{},
+		Items:  []*gqlmodel.DashboardEntry{},
+	}
+	require.Equal(t, expectAdded, dashboard)
+
+	_, err = resolver.AddDashboardEntry(user1, 5, gqlmodel.EntryTypeBarChart, "test", false, gqlmodel.InputStatsSelection{
+		Interval:    "",
+		Tags:        []string{"hhol"},
+		ExcludeTags: nil,
+		IncludeTags: nil,
+		RangeID:     nil,
+		Range: &gqlmodel.InputRelativeOrStaticRange{
+			From: "now-1d",
+			To:   "now-2d",
+		},
+	}, nil)
+	require.EqualError(t, err, "dashboard does not exist")
+	_, err = resolver.AddDashboardEntry(user1, 1, gqlmodel.EntryTypeBarChart, "test", false, gqlmodel.InputStatsSelection{
+		Interval:    gqlmodel.StatsIntervalHourly,
+		Tags:        []string{"hhol"},
+		ExcludeTags: nil,
+		IncludeTags: nil,
+		RangeID:     p(55),
+		Range: &gqlmodel.InputRelativeOrStaticRange{
+			From: "now-1d",
+			To:   "now-2d",
+		},
+	}, nil)
+	require.EqualError(t, err, "dashboard range does not exist")
+	_, err = resolver.AddDashboardEntry(user2, 1, gqlmodel.EntryTypeBarChart, "test", false, gqlmodel.InputStatsSelection{
+		Interval:    "doubly",
+		Tags:        []string{"hhol"},
+		ExcludeTags: nil,
+		IncludeTags: nil,
+		RangeID:     nil,
+		Range: &gqlmodel.InputRelativeOrStaticRange{
+			From: "",
+			To:   "",
+		},
+	}, nil)
+	require.EqualError(t, err, "dashboard does not exist")
+	_, err = resolver.AddDashboardEntry(user1, 1, gqlmodel.EntryTypeBarChart, "test", false, gqlmodel.InputStatsSelection{
+		Interval:    gqlmodel.StatsIntervalDaily,
+		Tags:        []string{"hhol"},
+		ExcludeTags: nil,
+		IncludeTags: nil,
+		RangeID:     nil,
+		Range: &gqlmodel.InputRelativeOrStaticRange{
+			From: "now-2d",
+			To:   "now-2",
+		},
+	}, nil)
+	require.EqualError(t, err, "range to (now-2) invalid: expected unit at the end but got nothing")
+	_, err = resolver.AddDashboardEntry(user1, 1, gqlmodel.EntryTypeBarChart, "test", false, gqlmodel.InputStatsSelection{
+		Interval:    gqlmodel.StatsIntervalDaily,
+		Tags:        []string{"hhol"},
+		ExcludeTags: nil,
+		IncludeTags: nil,
+		RangeID:     nil,
+		Range: &gqlmodel.InputRelativeOrStaticRange{
+			From: "now-2",
+			To:   "now-2d",
+		},
+	}, nil)
+	require.EqualError(t, err, "range from (now-2) invalid: expected unit at the end but got nothing")
+	_, err = resolver.AddDashboardEntry(user1, 1, gqlmodel.EntryTypeBarChart, "test", false, gqlmodel.InputStatsSelection{
+		Interval:    gqlmodel.StatsIntervalDaily,
+		Tags:        []string{},
+		ExcludeTags: nil,
+		IncludeTags: nil,
+		RangeID:     nil,
+		Range: &gqlmodel.InputRelativeOrStaticRange{
+			From: "now-2d",
+			To:   "now-2d",
+		},
+	}, nil)
+	require.EqualError(t, err, "at least one tag is required")
+
+	entry, err := resolver.AddDashboardEntry(user1, 1, gqlmodel.EntryTypeBarChart, "test", false, gqlmodel.InputStatsSelection{
+		Interval:    gqlmodel.StatsIntervalDaily,
+		Tags:        []string{"abc"},
+		ExcludeTags: nil,
+		IncludeTags: nil,
+		RangeID:     nil,
+		Range: &gqlmodel.InputRelativeOrStaticRange{
+			From: "now-2d",
+			To:   "now-5d",
+		},
+	}, &gqlmodel.InputResponsiveDashboardEntryPos{Desktop: &gqlmodel.InputDashboardEntryPos{
+		H: 1,
+		W: 2,
+		X: 1,
+		Y: 3,
+	}})
+	require.NoError(t, err)
+	expectedEntry := &gqlmodel.DashboardEntry{
+		ID:    1,
+		Title: "test",
+		Total: false,
+		StatsSelection: &gqlmodel.StatsSelection{
+			Interval:    gqlmodel.StatsIntervalDaily,
+			Tags:        []string{"abc"},
+			ExcludeTags: nil,
+			IncludeTags: nil,
+			RangeID:     nil,
+			Range: &gqlmodel.RelativeOrStaticRange{
+				From: "now-2d",
+				To:   "now-5d",
+			},
+		},
+		Pos: &gqlmodel.ResponsiveDashboardEntryPos{
+			Desktop: &gqlmodel.DashboardEntryPos{
+				W:    2,
+				H:    3,
+				X:    1,
+				Y:    3,
+				MinW: 2,
+				MinH: 3,
+			},
+			Mobile: &gqlmodel.DashboardEntryPos{
+				W:    1,
+				H:    2,
+				X:    0,
+				Y:    0,
+				MinW: 1,
+				MinH: 2,
+			},
+		},
+		EntryType: gqlmodel.EntryTypeBarChart,
+	}
+	require.Equal(t, expectedEntry, entry)
+
+	dashboards, err = resolver.Dashboards(user1)
+	require.NoError(t, err)
+	require.Equal(t, dashboards[0].Items, []*gqlmodel.DashboardEntry{expectedEntry})
+	xrange, err := resolver.AddDashboardRange(user1, 1, gqlmodel.InputNamedDateRange{
+		Name:     "range",
+		Editable: false,
+		Range: &gqlmodel.InputRelativeOrStaticRange{
+			From: "now-1d",
+			To:   "now",
+		},
+	})
+	require.NoError(t, err)
+	_, err = resolver.AddDashboardEntry(user1, 1, gqlmodel.EntryTypeBarChart, "other", false, gqlmodel.InputStatsSelection{
+		Interval: gqlmodel.StatsIntervalDaily,
+		Tags:     []string{"abc"},
+		RangeID:  p(xrange.ID),
+	}, &gqlmodel.InputResponsiveDashboardEntryPos{Desktop: &gqlmodel.InputDashboardEntryPos{
+		H: 1,
+		W: 2,
+		X: 1,
+		Y: 3,
+	}})
+	require.NoError(t, err)
+	_, err = resolver.RemoveDashboardRange(user1, xrange.ID)
+	require.EqualError(t, err, "range is used in entries: other")
+
+	chart := gqlmodel.EntryTypePieChart
+	_, err = resolver.UpdateDashboardEntry(user2, 1, &chart, nil, nil, nil, nil)
+	require.EqualError(t, err, "dashboard does not exist")
+	_, err = resolver.UpdateDashboardEntry(user1, 3, &chart, nil, nil, nil, nil)
+	require.EqualError(t, err, "entry does not exist")
+	_, err = resolver.UpdateDashboardEntry(user1, 1, &chart, s("cool title"), &bVal, &gqlmodel.InputStatsSelection{
+		Interval:    gqlmodel.StatsIntervalDaily,
+		Tags:        []string{"kek"},
+		ExcludeTags: nil,
+		IncludeTags: nil,
+		RangeID:     nil,
+		Range: &gqlmodel.InputRelativeOrStaticRange{
+			From: "now-2",
+			To:   "now-5d",
+		},
+	}, nil)
+	require.EqualError(t, err, "range from (now-2) invalid: expected unit at the end but got nothing")
+	_, err = resolver.UpdateDashboardEntry(user1, 1, &chart, s("cool title"), &bVal, &gqlmodel.InputStatsSelection{
+		Interval:    gqlmodel.StatsIntervalDaily,
+		Tags:        []string{"kek"},
+		ExcludeTags: nil,
+		IncludeTags: nil,
+		RangeID:     nil,
+		Range: &gqlmodel.InputRelativeOrStaticRange{
+			From: "now-2d",
+			To:   "now-5",
+		},
+	}, nil)
+	require.EqualError(t, err, "range to (now-5) invalid: expected unit at the end but got nothing")
+	dashboards, err = resolver.Dashboards(user1)
+	require.NoError(t, err)
+	require.Equal(t, []*gqlmodel.DashboardEntry{
+		{
+			ID:    1,
+			Title: "test",
+			Total: false,
+			StatsSelection: &gqlmodel.StatsSelection{
+				Interval:    gqlmodel.StatsIntervalDaily,
+				Tags:        []string{"abc"},
+				ExcludeTags: nil,
+				IncludeTags: nil,
+				RangeID:     nil,
+				Range: &gqlmodel.RelativeOrStaticRange{
+					From: "now-2d",
+					To:   "now-5d",
+				},
+			},
+			Pos: &gqlmodel.ResponsiveDashboardEntryPos{
+				Desktop: &gqlmodel.DashboardEntryPos{
+					W:    2,
+					H:    3,
+					X:    1,
+					Y:    3,
+					MinW: 2,
+					MinH: 3,
+				},
+				Mobile: &gqlmodel.DashboardEntryPos{
+					W:    1,
+					H:    2,
+					X:    0,
+					Y:    0,
+					MinW: 1,
+					MinH: 2,
+				},
+			},
+			EntryType: gqlmodel.EntryTypeBarChart,
+		},
+		{
+			ID:    2,
+			Title: "other",
+			Total: false,
+			StatsSelection: &gqlmodel.StatsSelection{
+				Interval:    gqlmodel.StatsIntervalDaily,
+				Tags:        []string{"abc"},
+				ExcludeTags: nil,
+				IncludeTags: nil,
+				RangeID:     p(1),
+			},
+			Pos: &gqlmodel.ResponsiveDashboardEntryPos{
+				Desktop: &gqlmodel.DashboardEntryPos{
+					W:    2,
+					H:    3,
+					X:    1,
+					Y:    3,
+					MinW: 2,
+					MinH: 3,
+				},
+				Mobile: &gqlmodel.DashboardEntryPos{
+					W:    1,
+					H:    2,
+					X:    0,
+					Y:    0,
+					MinW: 1,
+					MinH: 2,
+				},
+			},
+			EntryType: gqlmodel.EntryTypeBarChart,
+		},
+	}, dashboards[0].Items)
+	_, err = resolver.UpdateDashboardEntry(user1, 1, &chart, s("cool title"), &bVal, &gqlmodel.InputStatsSelection{
+		Interval:    gqlmodel.StatsIntervalDaily,
+		Tags:        []string{"kek"},
+		ExcludeTags: nil,
+		IncludeTags: nil,
+		RangeID:     nil,
+		Range: &gqlmodel.InputRelativeOrStaticRange{
+			From: "now-2d",
+			To:   "now-12d",
+		},
+	}, &gqlmodel.InputResponsiveDashboardEntryPos{Desktop: &gqlmodel.InputDashboardEntryPos{
+		H: 1,
+		W: 2,
+		X: 1,
+		Y: 3,
+	}})
+	require.NoError(t, err)
+
+	dashboards, err = resolver.Dashboards(user1)
+	require.NoError(t, err)
+	require.Equal(t, []*gqlmodel.DashboardEntry{
+		{
+			ID:    1,
+			Title: "cool title",
+			Total: false,
+			StatsSelection: &gqlmodel.StatsSelection{
+				Interval:    gqlmodel.StatsIntervalDaily,
+				Tags:        []string{"kek"},
+				ExcludeTags: nil,
+				IncludeTags: nil,
+				RangeID:     nil,
+				Range: &gqlmodel.RelativeOrStaticRange{
+					From: "now-2d",
+					To:   "now-12d",
+				},
+			},
+			Pos: &gqlmodel.ResponsiveDashboardEntryPos{
+				Desktop: &gqlmodel.DashboardEntryPos{
+					W:    2,
+					H:    3,
+					X:    1,
+					Y:    3,
+					MinW: 2,
+					MinH: 3,
+				},
+				Mobile: &gqlmodel.DashboardEntryPos{
+					W:    1,
+					H:    2,
+					X:    0,
+					Y:    0,
+					MinW: 1,
+					MinH: 2,
+				},
+			},
+			EntryType: gqlmodel.EntryTypePieChart,
+		},
+		{
+			ID:    2,
+			Title: "other",
+			Total: false,
+			StatsSelection: &gqlmodel.StatsSelection{
+				Interval:    gqlmodel.StatsIntervalDaily,
+				Tags:        []string{"abc"},
+				ExcludeTags: nil,
+				IncludeTags: nil,
+				RangeID:     p(1),
+			},
+			Pos: &gqlmodel.ResponsiveDashboardEntryPos{
+				Desktop: &gqlmodel.DashboardEntryPos{
+					W:    2,
+					H:    3,
+					X:    1,
+					Y:    3,
+					MinW: 2,
+					MinH: 3,
+				},
+				Mobile: &gqlmodel.DashboardEntryPos{
+					W:    1,
+					H:    2,
+					X:    0,
+					Y:    0,
+					MinW: 1,
+					MinH: 2,
+				},
+			},
+			EntryType: gqlmodel.EntryTypeBarChart,
+		},
+	}, dashboards[0].Items)
+
+	_, err = resolver.UpdateDashboardEntry(user1, 1, &chart, s("cool title"), &bVal, &gqlmodel.InputStatsSelection{
+		Interval:    gqlmodel.StatsIntervalDaily,
+		Tags:        []string{"kek"},
+		ExcludeTags: nil,
+		IncludeTags: nil,
+		RangeID:     p(5),
+	}, &gqlmodel.InputResponsiveDashboardEntryPos{Desktop: &gqlmodel.InputDashboardEntryPos{
+		H: 1,
+		W: 2,
+		X: 1,
+		Y: 3,
+	}})
+	require.EqualError(t, err, "dashboard range does not exist")
+
+	_, err = resolver.UpdateDashboardEntry(user1, 1, &chart, s("cool title"), &bVal, &gqlmodel.InputStatsSelection{
+		Interval:    gqlmodel.StatsIntervalDaily,
+		Tags:        []string{"kek"},
+		ExcludeTags: nil,
+		IncludeTags: nil,
+		RangeID:     p(xrange.ID),
+	}, &gqlmodel.InputResponsiveDashboardEntryPos{Desktop: &gqlmodel.InputDashboardEntryPos{
+		H: 1,
+		W: 2,
+		X: 1,
+		Y: 3,
+	}})
+	require.NoError(t, err)
+
+	dashboards, err = resolver.Dashboards(user1)
+	require.NoError(t, err)
+	require.Equal(t, []*gqlmodel.DashboardEntry{
+		{
+			ID:    1,
+			Title: "cool title",
+			Total: false,
+			StatsSelection: &gqlmodel.StatsSelection{
+				Interval:    gqlmodel.StatsIntervalDaily,
+				Tags:        []string{"kek"},
+				ExcludeTags: nil,
+				IncludeTags: nil,
+				RangeID:     p(xrange.ID),
+			},
+			Pos: &gqlmodel.ResponsiveDashboardEntryPos{
+				Desktop: &gqlmodel.DashboardEntryPos{
+					W:    2,
+					H:    3,
+					X:    1,
+					Y:    3,
+					MinW: 2,
+					MinH: 3,
+				},
+				Mobile: &gqlmodel.DashboardEntryPos{
+					W:    1,
+					H:    2,
+					X:    0,
+					Y:    0,
+					MinW: 1,
+					MinH: 2,
+				},
+			},
+			EntryType: gqlmodel.EntryTypePieChart,
+		},
+		{
+			ID:    2,
+			Title: "other",
+			Total: false,
+			StatsSelection: &gqlmodel.StatsSelection{
+				Interval:    gqlmodel.StatsIntervalDaily,
+				Tags:        []string{"abc"},
+				ExcludeTags: nil,
+				IncludeTags: nil,
+				RangeID:     p(1),
+			},
+			Pos: &gqlmodel.ResponsiveDashboardEntryPos{
+				Desktop: &gqlmodel.DashboardEntryPos{
+					W:    2,
+					H:    3,
+					X:    1,
+					Y:    3,
+					MinW: 2,
+					MinH: 3,
+				},
+				Mobile: &gqlmodel.DashboardEntryPos{
+					W:    1,
+					H:    2,
+					X:    0,
+					Y:    0,
+					MinW: 1,
+					MinH: 2,
+				},
+			},
+			EntryType: gqlmodel.EntryTypeBarChart,
+		},
+	}, dashboards[0].Items)
+
+	_, err = resolver.RemoveDashboardEntry(user2, 1)
+	require.EqualError(t, err, "dashboard does not exist")
+
+	_, err = resolver.RemoveDashboardEntry(user1, 55)
+	require.EqualError(t, err, "entry does not exist")
+
+	_, err = resolver.RemoveDashboardEntry(user1, 1)
+	require.NoError(t, err)
+
+	dashboards, err = resolver.Dashboards(user1)
+	require.NoError(t, err)
+	require.Equal(t, []*gqlmodel.DashboardEntry{
+		{
+			ID:    2,
+			Title: "other",
+			Total: false,
+			StatsSelection: &gqlmodel.StatsSelection{
+				Interval:    gqlmodel.StatsIntervalDaily,
+				Tags:        []string{"abc"},
+				ExcludeTags: nil,
+				IncludeTags: nil,
+				RangeID:     p(1),
+			},
+			Pos: &gqlmodel.ResponsiveDashboardEntryPos{
+				Desktop: &gqlmodel.DashboardEntryPos{
+					W:    2,
+					H:    3,
+					X:    1,
+					Y:    3,
+					MinW: 2,
+					MinH: 3,
+				},
+				Mobile: &gqlmodel.DashboardEntryPos{
+					W:    1,
+					H:    2,
+					X:    0,
+					Y:    0,
+					MinW: 1,
+					MinH: 2,
+				},
+			},
+			EntryType: gqlmodel.EntryTypeBarChart,
+		},
+	}, dashboards[0].Items)
+}
+
+func p(i int) *int {
+	return &i
+}
+func s(s string) *string {
+	return &s
+}

dashboard/entry/remove.go

@@ -0,0 +1,34 @@
+package entry
+
+import (
+	"context"
+
+	"github.com/traggo/server/dashboard/convert"
+	"github.com/traggo/server/dashboard/util"
+
+	"github.com/traggo/server/auth"
+	"github.com/traggo/server/generated/gqlmodel"
+	"github.com/traggo/server/model"
+)
+
+// RemoveDashboardEntry removes a dashboard entry.
+func (r *ResolverForEntry) RemoveDashboardEntry(ctx context.Context, id int) (*gqlmodel.DashboardEntry, error) {
+
+	userID := auth.GetUser(ctx).ID
+
+	entry, err := util.FindDashboardEntry(r.DB, id)
+	if err != nil {
+		return nil, err
+	}
+
+	if _, err := util.FindDashboard(r.DB, userID, entry.DashboardID); err != nil {
+		return nil, err
+	}
+
+	remove := r.DB.Delete(&model.DashboardEntry{}, id)
+	if remove.Error != nil {
+		return &gqlmodel.DashboardEntry{}, remove.Error
+	}
+
+	return convert.ToExternalEntry(entry)
+}

dashboard/entry/tagcheck.go

@@ -0,0 +1,33 @@
+package entry
+
+import (
+	"fmt"
+
+	"github.com/traggo/server/model"
+)
+
+func tagsDuplicates(tags []model.DashboardTagFilter) error {
+	existingTags := make(map[model.DashboardTagFilter]struct{})
+
+	for _, tag := range tags {
+		if _, ok := existingTags[tag]; ok {
+			tagType := "exclude"
+			if tag.Include {
+				tagType = "include"
+			}
+
+			return fmt.Errorf("%s tags: tag '%s' is present multiple times", tagType, tag.Key+":"+tag.StringValue)
+		} else {
+			copyTag := tag
+			copyTag.Include = !copyTag.Include
+
+			if _, ok := existingTags[copyTag]; ok {
+				return fmt.Errorf("tag '%s' is present in both exclude tags and include tags", tag.Key+":"+tag.StringValue)
+			}
+		}
+
+		existingTags[tag] = struct{}{}
+	}
+
+	return nil
+}

dashboard/entry/update.go

@@ -0,0 +1,104 @@
+package entry
+
+import (
+	"context"
+	"fmt"
+	"strings"
+
+	"github.com/traggo/server/time"
+
+	"github.com/traggo/server/model"
+
+	"github.com/traggo/server/auth"
+	"github.com/traggo/server/dashboard/convert"
+	"github.com/traggo/server/dashboard/util"
+	"github.com/traggo/server/generated/gqlmodel"
+)
+
+// UpdateDashboardEntry updates a dashboard entry.
+func (r *ResolverForEntry) UpdateDashboardEntry(ctx context.Context, id int, entryType *gqlmodel.EntryType, title *string, total *bool, stats *gqlmodel.InputStatsSelection, pos *gqlmodel.InputResponsiveDashboardEntryPos) (*gqlmodel.DashboardEntry, error) {
+	userID := auth.GetUser(ctx).ID
+
+	entry, err := util.FindDashboardEntry(r.DB, id)
+	if err != nil {
+		return nil, err
+	}
+
+	if _, err := util.FindDashboard(r.DB, userID, entry.DashboardID); err != nil {
+		return nil, err
+	}
+
+	if title != nil {
+		entry.Title = *title
+	}
+
+	if total != nil {
+		entry.Total = *total
+	}
+
+	tx := r.DB.Begin()
+	if err := tx.Error; err != nil {
+		return nil, err
+	}
+	defer func() {
+		if r := recover(); r != nil {
+			tx.Rollback()
+			panic(r)
+		} else if tx != nil {
+			tx.Rollback()
+		}
+	}()
+
+	if stats != nil {
+		if stats.RangeID != nil {
+			if _, err := util.FindDashboardRange(tx, *stats.RangeID); err != nil {
+				return nil, err
+			}
+			entry.RangeID = *stats.RangeID
+		} else if stats.Range != nil {
+			entry.RangeID = model.NoRangeIDDefined
+			if err := time.Validate(stats.Range.From); err != nil {
+				return nil, fmt.Errorf("range from (%s) invalid: %s", stats.Range.From, err)
+			}
+			if err := time.Validate(stats.Range.To); err != nil {
+				return nil, fmt.Errorf("range to (%s) invalid: %s", stats.Range.To, err)
+			}
+			entry.RangeFrom = stats.Range.From
+			entry.RangeTo = stats.Range.To
+		}
+
+		tagFilters := convert.TagFiltersToInternal(stats.ExcludeTags, false)
+		tagFilters = append(tagFilters, convert.TagFiltersToInternal(stats.IncludeTags, true)...)
+
+		if err := tagsDuplicates(tagFilters); err != nil {
+			return nil, err
+		}
+
+		if err := tx.Where("dashboard_entry_id = ?", id).Delete(new(model.DashboardTagFilter)).Error; err != nil {
+			return nil, fmt.Errorf("failed to update tag filters: %s", err)
+		}
+
+		entry.TagFilters = tagFilters
+		entry.Keys = strings.Join(stats.Tags, ",")
+		entry.Interval = convert.InternalInterval(stats.Interval)
+	}
+
+	if entryType != nil {
+		entry.Type = convert.InternalEntryType(*entryType)
+	}
+
+	if err := convert.ApplyPos(&entry, pos); err != nil {
+		return &gqlmodel.DashboardEntry{}, err
+	}
+
+	if err := tx.Save(entry).Error; err != nil {
+		return nil, err
+	}
+
+	if err := tx.Commit().Error; err != nil {
+		return nil, err
+	}
+
+	tx = nil
+	return convert.ToExternalEntry(entry)
+}