Added lots of commands

Simplified KeePass client

ModernKeePass.Application/Application.csproj

@@ -65,8 +65,19 @@
     <Compile Include="Database\Queries\IsDatabaseOpen\IsDatabaseOpenQuery.cs" />
     <Compile Include="Database\Queries\OpenDatabase\OpenDatabaseQuery.cs" />
     <Compile Include="Database\Queries\OpenDatabase\OpenDatabaseQueryValidator.cs" />
+    <Compile Include="Database\Queries\ReOpenDatabase\ReOpenDatabaseQuery.cs" />
     <Compile Include="DependencyInjection.cs" />
     <Compile Include="Entry\Models\EntryVm.cs" />
+    <Compile Include="Group\Commands\AddEntry\AddEntryCommand.cs" />
+    <Compile Include="Group\Commands\AddGroup\AddGroupCommand.cs" />
+    <Compile Include="Group\Commands\CreateEntry\CreateEntryCommand.cs" />
+    <Compile Include="Group\Commands\CreateGroup\CreateGroupCommand.cs" />
+    <Compile Include="Group\Commands\DeleteEntry\DeleteEntryCommand.cs" />
+    <Compile Include="Group\Commands\DeleteGroup\DeleteGroupCommand.cs" />
+    <Compile Include="Group\Commands\RemoveEntry\RemoveEntryCommand.cs" />
+    <Compile Include="Group\Commands\RemoveGroup\RemoveGroupCommand.cs" />
+    <Compile Include="Group\Commands\SortEntries\SortEntriesCommand.cs" />
+    <Compile Include="Group\Commands\SortGroups\SortGroupsCommand.cs" />
     <Compile Include="Group\Models\GroupVm.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Content Include="Services\CryptographyService.cs" />
@@ -79,14 +90,13 @@
     <Content Include="Services\SettingsService.cs" />
   </ItemGroup>
   <ItemGroup>
-    <Folder Include="Entry\Commands\UpdateEntry\" />
-    <Folder Include="Entry\Queries\" />
-    <Folder Include="Group\Commands\CreateEntry\" />
-    <Folder Include="Group\Commands\CreateGroup\" />
-    <Folder Include="Group\Commands\DeleteEntry\" />
-    <Folder Include="Group\Commands\DeleteGroup\" />
+    <Folder Include="Entry\Commands\SetFieldValue\" />
+    <Folder Include="Entry\Queries\GetEntry\" />
     <Folder Include="Group\Commands\UpdateGroup\" />
-    <Folder Include="Group\Queries\" />
+    <Folder Include="Group\Queries\GetGroup\" />
+    <Folder Include="Parameters\Commands\SetCipher\" />
+    <Folder Include="Parameters\Commands\SetCompression\" />
+    <Folder Include="Parameters\Commands\SetKeyDerivation\" />
     <Folder Include="Resources\Commands\" />
     <Folder Include="Resources\Queries\" />
     <Folder Include="Settings\" />

ModernKeePass.Application/Common/Interfaces/IDatabaseProxy.cs

@@ -8,22 +8,34 @@ namespace ModernKeePass.Application.Common.Interfaces
     {
         bool IsOpen { get; }
         string Name { get; }
-        GroupEntity RecycleBin { get; set; }
-        BaseEntity Cipher { get; set; }
-        BaseEntity KeyDerivation { get; set; }
-        string Compression { get; set; }
+        GroupEntity RootGroup { get; }
 
-        Task<DatabaseEntity> Open(FileInfo fileInfo, Credentials credentials);
-        Task<DatabaseEntity> Create(FileInfo fileInfo, Credentials credentials);
+        string RecycleBinId { get; set; }
+        string CipherId { get; set; }
+        string KeyDerivationId { get; set; }
+        string Compression { get; set; }
+        bool IsRecycleBinEnabled { get; }
+
+        Task<GroupEntity> Open(FileInfo fileInfo, Credentials credentials);
+        Task<GroupEntity> ReOpen();
+        Task<GroupEntity> Create(FileInfo fileInfo, Credentials credentials);
         Task SaveDatabase();
         Task SaveDatabase(FileInfo FileInfo);
         Task UpdateCredentials(Credentials credentials);
         void CloseDatabase();
-        Task AddEntry(GroupEntity parentGroup, EntryEntity entity);
-        Task AddGroup(GroupEntity parentGroup, GroupEntity entity);
-        Task UpdateEntry(EntryEntity entity);
-        Task UpdateGroup(GroupEntity entity);
-        Task DeleteEntry(EntryEntity entity);
-        Task DeleteGroup(GroupEntity entity);
+
+        Task AddEntry(string parentGroupId, string entryId);
+        Task AddGroup(string parentGroupId, string groupId);
+        Task UpdateEntry(string entryId);
+        Task UpdateGroup(string groupId);
+        Task RemoveEntry(string parentGroupId, string entryId);
+        Task RemoveGroup(string parentGroupId, string groupId);
+        EntryEntity CreateEntry(string parentGroupId);
+        GroupEntity CreateGroup(string parentGroupId, string nameId, bool isRecycleBin = false);
+        Task DeleteEntry(string entryId);
+        Task DeleteGroup(string groupId);
+
+        void SortEntries(string groupId);
+        void SortSubGroups(string groupId);
     }
 }

ModernKeePass.Application/Common/Mappings/MappingProfiles.cs

@@ -9,7 +9,6 @@ namespace ModernKeePass.Application.Common.Mappings
     {
         public void ApplyMappings()
         {
-            new DatabaseVm().Mapping(this);
             new EntryVm().Mapping(this);
             new GroupVm().Mapping(this);
         }

ModernKeePass.Application/Database/Commands/CreateDatabase/CreateDatabaseCommand.cs

@@ -2,7 +2,6 @@
 using System.Threading.Tasks;
 using AutoMapper;
 using ModernKeePass.Application.Common.Interfaces;
-using ModernKeePass.Application.Database.Models;
 using ModernKeePass.Application.Database.Queries.IsDatabaseOpen;
 using ModernKeePass.Application.Group.Models;
 using ModernKeePass.Domain.Dtos;
@@ -10,12 +9,12 @@ using ModernKeePass.Domain.Exceptions;
 
 namespace ModernKeePass.Application.Database.Commands.CreateDatabase
 {
-    public class CreateDatabaseCommand : IRequest<DatabaseVm>
+    public class CreateDatabaseCommand : IRequest<GroupVm>
     {
         public FileInfo FileInfo { get; set; }
         public Credentials Credentials { get; set; }
 
-        public class CreateDatabaseCommandHandler : IAsyncRequestHandler<CreateDatabaseCommand, DatabaseVm>
+        public class CreateDatabaseCommandHandler : IAsyncRequestHandler<CreateDatabaseCommand, GroupVm>
         {
             private readonly IDatabaseProxy _database;
             private readonly IMediator _mediator;
@@ -28,19 +27,13 @@ namespace ModernKeePass.Application.Database.Commands.CreateDatabase
                 _mapper = mapper;
             }
 
-            public async Task<DatabaseVm> Handle(CreateDatabaseCommand message)
+            public async Task<GroupVm> Handle(CreateDatabaseCommand message)
             {
                 var isDatabaseOpen = await _mediator.Send(new IsDatabaseOpenQuery());
                 if (isDatabaseOpen) throw new DatabaseOpenException();
 
-                var database = await _database.Create(message.FileInfo, message.Credentials);
-                var databaseVm = new DatabaseVm
-                {
-                    IsOpen = true,
-                    Name = database.Name,
-                    RootGroup = _mapper.Map<GroupVm>(database.RootGroupEntity)
-                };
-                return databaseVm;
+                var rootGroup = await _database.Create(message.FileInfo, message.Credentials);
+                return _mapper.Map<GroupVm>(rootGroup);
             }
 
         }

ModernKeePass.Application/Database/Models/DatabaseVm.cs

@@ -1,21 +1,16 @@
-using AutoMapper;
-using ModernKeePass.Application.Common.Mappings;
-using ModernKeePass.Application.Group.Models;
-using ModernKeePass.Domain.Entities;
+using ModernKeePass.Application.Group.Models;
 
 namespace ModernKeePass.Application.Database.Models
 {
-    public class DatabaseVm: IMapFrom<DatabaseEntity>
+    public class DatabaseVm
     {
         public bool IsOpen { get; set; }
         public string Name { get; set; }
         public GroupVm RootGroup { get; set; }
-
-        public void Mapping(Profile profile)
-        {
-            profile.CreateMap<DatabaseEntity, DatabaseVm>()
-                .ForMember(d => d.Name, opts => opts.MapFrom(s => s.Name))
-                .ForMember(d => d.RootGroup, opts => opts.MapFrom(s => s.RootGroupEntity));
-        }
+        public string RecycleBinId { get; set; }
+        public bool IsRecycleBinEnabled { get; set; }
+        public string Compression { get; set; }
+        public string CipherId { get; set; }
+        public string KeyDerivationId { get; set; }
     }
 }

ModernKeePass.Application/Database/Queries/GetDatabase/GetDatabaseQuery.cs

@@ -1,6 +1,8 @@
-using MediatR;
+using AutoMapper;
+using MediatR;
 using ModernKeePass.Application.Common.Interfaces;
 using ModernKeePass.Application.Database.Models;
+using ModernKeePass.Application.Group.Models;
 
 namespace ModernKeePass.Application.Database.Queries.GetDatabase
 {
@@ -9,10 +11,12 @@ namespace ModernKeePass.Application.Database.Queries.GetDatabase
         public class GetDatabaseQueryHandler : IRequestHandler<GetDatabaseQuery, DatabaseVm>
         {
             private readonly IDatabaseProxy _databaseProxy;
+            private readonly IMapper _mapper;
 
-            public GetDatabaseQueryHandler(IDatabaseProxy databaseProxy)
+            public GetDatabaseQueryHandler(IDatabaseProxy databaseProxy, IMapper mapper)
             {
                 _databaseProxy = databaseProxy;
+                _mapper = mapper;
             }
             
             public DatabaseVm Handle(GetDatabaseQuery request)
@@ -20,7 +24,13 @@ namespace ModernKeePass.Application.Database.Queries.GetDatabase
                 var database = new DatabaseVm
                 {
                     IsOpen = _databaseProxy.IsOpen,
-                    Name = _databaseProxy.Name
+                    Name = _databaseProxy.Name,
+                    RootGroup = _mapper.Map<GroupVm>(_databaseProxy.RootGroup),
+                    IsRecycleBinEnabled = _databaseProxy.IsRecycleBinEnabled,
+                    RecycleBinId = _databaseProxy.RecycleBinId,
+                    Compression = _databaseProxy.Compression,
+                    CipherId = _databaseProxy.CipherId,
+                    KeyDerivationId = _databaseProxy.CipherId
                 };
                 return database;
             }

ModernKeePass.Application/Database/Queries/OpenDatabase/OpenDatabaseQuery.cs

@@ -1,9 +1,7 @@
-using System.Threading;
-using System.Threading.Tasks;
+using System.Threading.Tasks;
 using AutoMapper;
 using MediatR;
 using ModernKeePass.Application.Common.Interfaces;
-using ModernKeePass.Application.Database.Models;
 using ModernKeePass.Application.Database.Queries.IsDatabaseOpen;
 using ModernKeePass.Application.Group.Models;
 using ModernKeePass.Domain.Dtos;
@@ -11,12 +9,12 @@ using ModernKeePass.Domain.Exceptions;
 
 namespace ModernKeePass.Application.Database.Queries.OpenDatabase
 {
-    public class OpenDatabaseQuery: IRequest<DatabaseVm>
+    public class OpenDatabaseQuery: IRequest<GroupVm>
     {
         public FileInfo FileInfo { get; set; }
         public Credentials Credentials { get; set; }
 
-        public class OpenDatabaseQueryHandler : IAsyncRequestHandler<OpenDatabaseQuery, DatabaseVm>
+        public class OpenDatabaseQueryHandler : IAsyncRequestHandler<OpenDatabaseQuery, GroupVm>
         {
             private readonly IMapper _mapper;
             private readonly IMediator _mediator;
@@ -29,19 +27,13 @@ namespace ModernKeePass.Application.Database.Queries.OpenDatabase
                 _databaseProxy = databaseProxy;
             }
 
-            public async Task<DatabaseVm> Handle(OpenDatabaseQuery request)
+            public async Task<GroupVm> Handle(OpenDatabaseQuery request)
             {
                 var isDatabaseOpen = await _mediator.Send(new IsDatabaseOpenQuery());
                 if (isDatabaseOpen) throw new DatabaseOpenException();
 
-                var database = await _databaseProxy.Open(request.FileInfo, request.Credentials);
-                var databaseVm = new DatabaseVm
-                {
-                    IsOpen = true,
-                    Name = database.Name,
-                    RootGroup = _mapper.Map<GroupVm>(database.RootGroupEntity)
-                };
-                return databaseVm;
+                var rootGroup = await _databaseProxy.Open(request.FileInfo, request.Credentials);
+                return _mapper.Map<GroupVm>(rootGroup);
             }
         }
     }

ModernKeePass.Application/Database/Queries/ReOpenDatabase/ReOpenDatabaseQuery.cs

@@ -0,0 +1,36 @@
+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.Database.Queries.ReOpenDatabase
+{
+    public class ReOpenDatabaseQuery: IRequest<GroupVm>
+    {
+        public class ReOpenDatabaseQueryHandler : IAsyncRequestHandler<ReOpenDatabaseQuery, GroupVm>
+        {
+            private readonly IMapper _mapper;
+            private readonly IMediator _mediator;
+            private readonly IDatabaseProxy _databaseProxy;
+
+            public ReOpenDatabaseQueryHandler(IMapper mapper, IMediator mediator, IDatabaseProxy databaseProxy)
+            {
+                _mapper = mapper;
+                _mediator = mediator;
+                _databaseProxy = databaseProxy;
+            }
+
+            public async Task<GroupVm> Handle(ReOpenDatabaseQuery request)
+            {
+                var isDatabaseOpen = await _mediator.Send(new IsDatabaseOpenQuery());
+                if (!isDatabaseOpen) throw new DatabaseClosedException();
+
+                var rootGroup = await _databaseProxy.ReOpen();
+                return _mapper.Map<GroupVm>(rootGroup);
+            }
+        }
+    }
+}

ModernKeePass.Application/Entry/Models/EntryVm.cs

@@ -1,4 +1,6 @@
-using System.Drawing;
+using System;
+using System.Collections.Generic;
+using System.Drawing;
 using AutoMapper;
 using ModernKeePass.Application.Common.Mappings;
 using ModernKeePass.Domain.Entities;
@@ -10,15 +12,33 @@ namespace ModernKeePass.Application.Entry.Models
     {
         public string Id { get; set; }
         public string Title { get; set; }
+        public string Username { get; set; }
+        public string Password { get; set; }
+        public string Notes { get; set; }
+        public Uri Url { get; set; }
+        public Dictionary<string, string> AdditionalFields { get; set; }
+        public IEnumerable<EntryEntity> History { get; set; }
         public Icon Icon { get; set; }
         public Color ForegroundColor { get; set; }
         public Color BackgroundColor { get; set; }
+        public bool HasExpirationDate { get; internal set; }
+        public DateTimeOffset ExpirationDate { get; internal set; }
+        public DateTimeOffset ModificationDate { get; internal set; }
 
         public void Mapping(Profile profile)
         {
             profile.CreateMap<EntryEntity, EntryVm>()
                 .ForMember(d => d.Id, opts => opts.MapFrom(s => s.Id))
                 .ForMember(d => d.Title, opts => opts.MapFrom(s => s.Name))
+                .ForMember(d => d.Username, opts => opts.MapFrom(s => s.UserName))
+                .ForMember(d => d.Password, opts => opts.MapFrom(s => s.Password))
+                .ForMember(d => d.Url, opts => opts.MapFrom(s => s.Url))
+                .ForMember(d => d.Notes, opts => opts.MapFrom(s => s.Notes))
+                .ForMember(d => d.AdditionalFields, opts => opts.MapFrom(s => s.AdditionalFields))
+                .ForMember(d => d.History, opts => opts.MapFrom(s => s.History))
+                .ForMember(d => d.HasExpirationDate, opts => opts.MapFrom(s => s.HasExpirationDate))
+                .ForMember(d => d.ExpirationDate, opts => opts.MapFrom(s => s.ExpirationDate))
+                .ForMember(d => d.ModificationDate, opts => opts.MapFrom(s => s.LastModificationDate))
                 .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));

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));
         }
     }