Added lots of commands

Simplified KeePass client

ModernKeePass.Application/Group/Commands/AddEntry/AddEntryCommand.cs

@@ -0,0 +1,54 @@
+using System.Threading.Tasks;
+using MediatR;
+using ModernKeePass.Application.Common.Interfaces;
+using ModernKeePass.Application.Database.Queries.IsDatabaseOpen;
+using ModernKeePass.Application.Entry.Models;
+using ModernKeePass.Application.Group.Models;
+using ModernKeePass.Domain.Exceptions;
+
+namespace ModernKeePass.Application.Group.Commands.AddEntry
+{
+    public class AddEntryCommand : IRequest
+    {
+        public GroupVm ParentGroup { get; set; }
+        public EntryVm Entry { get; set; }
+
+        public class AddEntryCommandHandler : IAsyncRequestHandler<AddEntryCommand>
+        {
+            private readonly IDatabaseProxy _database;
+            private readonly IMediator _mediator;
+
+            public AddEntryCommandHandler(IDatabaseProxy database, IMediator mediator)
+            {
+                _database = database;
+                _mediator = mediator;
+            }
+
+            public async Task Handle(AddEntryCommand message)
+            {
+                var isDatabaseOpen = await _mediator.Send(new IsDatabaseOpenQuery());
+                if (!isDatabaseOpen) throw new DatabaseClosedException();
+                /*var entryEntity = new EntryEntity
+                {
+                    Id = message.Entry.Id,
+                    Name = message.Entry.Title,
+                    UserName = message.Entry.Username,
+                    Password = message.Entry.Password,
+                    Url = message.Entry.Url,
+                    Notes = message.Entry.Notes,
+                    HasExpirationDate = message.Entry.HasExpirationDate,
+                    ExpirationDate = message.Entry.ExpirationDate,
+                    LastModificationDate = message.Entry.ModificationDate,
+                    BackgroundColor = message.Entry.BackgroundColor,
+                    ForegroundColor = message.Entry.ForegroundColor,
+                    Icon = message.Entry.Icon,
+                    AdditionalFields = message.Entry.AdditionalFields,
+                    History = message.Entry.History
+                };*/
+
+                await _database.AddEntry(message.ParentGroup.Id, message.Entry.Id);
+                message.ParentGroup.Entries.Add(message.Entry);
+            }
+        }
+    }
+}

ModernKeePass.Application/Group/Commands/AddGroup/AddGroupCommand.cs

@@ -0,0 +1,36 @@
+using System.Threading.Tasks;
+using MediatR;
+using ModernKeePass.Application.Common.Interfaces;
+using ModernKeePass.Application.Database.Queries.IsDatabaseOpen;
+using ModernKeePass.Application.Group.Models;
+using ModernKeePass.Domain.Exceptions;
+
+namespace ModernKeePass.Application.Group.Commands.AddGroup
+{
+    public class AddGroupCommand : IRequest
+    {
+        public GroupVm ParentGroup { get; set; }
+        public GroupVm Group { get; set; }
+
+        public class AddGroupCommandHandler : IAsyncRequestHandler<AddGroupCommand>
+        {
+            private readonly IDatabaseProxy _database;
+            private readonly IMediator _mediator;
+
+            public AddGroupCommandHandler(IDatabaseProxy database, IMediator mediator)
+            {
+                _database = database;
+                _mediator = mediator;
+            }
+
+            public async Task Handle(AddGroupCommand message)
+            {
+                var isDatabaseOpen = await _mediator.Send(new IsDatabaseOpenQuery());
+                if (!isDatabaseOpen) throw new DatabaseClosedException();
+
+                await _database.AddGroup(message.ParentGroup.Id, message.Group.Id);
+                message.ParentGroup.SubGroups.Add(message.Group);
+            }
+        }
+    }
+}

ModernKeePass.Application/Group/Commands/CreateEntry/CreateEntryCommand.cs

@@ -0,0 +1,41 @@
+using System.Threading.Tasks;
+using AutoMapper;
+using MediatR;
+using ModernKeePass.Application.Common.Interfaces;
+using ModernKeePass.Application.Database.Queries.IsDatabaseOpen;
+using ModernKeePass.Application.Entry.Models;
+using ModernKeePass.Application.Group.Models;
+using ModernKeePass.Domain.Exceptions;
+
+namespace ModernKeePass.Application.Group.Commands.CreateEntry
+{
+    public class CreateEntryCommand : IRequest<EntryVm>
+    {
+        public GroupVm ParentGroup { get; set; }
+
+        public class CreateEntryCommandHandler : IAsyncRequestHandler<CreateEntryCommand, EntryVm>
+        {
+            private readonly IDatabaseProxy _database;
+            private readonly IMediator _mediator;
+            private readonly IMapper _mapper;
+
+            public CreateEntryCommandHandler(IDatabaseProxy database, IMediator mediator, IMapper mapper)
+            {
+                _database = database;
+                _mediator = mediator;
+                _mapper = mapper;
+            }
+
+            public async Task<EntryVm> Handle(CreateEntryCommand message)
+            {
+                var isDatabaseOpen = await _mediator.Send(new IsDatabaseOpenQuery());
+                if (!isDatabaseOpen) throw new DatabaseClosedException();
+
+                var entry = _database.CreateEntry(message.ParentGroup.Id);
+                var entryVm = _mapper.Map<EntryVm>(entry);
+                message.ParentGroup.Entries.Add(entryVm);
+                return entryVm;
+            }
+        }
+    }
+}

ModernKeePass.Application/Group/Commands/CreateGroup/CreateGroupCommand.cs

@@ -0,0 +1,42 @@
+using System.Threading.Tasks;
+using AutoMapper;
+using MediatR;
+using ModernKeePass.Application.Common.Interfaces;
+using ModernKeePass.Application.Database.Queries.IsDatabaseOpen;
+using ModernKeePass.Application.Group.Models;
+using ModernKeePass.Domain.Exceptions;
+
+namespace ModernKeePass.Application.Group.Commands.CreateGroup
+{
+    public class CreateGroupCommand : IRequest<GroupVm>
+    {
+        public GroupVm ParentGroup { get; set; }
+        public string Name { get; set; }
+        public bool IsRecycleBin { get; set; }
+
+        public class CreateGroupCommandHandler : IAsyncRequestHandler<CreateGroupCommand, GroupVm>
+        {
+            private readonly IDatabaseProxy _database;
+            private readonly IMediator _mediator;
+            private readonly IMapper _mapper;
+
+            public CreateGroupCommandHandler(IDatabaseProxy database, IMediator mediator, IMapper mapper)
+            {
+                _database = database;
+                _mediator = mediator;
+                _mapper = mapper;
+            }
+
+            public async Task<GroupVm> Handle(CreateGroupCommand message)
+            {
+                var isDatabaseOpen = await _mediator.Send(new IsDatabaseOpenQuery());
+                if (!isDatabaseOpen) throw new DatabaseClosedException();
+
+                var group = _database.CreateGroup(message.ParentGroup.Id, message.Name, message.IsRecycleBin);
+                var groupVm = _mapper.Map<GroupVm>(group);
+                message.ParentGroup.SubGroups.Add(groupVm);
+                return groupVm;
+            }
+        }
+    }
+}

ModernKeePass.Application/Group/Commands/DeleteEntry/DeleteEntryCommand.cs

@@ -0,0 +1,35 @@
+using System.Threading.Tasks;
+using MediatR;
+using ModernKeePass.Application.Common.Interfaces;
+using ModernKeePass.Application.Database.Queries.IsDatabaseOpen;
+using ModernKeePass.Application.Entry.Models;
+using ModernKeePass.Domain.Exceptions;
+
+namespace ModernKeePass.Application.Group.Commands.DeleteEntry
+{
+    public class DeleteEntryCommand : IRequest
+    {
+        public EntryVm Entry { get; set; }
+
+        public class DeleteEntryCommandHandler : IAsyncRequestHandler<DeleteEntryCommand>
+        {
+            private readonly IDatabaseProxy _database;
+            private readonly IMediator _mediator;
+
+            public DeleteEntryCommandHandler(IDatabaseProxy database, IMediator mediator)
+            {
+                _database = database;
+                _mediator = mediator;
+            }
+
+            public async Task Handle(DeleteEntryCommand message)
+            {
+                var isDatabaseOpen = await _mediator.Send(new IsDatabaseOpenQuery());
+                if (!isDatabaseOpen) throw new DatabaseClosedException();
+
+                await _database.DeleteEntry(message.Entry.Id);
+                message.Entry = null;
+            }
+        }
+    }
+}

ModernKeePass.Application/Group/Commands/DeleteGroup/DeleteGroupCommand.cs

@@ -0,0 +1,35 @@
+using System.Threading.Tasks;
+using MediatR;
+using ModernKeePass.Application.Common.Interfaces;
+using ModernKeePass.Application.Database.Queries.IsDatabaseOpen;
+using ModernKeePass.Application.Group.Models;
+using ModernKeePass.Domain.Exceptions;
+
+namespace ModernKeePass.Application.Group.Commands.DeleteGroup
+{
+    public class DeleteGroupCommand : IRequest
+    {
+        public GroupVm Group { get; set; }
+
+        public class DeleteGroupCommandHandler : IAsyncRequestHandler<DeleteGroupCommand>
+        {
+            private readonly IDatabaseProxy _database;
+            private readonly IMediator _mediator;
+
+            public DeleteGroupCommandHandler(IDatabaseProxy database, IMediator mediator)
+            {
+                _database = database;
+                _mediator = mediator;
+            }
+
+            public async Task Handle(DeleteGroupCommand message)
+            {
+                var isDatabaseOpen = await _mediator.Send(new IsDatabaseOpenQuery());
+                if (!isDatabaseOpen) throw new DatabaseClosedException();
+
+                await _database.DeleteGroup(message.Group.Id);
+                message.Group = null;
+            }
+        }
+    }
+}

ModernKeePass.Application/Group/Commands/RemoveEntry/RemoveEntryCommand.cs

@@ -0,0 +1,37 @@
+using System.Threading.Tasks;
+using MediatR;
+using ModernKeePass.Application.Common.Interfaces;
+using ModernKeePass.Application.Database.Queries.IsDatabaseOpen;
+using ModernKeePass.Application.Entry.Models;
+using ModernKeePass.Application.Group.Models;
+using ModernKeePass.Domain.Exceptions;
+
+namespace ModernKeePass.Application.Group.Commands.RemoveEntry
+{
+    public class RemoveEntryCommand : IRequest
+    {
+        public GroupVm ParentGroup { get; set; }
+        public EntryVm Entry { get; set; }
+
+        public class RemoveEntryCommandHandler : IAsyncRequestHandler<RemoveEntryCommand>
+        {
+            private readonly IDatabaseProxy _database;
+            private readonly IMediator _mediator;
+
+            public RemoveEntryCommandHandler(IDatabaseProxy database, IMediator mediator)
+            {
+                _database = database;
+                _mediator = mediator;
+            }
+
+            public async Task Handle(RemoveEntryCommand message)
+            {
+                var isDatabaseOpen = await _mediator.Send(new IsDatabaseOpenQuery());
+                if (!isDatabaseOpen) throw new DatabaseClosedException();
+
+                await _database.RemoveEntry(message.ParentGroup.Id, message.Entry.Id);
+                message.ParentGroup.Entries.Remove(message.Entry);
+            }
+        }
+    }
+}

ModernKeePass.Application/Group/Commands/RemoveGroup/RemoveGroupCommand.cs

@@ -0,0 +1,36 @@
+using System.Threading.Tasks;
+using MediatR;
+using ModernKeePass.Application.Common.Interfaces;
+using ModernKeePass.Application.Database.Queries.IsDatabaseOpen;
+using ModernKeePass.Application.Group.Models;
+using ModernKeePass.Domain.Exceptions;
+
+namespace ModernKeePass.Application.Group.Commands.RemoveGroup
+{
+    public class RemoveGroupCommand : IRequest
+    {
+        public GroupVm ParentGroup { get; set; }
+        public GroupVm Group { get; set; }
+
+        public class RemoveGroupCommandHandler : IAsyncRequestHandler<RemoveGroupCommand>
+        {
+            private readonly IDatabaseProxy _database;
+            private readonly IMediator _mediator;
+
+            public RemoveGroupCommandHandler(IDatabaseProxy database, IMediator mediator)
+            {
+                _database = database;
+                _mediator = mediator;
+            }
+
+            public async Task Handle(RemoveGroupCommand message)
+            {
+                var isDatabaseOpen = await _mediator.Send(new IsDatabaseOpenQuery());
+                if (!isDatabaseOpen) throw new DatabaseClosedException();
+
+                await _database.RemoveGroup(message.ParentGroup.Id, message.Group.Id);
+                message.ParentGroup.SubGroups.Remove(message.Group);
+            }
+        }
+    }
+}

ModernKeePass.Application/Group/Commands/SortEntries/SortEntriesCommand.cs

@@ -0,0 +1,34 @@
+using System.Threading.Tasks;
+using MediatR;
+using ModernKeePass.Application.Common.Interfaces;
+using ModernKeePass.Application.Database.Queries.IsDatabaseOpen;
+using ModernKeePass.Application.Group.Models;
+using ModernKeePass.Domain.Exceptions;
+
+namespace ModernKeePass.Application.Group.Commands.SortEntries
+{
+    public class SortEntriesCommand : IRequest
+    {
+        public GroupVm Group { get; set; }
+
+        public class SortEntriesCommandHandler : IAsyncRequestHandler<SortEntriesCommand>
+        {
+            private readonly IDatabaseProxy _database;
+            private readonly IMediator _mediator;
+
+            public SortEntriesCommandHandler(IDatabaseProxy database, IMediator mediator)
+            {
+                _database = database;
+                _mediator = mediator;
+            }
+
+            public async Task Handle(SortEntriesCommand message)
+            {
+                var isDatabaseOpen = await _mediator.Send(new IsDatabaseOpenQuery());
+                if (!isDatabaseOpen) throw new DatabaseClosedException();
+
+                _database.SortEntries(message.Group.Id);
+            }
+        }
+    }
+}

ModernKeePass.Application/Group/Commands/SortGroups/SortGroupsCommand.cs

@@ -0,0 +1,34 @@
+using System.Threading.Tasks;
+using MediatR;
+using ModernKeePass.Application.Common.Interfaces;
+using ModernKeePass.Application.Database.Queries.IsDatabaseOpen;
+using ModernKeePass.Application.Group.Models;
+using ModernKeePass.Domain.Exceptions;
+
+namespace ModernKeePass.Application.Group.Commands.SortGroups
+{
+    public class SortGroupsCommand : IRequest
+    {
+        public GroupVm Group { get; set; }
+
+        public class SortGroupsCommandHandler : IAsyncRequestHandler<SortGroupsCommand>
+        {
+            private readonly IDatabaseProxy _database;
+            private readonly IMediator _mediator;
+
+            public SortGroupsCommandHandler(IDatabaseProxy database, IMediator mediator)
+            {
+                _database = database;
+                _mediator = mediator;
+            }
+
+            public async Task Handle(SortGroupsCommand message)
+            {
+                var isDatabaseOpen = await _mediator.Send(new IsDatabaseOpenQuery());
+                if (!isDatabaseOpen) throw new DatabaseClosedException();
+
+                _database.SortSubGroups(message.Group.Id);
+            }
+        }
+    }
+}

ModernKeePass.Application/Group/Models/GroupVm.cs

@@ -1,5 +1,5 @@
 using System.Collections.Generic;
-using System.Drawing;
+using System.Linq;
 using AutoMapper;
 using ModernKeePass.Application.Common.Mappings;
 using ModernKeePass.Application.Entry.Models;
@@ -13,8 +13,6 @@ namespace ModernKeePass.Application.Group.Models
         public string Id { get; set; }
         public string Title { get; set; }
         public Icon Icon { get; set; }
-        public Color ForegroundColor { get; set; }
-        public Color BackgroundColor { get; set; }
         public List<GroupVm> SubGroups { get; set; } = new List<GroupVm>();
         public List<EntryVm> Entries { get; set; } = new List<EntryVm>();
 
@@ -24,9 +22,7 @@ namespace ModernKeePass.Application.Group.Models
                 .ForMember(d => d.Id, opts => opts.MapFrom(s => s.Id))
                 .ForMember(d => d.Title, opts => opts.MapFrom(s => s.Name))
                 .ForMember(d => d.Icon, opts => opts.MapFrom(s => s.Icon))
-                .ForMember(d => d.ForegroundColor, opts => opts.MapFrom(s => s.ForegroundColor))
-                .ForMember(d => d.BackgroundColor, opts => opts.MapFrom(s => s.BackgroundColor))
-                .ForMember(d => d.Entries, opts => opts.MapFrom(s => s.Entries))
+                .ForMember(d => d.Entries, opts => opts.MapFrom(s => s.Entries.OrderBy(e => e.Name)))
                 .ForMember(d => d.SubGroups, opts => opts.MapFrom(s => s.SubGroups));
         }
     }