Get favourites working

Bitvault/AggerateContainerViewModelHandler.cs

@@ -18,19 +18,19 @@ public class AggerateContainerViewModelHandler(IMediator mediator,
             bool selected = true;
 
             if (await mediator.Handle<RequestEventArgs<QueryContainerConfiguration>,
-                IReadOnlyCollection<(int Id, string? Name)>>(Request.As(new QueryContainerConfiguration 
+                IReadOnlyCollection<(int Id, string? Name, bool Favourite, bool Archived)>>(Request.As(new QueryContainerConfiguration 
                 { 
                     Filter = configuration.Filter,
                     Query = configuration.Query 
-                })) is IReadOnlyCollection<(int Id, string? Name)> results)
+                })) is IReadOnlyCollection<(int Id, string? Name, bool Favourite, bool Archived)> results)
             {
-                foreach ((int Id, string? Name) in results)
+                foreach ((int Id, string? Name, bool Favourite, bool Archived) in results)
                 {
                     IServiceScope serviceScope = serviceProvider.CreateScope();
                     IServiceFactory serviceFactory = serviceScope.ServiceProvider.GetRequiredService<IServiceFactory>();
                     IValueStore<Item> valueStore = serviceScope.ServiceProvider.GetRequiredService<IValueStore<Item>>();
 
-                    if (serviceFactory.Create<ItemNavigationViewModel>(Id, Name, "Description", selected, configuration.Filter == "Archive") is ItemNavigationViewModel viewModel)
+                    if (serviceFactory.Create<ItemNavigationViewModel>(Id, Name, "Description", selected, Favourite, Archived) is ItemNavigationViewModel viewModel)
                     {
                         Item item = new() { Id = Id, Name = Name };
                         valueStore.Set(item);

Bitvault/ArchiveItemActionViewModel.cs

@@ -13,5 +13,4 @@ public partial class ArchiveItemActionViewModel(IServiceProvider provider,
 {
     [RelayCommand]
     public void Invoke() => Publisher.Publish(Archive.As<Item>());
-}
-
+}

Bitvault/Favourite.cs

@@ -0,0 +1,10 @@
+namespace Bitvault;
+
+public record Favourite
+{
+    public static FavouriteEventArgs<TValue> As<TValue>(TValue value) =>
+        new(value);
+
+    public static FavouriteEventArgs<TValue> As<TValue>() where TValue : new() =>
+        new(new TValue());
+}

Bitvault/FavouriteEventArgs.cs

@@ -0,0 +1,3 @@
+namespace Bitvault;
+
+public record FavouriteEventArgs<TValue>(TValue Value);

Bitvault/FavouriteItemActionViewModel.cs

@@ -0,0 +1,30 @@
+using CommunityToolkit.Mvvm.Input;
+using Toolkit.Foundation;
+
+namespace Bitvault;
+
+public partial class FavouriteItemActionViewModel(IServiceProvider provider,
+    IServiceFactory factory,
+    IMediator mediator,
+    IPublisher publisher,
+    ISubscription subscriber,
+    IDisposer disposer,
+    bool value = false) : Observable<bool>(provider, factory, mediator, publisher, subscriber, disposer, value),
+    IRemovable
+{
+    [RelayCommand]
+    public void Invoke()
+    {
+        if (!Value)
+        {
+            Value = true;
+            Publisher.Publish(Favourite.As<Item>());
+        }
+        else
+        {
+            Value = false;
+            Publisher.Publish(Unfavourite.As<Item>());
+        }
+    }
+}
+

Bitvault/FavouriteItemHandler.cs

@@ -0,0 +1,34 @@
+using Bitvault.Data;
+using Microsoft.EntityFrameworkCore;
+using Toolkit.Foundation;
+
+namespace Bitvault;
+
+public class FavouriteItemHandler(IValueStore<Item> valueStore,
+    IDbContextFactory<ContainerDbContext> dbContextFactory) :
+    INotificationHandler<FavouriteEventArgs<Item>>
+{
+    public async Task Handle(FavouriteEventArgs<Item> args)
+    {
+        try
+        {
+            if (valueStore.Value is Item item)
+            {
+                await Task.Run(async () =>
+                {
+                    using ContainerDbContext context = await dbContextFactory.CreateDbContextAsync();
+
+                    if (await context.FindAsync<ItemEntry>(item.Id) is ItemEntry result)
+                    {
+                        result.State = 1;
+                        await context.SaveChangesAsync();
+                    }
+                });
+            }
+        }
+        catch
+        {
+
+        }
+    }
+}

Bitvault/ItemNavigationViewModel.cs

@@ -15,10 +15,13 @@ public partial class ItemNavigationViewModel(IServiceProvider provider,
     string name,
     string description,
     bool selected,
+    bool favourite,
     bool archived) :
     Observable(provider, factory, mediator, publisher, subscriber, disposer),
     INotificationHandler<ArchiveEventArgs<Item>>,
     INotificationHandler<UnarchiveEventArgs<Item>>,
+    INotificationHandler<FavouriteEventArgs<Item>>,
+    INotificationHandler<UnfavouriteEventArgs<Item>>,
     ISelectable,
     IRemovable
 {
@@ -28,6 +31,9 @@ public partial class ItemNavigationViewModel(IServiceProvider provider,
     [ObservableProperty]
     private string? description = description;
 
+    [ObservableProperty]
+    private bool favourite = favourite;
+
     [ObservableProperty]
     private int id = id;
 
@@ -42,15 +48,15 @@ public partial class ItemNavigationViewModel(IServiceProvider provider,
 
     public IContentTemplate Template { get; set; } = template;
 
-    public Task Handle(ArchiveEventArgs<Item> args)
-    {
-        Dispose();
-        return Task.CompletedTask;
-    }
+    public Task Handle(ArchiveEventArgs<Item> args) => 
+        Task.Run(Dispose);
 
-    public Task Handle(UnarchiveEventArgs<Item> args)
-    {
-        Dispose();
-        return Task.CompletedTask;
-    }
+    public Task Handle(UnarchiveEventArgs<Item> args) => 
+        Task.Run(Dispose);
+
+    public Task Handle(FavouriteEventArgs<Item> args) => 
+        Task.FromResult(Favourite = true);
+
+    public Task Handle(UnfavouriteEventArgs<Item> args) =>
+        Task.FromResult(Favourite = false);
 }

Bitvault/ItemViewModel.cs

@@ -18,6 +18,7 @@ public partial class ItemViewModel :
         ISubscription subscriber, 
         IDisposer disposer,
         IContentTemplate template,
+        bool favourite = false,
         bool archived = false) : base(provider, factory, mediator, publisher, subscriber, disposer)
     {
         Template = template;
@@ -27,6 +28,7 @@ public partial class ItemViewModel :
         {
             Publisher.Publish(Notify.As(Factory.Create<CommandCollection>(new List<IDisposable>
             {
+                Factory.Create<FavouriteItemActionViewModel>(favourite),
                 Factory.Create<EditItemActionViewModel>(),
                 Factory.Create<ArchiveItemActionViewModel>(),
             })));

Bitvault/QueryContainerHandler.cs

@@ -6,12 +6,12 @@ using Toolkit.Foundation;
 namespace Bitvault;
 
 public class QueryContainerHandler(IDbContextFactory<ContainerDbContext> dbContextFactory) :
-    IHandler<RequestEventArgs<QueryContainerConfiguration>, IReadOnlyCollection<(int Id, string? Name)>>
+    IHandler<RequestEventArgs<QueryContainerConfiguration>, IReadOnlyCollection<(int Id, string? Name, bool Favourite, bool Archived)>>
 {
-    public async Task<IReadOnlyCollection<(int Id, string? Name)>> Handle(RequestEventArgs<QueryContainerConfiguration> args, 
+    public async Task<IReadOnlyCollection<(int Id, string? Name, bool Favourite, bool Archived)>> Handle(RequestEventArgs<QueryContainerConfiguration> args, 
         CancellationToken cancellationToken)
     {
-        List<(int Id, string? Name)> items = [];
+        List<(int Id, string? Name, bool Favourite, bool Archived)> items = [];
 
         if (args.Value is  QueryContainerConfiguration queryConfiguration)
         {
@@ -44,13 +44,15 @@ public class QueryContainerHandler(IDbContextFactory<ContainerDbContext> dbConte
                 return await context.Set<ItemEntry>().Where(predicate).Select(x => new
                 {
                     x.Id,
-                    x.Name
+                    x.Name,
+                    Favourite = x.State == 1,
+                    Archived = x.State == 2
                 }).OrderBy(x => x.Name).ToListAsync();
             });
 
             foreach (var result in results)
             {
-                items.Add(new(result.Id, result.Name));
+                items.Add(new(result.Id, result.Name, result.Favourite, result.Archived));
             }
         }
 

Bitvault/Unfavourite.cs

@@ -0,0 +1,10 @@
+namespace Bitvault;
+
+public record Unfavourite
+{
+    public static UnfavouriteEventArgs<TValue> As<TValue>(TValue value) =>
+        new(value);
+
+    public static UnfavouriteEventArgs<TValue> As<TValue>() where TValue : new() =>
+        new(new TValue());
+}

Bitvault/UnfavouriteEventArgs.cs

@@ -0,0 +1,3 @@
+namespace Bitvault;
+
+public record UnfavouriteEventArgs<TValue>(TValue Value);

Bitvault/UnfavouriteItemActionViewModel.cs

@@ -0,0 +1,17 @@
+using CommunityToolkit.Mvvm.Input;
+using Toolkit.Foundation;
+
+namespace Bitvault;
+
+public partial class UnfavouriteItemActionViewModel(IServiceProvider provider,
+    IServiceFactory factory,
+    IMediator mediator,
+    IPublisher publisher,
+    ISubscription subscriber,
+    IDisposer disposer) : Observable(provider, factory, mediator, publisher, subscriber, disposer),
+    IRemovable
+{
+    [RelayCommand]
+    public void Invoke() => Publisher.Publish(Unfavourite.As<Item>());
+}
+

Bitvault/UnfavouriteItemHandler.cs

@@ -0,0 +1,34 @@
+using Bitvault.Data;
+using Microsoft.EntityFrameworkCore;
+using Toolkit.Foundation;
+
+namespace Bitvault;
+
+public class UnfavouriteItemHandler(IValueStore<Item> valueStore,
+    IDbContextFactory<ContainerDbContext> dbContextFactory) :
+    INotificationHandler<UnfavouriteEventArgs<Item>>
+{
+    public async Task Handle(UnfavouriteEventArgs<Item> args)
+    {
+        try
+        {
+            if (valueStore.Value is Item item)
+            {
+                await Task.Run(async () =>
+                {
+                    using ContainerDbContext context = await dbContextFactory.CreateDbContextAsync();
+
+                    if (await context.FindAsync<ItemEntry>(item.Id) is ItemEntry result)
+                    {
+                        result.State = 0;
+                        await context.SaveChangesAsync();
+                    }
+                });
+            }
+        }
+        catch
+        {
+
+        }
+    }
+}