feat: Add notifications for empty skill queue

.gitignore

@@ -11,3 +11,4 @@ evebuddy.exe
 fynemeta
 evebuddy
 profile*.gif
+__debug_*

Makefile

@@ -1,3 +1,5 @@
+generate: bundle queries
+
 bundle:
 	fyne bundle --package ui resources/ui > internal/app/ui/resource.go
 	fyne bundle --package eveimage resources/eveimage > internal/eveimage/resource.go

internal/app/character.go

@@ -8,16 +8,17 @@ import (
 
 // An Eve Online character owners by the user.
 type Character struct {
-	AssetValue    optional.Optional[float64]
-	EveCharacter  *EveCharacter
-	Home          *EveLocation
-	ID            int32
-	LastLoginAt   optional.Optional[time.Time]
-	Location      *EveLocation
-	Ship          *EveType
-	TotalSP       optional.Optional[int]
-	UnallocatedSP optional.Optional[int]
-	WalletBalance optional.Optional[float64]
+	AssetValue        optional.Optional[float64]
+	EveCharacter      *EveCharacter
+	Home              *EveLocation
+	ID                int32
+	IsTrainingWatched bool
+	LastLoginAt       optional.Optional[time.Time]
+	Location          *EveLocation
+	Ship              *EveType
+	TotalSP           optional.Optional[int]
+	UnallocatedSP     optional.Optional[int]
+	WalletBalance     optional.Optional[float64]
 }
 
 // A shortened version of Character.

internal/app/character/character.go

@@ -16,15 +16,66 @@ import (
 	"github.com/antihax/goesi/esi"
 )
 
-func (s *CharacterService) DeleteCharacter(ctx context.Context, characterID int32) error {
-	if err := s.st.DeleteCharacter(ctx, characterID); err != nil {
+func (s *CharacterService) DeleteCharacter(ctx context.Context, id int32) error {
+	if err := s.st.DeleteCharacter(ctx, id); err != nil {
 		return err
 	}
 	return s.StatusCacheService.UpdateCharacters(ctx, s.st)
 }
 
-func (s *CharacterService) GetCharacter(ctx context.Context, characterID int32) (*app.Character, error) {
-	o, err := s.st.GetCharacter(ctx, characterID)
+// EnableTrainingWatcher enables training watcher for a character when it has an active training queue.
+func (s *CharacterService) EnableTrainingWatcher(ctx context.Context, characterID int32) error {
+	c, err := s.GetCharacter(ctx, characterID)
+	if err != nil {
+		return err
+	}
+	if c.IsTrainingWatched {
+		return nil
+	}
+	t, err := s.GetCharacterTotalTrainingTime(ctx, characterID)
+	if err != nil {
+		return err
+	}
+	if t.IsEmpty() {
+		return nil
+	}
+	err = s.UpdateCharacterIsTrainingWatched(ctx, characterID, true)
+	if err != nil {
+		return err
+	}
+	slog.Info("Enabled training watcher", "characterID", characterID)
+	return nil
+}
+
+// EnableAllTrainingWatchers enables training watches for any currently active training queue.
+func (s *CharacterService) EnableAllTrainingWatchers(ctx context.Context) error {
+	ids, err := s.st.ListCharacterIDs(ctx)
+	if err != nil {
+		return err
+	}
+	for _, id := range ids {
+		t, err := s.GetCharacterTotalTrainingTime(ctx, id)
+		if err != nil {
+			return err
+		}
+		if t.IsEmpty() {
+			continue
+		}
+		err = s.UpdateCharacterIsTrainingWatched(ctx, id, true)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// DisableAllTrainingWatchers disables training watches for all characters.
+func (s *CharacterService) DisableAllTrainingWatchers(ctx context.Context) error {
+	return s.st.DisableAllTrainingWatchers(ctx)
+}
+
+func (s *CharacterService) GetCharacter(ctx context.Context, id int32) (*app.Character, error) {
+	o, err := s.st.GetCharacter(ctx, id)
 	if errors.Is(err, storage.ErrNotFound) {
 		return nil, ErrNotFound
 	}
@@ -47,6 +98,10 @@ func (s *CharacterService) ListCharactersShort(ctx context.Context) ([]*app.Char
 	return s.st.ListCharactersShort(ctx)
 }
 
+func (s *CharacterService) UpdateCharacterIsTrainingWatched(ctx context.Context, id int32, v bool) error {
+	return s.st.UpdateCharacterIsTrainingWatched(ctx, id, v)
+}
+
 // UpdateOrCreateCharacterFromSSO creates or updates a character via SSO authentication.
 // The provided context is used for the SSO authentication process only and can be canceled.
 func (s *CharacterService) UpdateOrCreateCharacterFromSSO(ctx context.Context, infoText binding.ExternalString) (int32, error) {

internal/app/character/character_test.go

@@ -65,6 +65,81 @@ func TestGetAnyCharacter(t *testing.T) {
 	})
 }
 
+func TestTrainingWatchers(t *testing.T) {
+	db, st, factory := testutil.New()
+	defer db.Close()
+	cs := newCharacterService(st)
+	ctx := context.Background()
+	t.Run("should enable watchers for characters with active queues only", func(t *testing.T) {
+		// given
+		testutil.TruncateTables(db)
+		c1 := factory.CreateCharacter()
+		factory.CreateCharacterSkillqueueItem(storage.SkillqueueItemParams{CharacterID: c1.ID})
+		c2 := factory.CreateCharacter()
+		// when
+		err := cs.EnableAllTrainingWatchers(ctx)
+		// then
+		if assert.NoError(t, err) {
+			c1x, err := cs.GetCharacter(ctx, c1.ID)
+			if assert.NoError(t, err) {
+				assert.True(t, c1x.IsTrainingWatched)
+			}
+			c2x, err := cs.GetCharacter(ctx, c2.ID)
+			if assert.NoError(t, err) {
+				assert.False(t, c2x.IsTrainingWatched)
+			}
+		}
+	})
+	t.Run("should disable all training watchers", func(t *testing.T) {
+		// given
+		testutil.TruncateTables(db)
+		c1 := factory.CreateCharacter(storage.UpdateOrCreateCharacterParams{IsTrainingWatched: true})
+		c2 := factory.CreateCharacter()
+		// when
+		err := cs.DisableAllTrainingWatchers(ctx)
+		// then
+		if assert.NoError(t, err) {
+			c1x, err := cs.GetCharacter(ctx, c1.ID)
+			if assert.NoError(t, err) {
+				assert.False(t, c1x.IsTrainingWatched)
+			}
+			c2x, err := cs.GetCharacter(ctx, c2.ID)
+			if assert.NoError(t, err) {
+				assert.False(t, c2x.IsTrainingWatched)
+			}
+		}
+	})
+	t.Run("should enable watchers for character with active queues", func(t *testing.T) {
+		// given
+		testutil.TruncateTables(db)
+		c1 := factory.CreateCharacter()
+		factory.CreateCharacterSkillqueueItem(storage.SkillqueueItemParams{CharacterID: c1.ID})
+		// when
+		err := cs.EnableTrainingWatcher(ctx, c1.ID)
+		// then
+		if assert.NoError(t, err) {
+			c1a, err := cs.GetCharacter(ctx, c1.ID)
+			if assert.NoError(t, err) {
+				assert.True(t, c1a.IsTrainingWatched)
+			}
+		}
+	})
+	t.Run("should not enable watchers for character without active queues", func(t *testing.T) {
+		// given
+		testutil.TruncateTables(db)
+		c1 := factory.CreateCharacter()
+		// when
+		err := cs.EnableTrainingWatcher(ctx, c1.ID)
+		// then
+		if assert.NoError(t, err) {
+			c1a, err := cs.GetCharacter(ctx, c1.ID)
+			if assert.NoError(t, err) {
+				assert.False(t, c1a.IsTrainingWatched)
+			}
+		}
+	})
+}
+
 func newCharacterService(st *storage.Storage) *character.CharacterService {
 	sc := statuscache.New(cache.New())
 	eu := eveuniverse.New(st, nil)

internal/app/storage/character.go

@@ -16,7 +16,14 @@ import (
 func (st *Storage) DeleteCharacter(ctx context.Context, characterID int32) error {
 	err := st.q.DeleteCharacter(ctx, int64(characterID))
 	if err != nil {
-		return fmt.Errorf("delete Character %d: %w", characterID, err)
+		return fmt.Errorf("delete character %d: %w", characterID, err)
+	}
+	return nil
+}
+
+func (st *Storage) DisableAllTrainingWatchers(ctx context.Context) error {
+	if err := st.q.DisableAllTrainingWatchers(ctx); err != nil {
+		return fmt.Errorf("disable all training watchers: %w", err)
 	}
 	return nil
 }
@@ -27,7 +34,7 @@ func (st *Storage) GetCharacter(ctx context.Context, characterID int32) (*app.Ch
 		if errors.Is(err, sql.ErrNoRows) {
 			err = ErrNotFound
 		}
-		return nil, fmt.Errorf("get Character %d: %w", characterID, err)
+		return nil, fmt.Errorf("get character %d: %w", characterID, err)
 	}
 	alliance := nullEveEntry{
 		ID:       r.EveCharacter.AllianceID,
@@ -52,15 +59,15 @@ func (st *Storage) GetCharacter(ctx context.Context, characterID int32) (*app.Ch
 		r.ShipID,
 	)
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("get character %d: %w", characterID, err)
 	}
 	return c, nil
 }
 
 func (st *Storage) GetFirstCharacter(ctx context.Context) (*app.Character, error) {
 	ids, err := st.ListCharacterIDs(ctx)
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("list first character: %w", err)
 	}
 	if len(ids) == 0 {
 		return nil, ErrNotFound
@@ -72,7 +79,7 @@ func (st *Storage) GetFirstCharacter(ctx context.Context) (*app.Character, error
 func (st *Storage) ListCharacters(ctx context.Context) ([]*app.Character, error) {
 	rows, err := st.q.ListCharacters(ctx)
 	if err != nil {
-		return nil, fmt.Errorf("list Characters: %w", err)
+		return nil, fmt.Errorf("list characters: %w", err)
 	}
 	cc := make([]*app.Character, len(rows))
 	for i, r := range rows {
@@ -99,7 +106,7 @@ func (st *Storage) ListCharacters(ctx context.Context) ([]*app.Character, error)
 			r.ShipID,
 		)
 		if err != nil {
-			return nil, err
+			return nil, fmt.Errorf("list characters: %w", err)
 		}
 		cc[i] = c
 	}
@@ -139,6 +146,17 @@ func (st *Storage) UpdateCharacterHome(ctx context.Context, characterID int32, h
 	return nil
 }
 
+func (st *Storage) UpdateCharacterIsTrainingWatched(ctx context.Context, characterID int32, isWatched bool) error {
+	arg := queries.UpdateCharacterIsTrainingWatchedParams{
+		ID:                int64(characterID),
+		IsTrainingWatched: isWatched,
+	}
+	if err := st.q.UpdateCharacterIsTrainingWatched(ctx, arg); err != nil {
+		return fmt.Errorf("update is training watched for character %d: %w", characterID, err)
+	}
+	return nil
+}
+
 func (st *Storage) UpdateCharacterLastLoginAt(ctx context.Context, characterID int32, v optional.Optional[time.Time]) error {
 	arg := queries.UpdateCharacterLastLoginAtParams{
 		ID:          int64(characterID),
@@ -207,31 +225,33 @@ func (st *Storage) UpdateCharacterAssetValue(ctx context.Context, characterID in
 }
 
 type UpdateOrCreateCharacterParams struct {
-	AssetValue    optional.Optional[float64]
-	ID            int32
-	HomeID        optional.Optional[int64]
-	LastLoginAt   optional.Optional[time.Time]
-	LocationID    optional.Optional[int64]
-	ShipID        optional.Optional[int32]
-	TotalSP       optional.Optional[int]
-	UnallocatedSP optional.Optional[int]
-	WalletBalance optional.Optional[float64]
+	AssetValue        optional.Optional[float64]
+	ID                int32
+	IsTrainingWatched bool
+	HomeID            optional.Optional[int64]
+	LastLoginAt       optional.Optional[time.Time]
+	LocationID        optional.Optional[int64]
+	ShipID            optional.Optional[int32]
+	TotalSP           optional.Optional[int]
+	UnallocatedSP     optional.Optional[int]
+	WalletBalance     optional.Optional[float64]
 }
 
 func (st *Storage) UpdateOrCreateCharacter(ctx context.Context, arg UpdateOrCreateCharacterParams) error {
 	arg2 := queries.UpdateOrCreateCharacterParams{
-		ID:            int64(arg.ID),
-		AssetValue:    optional.ToNullFloat64(arg.AssetValue),
-		HomeID:        optional.ToNullInt64(arg.HomeID),
-		LastLoginAt:   optional.ToNullTime(arg.LastLoginAt),
-		LocationID:    optional.ToNullInt64(arg.LocationID),
-		ShipID:        optional.ToNullInt64(arg.ShipID),
-		TotalSp:       optional.ToNullInt64(arg.TotalSP),
-		UnallocatedSp: optional.ToNullInt64(arg.UnallocatedSP),
-		WalletBalance: optional.ToNullFloat64(arg.WalletBalance),
+		ID:                int64(arg.ID),
+		AssetValue:        optional.ToNullFloat64(arg.AssetValue),
+		IsTrainingWatched: arg.IsTrainingWatched,
+		HomeID:            optional.ToNullInt64(arg.HomeID),
+		LastLoginAt:       optional.ToNullTime(arg.LastLoginAt),
+		LocationID:        optional.ToNullInt64(arg.LocationID),
+		ShipID:            optional.ToNullInt64(arg.ShipID),
+		TotalSp:           optional.ToNullInt64(arg.TotalSP),
+		UnallocatedSp:     optional.ToNullInt64(arg.UnallocatedSP),
+		WalletBalance:     optional.ToNullFloat64(arg.WalletBalance),
 	}
 	if err := st.q.UpdateOrCreateCharacter(ctx, arg2); err != nil {
-		return fmt.Errorf("update or create Character %d: %w", arg.ID, err)
+		return fmt.Errorf("update or create character %d: %w", arg.ID, err)
 	}
 	return nil
 }
@@ -248,43 +268,44 @@ func (st *Storage) characterFromDBModel(
 	locationID sql.NullInt64,
 	shipID sql.NullInt64,
 ) (*app.Character, error) {
-	c := app.Character{
-		AssetValue:    optional.FromNullFloat64(character.AssetValue),
-		EveCharacter:  eveCharacterFromDBModel(eveCharacter, corporation, race, alliance, faction),
-		ID:            int32(character.ID),
-		LastLoginAt:   optional.FromNullTime(character.LastLoginAt),
-		TotalSP:       optional.FromNullInt64ToInteger[int](character.TotalSp),
-		UnallocatedSP: optional.FromNullInt64ToInteger[int](character.UnallocatedSp),
-		WalletBalance: optional.FromNullFloat64(character.WalletBalance),
+	o := app.Character{
+		AssetValue:        optional.FromNullFloat64(character.AssetValue),
+		EveCharacter:      eveCharacterFromDBModel(eveCharacter, corporation, race, alliance, faction),
+		ID:                int32(character.ID),
+		IsTrainingWatched: character.IsTrainingWatched,
+		LastLoginAt:       optional.FromNullTime(character.LastLoginAt),
+		TotalSP:           optional.FromNullInt64ToInteger[int](character.TotalSp),
+		UnallocatedSP:     optional.FromNullInt64ToInteger[int](character.UnallocatedSp),
+		WalletBalance:     optional.FromNullFloat64(character.WalletBalance),
 	}
 	if homeID.Valid {
 		x, err := st.GetEveLocation(ctx, homeID.Int64)
 		if err != nil {
 			return nil, err
 		}
-		c.Home = x
+		o.Home = x
 	}
 	if locationID.Valid {
 		x, err := st.GetEveLocation(ctx, locationID.Int64)
 		if err != nil {
 			return nil, err
 		}
-		c.Location = x
+		o.Location = x
 	}
 	if shipID.Valid {
 		x, err := st.GetEveType(ctx, int32(shipID.Int64))
 		if err != nil {
 			return nil, err
 		}
-		c.Ship = x
+		o.Ship = x
 	}
-	return &c, nil
+	return &o, nil
 }
 
-func (st *Storage) GetCharacterAssetValue(ctx context.Context, characterID int32) (optional.Optional[float64], error) {
-	v, err := st.q.GetCharacterAssetValue(ctx, int64(characterID))
+func (st *Storage) GetCharacterAssetValue(ctx context.Context, id int32) (optional.Optional[float64], error) {
+	v, err := st.q.GetCharacterAssetValue(ctx, int64(id))
 	if err != nil {
-		return optional.Optional[float64]{}, err
+		return optional.Optional[float64]{}, fmt.Errorf("get asset value for character %d: %w", id, err)
 	}
 	return optional.FromNullFloat64(v), nil
 }