Add support for storing filters in dashboard entries

dashboard/convert/dashboardtag.go

@@ -0,0 +1,58 @@
+package convert
+
+import (
+	"github.com/traggo/server/generated/gqlmodel"
+	"github.com/traggo/server/model"
+)
+
+func excludedTagsToExternal(tags []model.DashboardExcludedTag) []*gqlmodel.TimeSpanTag {
+	result := []*gqlmodel.TimeSpanTag{}
+	for _, tag := range tags {
+		result = append(result, &gqlmodel.TimeSpanTag{
+			Key:   tag.Key,
+			Value: tag.StringValue,
+		})
+	}
+	return result
+}
+
+func ExcludedTagsToInternal(gqls []*gqlmodel.InputTimeSpanTag) []model.DashboardExcludedTag {
+	result := make([]model.DashboardExcludedTag, 0)
+	for _, tag := range gqls {
+		result = append(result, excludedTagToInternal(*tag))
+	}
+	return result
+}
+
+func excludedTagToInternal(gqls gqlmodel.InputTimeSpanTag) model.DashboardExcludedTag {
+	return model.DashboardExcludedTag{
+		Key:         gqls.Key,
+		StringValue: gqls.Value,
+	}
+}
+
+func includedTagsToExternal(tags []model.DashboardIncludedTag) []*gqlmodel.TimeSpanTag {
+	result := []*gqlmodel.TimeSpanTag{}
+	for _, tag := range tags {
+		result = append(result, &gqlmodel.TimeSpanTag{
+			Key:   tag.Key,
+			Value: tag.StringValue,
+		})
+	}
+	return result
+}
+
+func IncludedTagsToInternal(gqls []*gqlmodel.InputTimeSpanTag) []model.DashboardIncludedTag {
+	result := make([]model.DashboardIncludedTag, 0)
+	for _, tag := range gqls {
+		result = append(result, includedTagToInternal(*tag))
+	}
+	return result
+}
+
+func includedTagToInternal(gqls gqlmodel.InputTimeSpanTag) model.DashboardIncludedTag {
+	return model.DashboardIncludedTag{
+		Key:         gqls.Key,
+		StringValue: gqls.Value,
+	}
+}

dashboard/convert/entry.go

@@ -38,9 +38,11 @@ func ToExternalEntry(entry model.DashboardEntry) (*gqlmodel.DashboardEntry, erro
 		To:   entry.RangeTo,
 	}
 	stats := &gqlmodel.StatsSelection{
-		Interval: ExternalInterval(entry.Interval),
-		Tags:     strings.Split(entry.Keys, ","),
-		Range:    dateRange,
+		Interval:    ExternalInterval(entry.Interval),
+		Tags:        strings.Split(entry.Keys, ","),
+		Range:       dateRange,
+		ExcludeTags: excludedTagsToExternal(entry.ExcludedTags),
+		IncludeTags: includedTagsToExternal(entry.IncludedTags),
 	}
 	if entry.RangeID != model.NoRangeIDDefined {
 		stats.RangeID = &entry.RangeID

dashboard/entry/add.go

@@ -24,6 +24,18 @@ func (r *ResolverForEntry) AddDashboardEntry(ctx context.Context, dashboardID in
 		return nil, err
 	}
 
+	if tag := tagsDuplicates(stats.ExcludeTags, stats.IncludeTags); tag != nil {
+		return nil, fmt.Errorf("tag '%s' is present in both exclude tags and include tags", tag.Key+":"+tag.Value)
+	}
+
+	if err := tagsExist(r.DB, auth.GetUser(ctx).ID, stats.ExcludeTags); err != nil {
+		return nil, fmt.Errorf("exclude tags: %s", err.Error())
+	}
+
+	if err := tagsExist(r.DB, auth.GetUser(ctx).ID, stats.IncludeTags); err != nil {
+		return nil, fmt.Errorf("include tags: %s", err.Error())
+	}
+
 	entry := model.DashboardEntry{
 		Keys:            strings.Join(stats.Tags, ","),
 		Type:            convert.InternalEntryType(entryType),
@@ -34,6 +46,8 @@ func (r *ResolverForEntry) AddDashboardEntry(ctx context.Context, dashboardID in
 		MobilePosition:  convert.EmptyPos(),
 		DesktopPosition: convert.EmptyPos(),
 		RangeID:         -1,
+		ExcludedTags:    convert.ExcludedTagsToInternal(stats.ExcludeTags),
+		IncludedTags:    convert.IncludedTagsToInternal(stats.IncludeTags),
 	}
 
 	if len(stats.Tags) == 0 {

dashboard/entry/tagcheck.go

@@ -0,0 +1,43 @@
+package entry
+
+import (
+	"fmt"
+
+	"github.com/jinzhu/gorm"
+	"github.com/traggo/server/generated/gqlmodel"
+	"github.com/traggo/server/model"
+)
+
+func tagsDuplicates(src []*gqlmodel.InputTimeSpanTag, dst []*gqlmodel.InputTimeSpanTag) *gqlmodel.InputTimeSpanTag {
+	existingTags := make(map[string]struct{})
+	for _, tag := range src {
+		existingTags[tag.Key+":"+tag.Value] = struct{}{}
+	}
+
+	for _, tag := range dst {
+		if _, ok := existingTags[tag.Key+":"+tag.Value]; ok {
+			return tag
+		}
+
+		existingTags[tag.Key] = struct{}{}
+	}
+
+	return nil
+}
+
+func tagsExist(db *gorm.DB, userID int, tags []*gqlmodel.InputTimeSpanTag) error {
+	existingTags := make(map[string]struct{})
+
+	for _, tag := range tags {
+		if _, ok := existingTags[tag.Key]; ok {
+			return fmt.Errorf("tag '%s' is present multiple times", tag.Key)
+		}
+
+		if db.Where("key = ?", tag.Key).Where("user_id = ?", userID).Find(new(model.TagDefinition)).RecordNotFound() {
+			return fmt.Errorf("tag '%s' does not exist", tag.Key)
+		}
+
+		existingTags[tag.Key] = struct{}{}
+	}
+	return nil
+}

dashboard/entry/update.go

@@ -53,6 +53,25 @@ func (r *ResolverForEntry) UpdateDashboardEntry(ctx context.Context, id int, ent
 			entry.RangeFrom = stats.Range.From
 			entry.RangeTo = stats.Range.To
 		}
+
+		if tag := tagsDuplicates(stats.ExcludeTags, stats.IncludeTags); tag != nil {
+			return nil, fmt.Errorf("tag '%s' is present in both exclude tags and include tags", tag.Key+":"+tag.Value)
+		}
+
+		r.DB.Where("dashboard_entry_id = ?", id).Delete(new(model.DashboardExcludedTag))
+		r.DB.Where("dashboard_entry_id = ?", id).Delete(new(model.DashboardIncludedTag))
+
+		if err := tagsExist(r.DB, auth.GetUser(ctx).ID, stats.ExcludeTags); err != nil {
+			return nil, fmt.Errorf("exclude tags: %s", err.Error())
+		}
+
+		if err := tagsExist(r.DB, auth.GetUser(ctx).ID, stats.IncludeTags); err != nil {
+			return nil, fmt.Errorf("include tags: %s", err.Error())
+		}
+
+		entry.ExcludedTags = convert.ExcludedTagsToInternal(stats.ExcludeTags)
+		entry.IncludedTags = convert.IncludedTagsToInternal(stats.IncludeTags)
+
 		entry.Keys = strings.Join(stats.Tags, ",")
 		entry.Interval = convert.InternalInterval(stats.Interval)
 	}

dashboard/get.go

@@ -15,7 +15,14 @@ func (r *ResolverForDashboard) Dashboards(ctx context.Context) ([]*gqlmodel.Dash
 	userID := auth.GetUser(ctx).ID
 
 	dashboards := []model.Dashboard{}
-	find := r.DB.Preload("Entries").Preload("Ranges").Where(&model.Dashboard{UserID: userID}).Find(&dashboards)
+
+	q := r.DB
+	q = q.Preload("Entries")
+	q = q.Preload("Entries.ExcludedTags")
+	q = q.Preload("Entries.IncludedTags")
+	q = q.Preload("Ranges")
+
+	find := q.Where(&model.Dashboard{UserID: userID}).Find(&dashboards)
 
 	if find.Error != nil {
 		return nil, find.Error

model/all.go

@@ -11,6 +11,8 @@ func All() []interface{} {
 		new(UserSetting),
 		new(Dashboard),
 		new(DashboardEntry),
+		new(DashboardExcludedTag),
+		new(DashboardIncludedTag),
 		new(DashboardRange),
 	}
 }

model/dashboard.go

@@ -26,21 +26,37 @@ type Dashboard struct {
 
 // DashboardEntry an entry which represents a diagram in a dashboard.
 type DashboardEntry struct {
-	ID          int `gorm:"primary_key;unique_index;AUTO_INCREMENT"`
-	DashboardID int `gorm:"type:int REFERENCES dashboards(id) ON DELETE CASCADE"`
-	Title       string
-	Total       bool `gorm:"default:false"`
-	Type        DashboardType
-	Keys        string
-	Interval    Interval
-	RangeID     int
-	RangeFrom   string
-	RangeTo     string
+	ID           int `gorm:"primary_key;unique_index;AUTO_INCREMENT"`
+	DashboardID  int `gorm:"type:int REFERENCES dashboards(id) ON DELETE CASCADE"`
+	Title        string
+	Total        bool `gorm:"default:false"`
+	Type         DashboardType
+	Keys         string
+	Interval     Interval
+	RangeID      int
+	RangeFrom    string
+	RangeTo      string
+	ExcludedTags []DashboardExcludedTag
+	IncludedTags []DashboardIncludedTag
 
 	MobilePosition  string
 	DesktopPosition string
 }
 
+// DashboardExcludedTag a tag for filtering timespans
+type DashboardExcludedTag struct {
+	DashboardEntryID int `gorm:"type:int REFERENCES dashboard_entries(id) ON DELETE CASCADE"`
+	Key              string
+	StringValue      string
+}
+
+// DashboardIncludedTag a tag for filtering timespans
+type DashboardIncludedTag struct {
+	DashboardEntryID int `gorm:"type:int REFERENCES dashboard_entries(id) ON DELETE CASCADE"`
+	Key              string
+	StringValue      string
+}
+
 // DashboardType the dashboard type
 type DashboardType string
 

ui/src/dashboard/Entry/AddPopup.tsx

@@ -10,6 +10,8 @@ import * as gqlDashboard from '../../gql/dashboard';
 import {Fade} from '../../common/Fade';
 import {DashboardEntryForm, isValidDashboardEntry} from './DashboardEntryForm';
 import {AddDashboardEntry, AddDashboardEntryVariables} from '../../gql/__generated__/AddDashboardEntry';
+import {handleError} from '../../utils/errors';
+import {useSnackbar} from 'notistack';
 
 interface EditPopupProps {
     dashboardId: number;
@@ -38,6 +40,9 @@ export const AddPopup: React.FC<EditPopupProps> = ({
         refetchQueries: [{query: gqlDashboard.Dashboards}],
     });
     const valid = isValidDashboardEntry(entry);
+
+    const {enqueueSnackbar} = useSnackbar();
+
     return (
         <Popper
             key="popup"
@@ -89,6 +94,8 @@ export const AddPopup: React.FC<EditPopupProps> = ({
                                                       }
                                                     : null,
                                                 rangeId: entry.statsSelection.rangeId,
+                                                excludeTags: entry.statsSelection.excludeTags,
+                                                includeTags: entry.statsSelection.includeTags,
                                             },
                                             pos: {
                                                 desktop: {
@@ -99,7 +106,9 @@ export const AddPopup: React.FC<EditPopupProps> = ({
                                                 },
                                             },
                                         },
-                                    }).then(finish);
+                                    })
+                                        .then(finish)
+                                        .catch(handleError('Add Dashboard Entry', enqueueSnackbar));
                                 }}>
                                 Add
                             </Button>

ui/src/dashboard/Entry/DashboardEntry.tsx

@@ -52,6 +52,8 @@ const SpecificDashboardEntry: React.FC<{entry: Dashboards_dashboards_items; rang
                 range,
                 interval,
                 tags: entry.statsSelection.tags,
+                excludeTags: entry.statsSelection.excludeTags,
+                includeTags: entry.statsSelection.includeTags,
             },
         },
     });

ui/src/dashboard/Entry/DashboardEntryForm.tsx

@@ -5,6 +5,7 @@ import InputLabel from '@material-ui/core/InputLabel';
 import Select from '@material-ui/core/NativeSelect/NativeSelect';
 import {EntryType, StatsInterval} from '../../gql/__generated__/globalTypes';
 import {TagKeySelector} from '../../tag/TagKeySelector';
+import {TagFilterSelector} from '../../tag/TagFilterSelector';
 import {Dashboards_dashboards_items, Dashboards_dashboards_items_statsSelection_range} from '../../gql/__generated__/Dashboards';
 import {RelativeDateTimeSelector} from '../../common/RelativeDateTimeSelector';
 import {parseRelativeTime} from '../../utils/time';
@@ -31,6 +32,27 @@ export const isValidDashboardEntry = (item: Dashboards_dashboards_items): boolea
 export const DashboardEntryForm: React.FC<EditPopupProps> = ({entry, onChange: setEntry, disabled = false, ranges}) => {
     const [staticRange, setStaticRange] = React.useState(!entry.statsSelection.rangeId);
 
+    const [excludeTags, setExcludeTags] = React.useState(
+        (entry.statsSelection.excludeTags || []).map((tag) => ({
+            tag: {
+                key: tag.key,
+                color: '',
+                __typename: 'TagDefinition' as 'TagDefinition',
+            },
+            value: tag.value,
+        }))
+    );
+    const [includeTags, setIncludeTags] = React.useState(
+        (entry.statsSelection.includeTags || []).map((tag) => ({
+            tag: {
+                key: tag.key,
+                color: '',
+                __typename: 'TagDefinition' as 'TagDefinition',
+            },
+            value: tag.value,
+        }))
+    );
+
     const range: Dashboards_dashboards_items_statsSelection_range = entry.statsSelection.range
         ? entry.statsSelection.range
         : {
@@ -189,6 +211,32 @@ export const DashboardEntryForm: React.FC<EditPopupProps> = ({entry, onChange: s
                     setEntry(entry);
                 }}
             />
+            <TagFilterSelector
+                type="Exclude"
+                value={excludeTags}
+                onChange={(tags) => {
+                    setExcludeTags(tags);
+                    entry.statsSelection.excludeTags = tags.map((tag) => ({
+                        key: tag.tag.key,
+                        value: tag.value,
+                        __typename: 'TimeSpanTag',
+                    }));
+                    setEntry(entry);
+                }}
+            />
+            <TagFilterSelector
+                type="Include"
+                value={includeTags}
+                onChange={(tags) => {
+                    setIncludeTags(tags);
+                    entry.statsSelection.includeTags = tags.map((tag) => ({
+                        key: tag.tag.key,
+                        value: tag.value,
+                        __typename: 'TimeSpanTag',
+                    }));
+                    setEntry(entry);
+                }}
+            />
         </>
     );
 };

ui/src/dashboard/Entry/EditPopup.tsx

@@ -10,6 +10,8 @@ import * as gqlDashboard from '../../gql/dashboard';
 import {UpdateDashboardEntry, UpdateDashboardEntryVariables} from '../../gql/__generated__/UpdateDashboardEntry';
 import {Fade} from '../../common/Fade';
 import {DashboardEntryForm, isValidDashboardEntry} from './DashboardEntryForm';
+import {handleError} from '../../utils/errors';
+import {useSnackbar} from 'notistack';
 
 interface EditPopupProps {
     entry: Dashboards_dashboards_items;
@@ -24,6 +26,9 @@ export const EditPopup: React.FC<EditPopupProps> = ({entry, anchorEl, onChange:
         refetchQueries: [{query: gqlDashboard.Dashboards}],
     });
     const valid = isValidDashboardEntry(entry);
+
+    const {enqueueSnackbar} = useSnackbar();
+
     return (
         <Popper
             key="popup"
@@ -75,9 +80,13 @@ export const EditPopup: React.FC<EditPopupProps> = ({entry, anchorEl, onChange:
                                                       }
                                                     : null,
                                                 rangeId: entry.statsSelection.rangeId,
+                                                excludeTags: entry.statsSelection.excludeTags,
+                                                includeTags: entry.statsSelection.includeTags,
                                             },
                                         },
-                                    }).then(() => setEdit(null));
+                                    })
+                                        .then(() => setEdit(null))
+                                        .catch(handleError('Edit Dashboard Entry', enqueueSnackbar));
                                 }}>
                                 Save
                             </Button>