*BoxWithButton data binding actually work

Set credentials validation works as intended
Getting settings has default values
Add parent group in Move searchbox
Moving entries work as intended
Removed unreferenced code files

.gitignore

@@ -38,4 +38,5 @@ packages/
 project.lock.json
 AppPackages/
 BundleArtifacts/
-*.DotSettings
+*.DotSettings
+/ModernKeePass/Win81App_StoreKey.pfx

ModernKeePass.Application/Application.csproj

@@ -0,0 +1,155 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <PropertyGroup>
+    <MinimumVisualStudioVersion>14.0</MinimumVisualStudioVersion>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProjectGuid>{42353562-5E43-459C-8E3E-2F21E575261D}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>ModernKeePass.Application</RootNamespace>
+    <AssemblyName>ModernKeePass.Application</AssemblyName>
+    <DefaultLanguage>en-US</DefaultLanguage>
+    <FileAlignment>512</FileAlignment>
+    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
+    <TargetFrameworkProfile>
+    </TargetFrameworkProfile>
+    <TargetFrameworkVersion>v5.0</TargetFrameworkVersion>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x64' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\x64\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <PlatformTarget>x64</PlatformTarget>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\x86\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <PlatformTarget>x86</PlatformTarget>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x64' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\x64\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <PlatformTarget>x64</PlatformTarget>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|ARM' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\ARM\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <ItemGroup>
+    <!-- A reference to the entire .NET Framework is automatically included -->
+    <None Include="project.json" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="Common\Behaviors\DirtyStatusBehavior.cs" />
+    <Compile Include="Common\Interfaces\ICryptographyClient.cs" />
+    <Compile Include="Common\Interfaces\IDatabaseProxy.cs" />
+    <Compile Include="Common\Interfaces\IEntityVm.cs" />
+    <Compile Include="Common\Interfaces\IFileProxy.cs" />
+    <Compile Include="Common\Interfaces\IImportFormat.cs" />
+    <Compile Include="Common\Interfaces\ICredentialsProxy.cs" />
+    <Compile Include="Common\Interfaces\INotificationService.cs" />
+    <Compile Include="Common\Interfaces\IRecentProxy.cs" />
+    <Compile Include="Common\Interfaces\IResourceProxy.cs" />
+    <Compile Include="Common\Interfaces\ISettingsProxy.cs" />
+    <Compile Include="Common\Mappings\IMapFrom.cs" />
+    <Compile Include="Common\Mappings\MappingProfile.cs" />
+    <Compile Include="Entry\Commands\AddHistory\AddHistoryCommand.cs" />
+    <Compile Include="Entry\Commands\DeleteHistory\DeleteHistoryCommand.cs" />
+    <Compile Include="Entry\Commands\RestoreHistory\RestoreHistoryCommand.cs" />
+    <Compile Include="Entry\Queries\GetEntry\GetEntryQuery.cs" />
+    <Compile Include="Group\Commands\DeleteEntry\DeleteEntryCommand.cs" />
+    <Compile Include="Group\Commands\DeleteGroup\DeleteGroupCommand.cs" />
+    <Compile Include="Group\Commands\UpdateGroup\UpdateGroupCommand.cs" />
+    <Compile Include="Group\Queries\GetAllGroups\GetAllGroupsQuery.cs" />
+    <Compile Include="Group\Queries\GetGroup\GetGroupQuery.cs" />
+    <Compile Include="Group\Queries\SearchEntries\SearchEntriesQuery.cs" />
+    <Compile Include="Parameters\Commands\SetCipher\SetCipherCommand.cs" />
+    <Compile Include="Parameters\Commands\SetCompression\SetCompressionCommand.cs" />
+    <Compile Include="Parameters\Commands\SetHasRecycleBin\SetHasRecycleBinCommand.cs" />
+    <Compile Include="Parameters\Commands\SetKeyDerivation\SetKeyDerivationCommand.cs" />
+    <Compile Include="Parameters\Commands\SetRecycleBin\SetRecycleBinCommand.cs" />
+    <Compile Include="Parameters\Models\CipherVm.cs" />
+    <Compile Include="Parameters\Models\KeyDerivationVm.cs" />
+    <Compile Include="Parameters\Queries\GetCiphers\GetCiphersQuery.cs" />
+    <Compile Include="Parameters\Queries\GetCompressions\GetCompressionsQuery.cs" />
+    <Compile Include="Parameters\Queries\GetKeyDerivations\GetKeyDerivationsQuery.cs" />
+    <Compile Include="Database\Commands\CloseDatabase\CloseDatabaseCommand.cs" />
+    <Compile Include="Database\Commands\CreateDatabase\CreateDatabaseCommand.cs" />
+    <Compile Include="Database\Commands\CreateDatabase\CreateDatabaseQueryValidator.cs" />
+    <Compile Include="Database\Commands\SaveDatabase\SaveDatabaseCommand.cs" />
+    <Compile Include="Database\Commands\UpdateCredentials\UpdateCredentialsCommand.cs" />
+    <Compile Include="Database\Models\DatabaseVm.cs" />
+    <Compile Include="Database\Queries\GetDatabase\GetDatabaseQuery.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\Commands\SetFieldValue\SetFieldValueCommand.cs" />
+    <Compile Include="Entry\Commands\SetFieldValue\SetFieldValueCommandValidator.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\MoveEntry\MoveEntryCommand.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" />
+    <Compile Include="Security\Commands\GenerateKeyFile\GenerateKeyFileCommand.cs" />
+    <Compile Include="Security\Commands\GeneratePassword\GeneratePasswordCommand.cs" />
+    <Compile Include="Security\Queries\EstimatePasswordComplexity\EstimatePasswordComplexityQuery.cs" />
+  </ItemGroup>
+  <ItemGroup />
+  <ItemGroup>
+    <ProjectReference Include="..\ModernKeePass.Domain\Domain.csproj">
+      <Project>{9a0759f1-9069-4841-99e3-3bec44e17356}</Project>
+      <Name>Domain</Name>
+    </ProjectReference>
+  </ItemGroup>
+  <Import Project="$(MSBuildExtensionsPath32)\Microsoft\Portable\$(TargetFrameworkVersion)\Microsoft.Portable.CSharp.targets" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+</Project>

ModernKeePass.Application/Common/Behaviors/DirtyStatusBehavior.cs

@@ -0,0 +1,35 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using MediatR;
+using ModernKeePass.Application.Common.Interfaces;
+using ModernKeePass.Application.Database.Commands.CloseDatabase;
+using ModernKeePass.Application.Database.Commands.SaveDatabase;
+
+namespace ModernKeePass.Application.Common.Behaviors
+{
+    public class DirtyStatusBehavior<TRequest, TResponse> : IPipelineBehavior<TRequest, TResponse>
+    {
+        private readonly List<string> _excludedCommands = new List<string>
+            {nameof(SaveDatabaseCommand), nameof(CloseDatabaseCommand)};
+
+        private readonly IDatabaseProxy _database;
+
+        public DirtyStatusBehavior(IDatabaseProxy database)
+        {
+            _database = database;
+        }
+
+        public async Task<TResponse> Handle(TRequest request, RequestHandlerDelegate<TResponse> next)
+        {
+            var response = await next();
+            var queryName = typeof(TRequest).Name;
+            if (queryName.Contains("Command"))
+            {
+                _database.IsDirty = !_excludedCommands.Contains(queryName);
+            }
+
+            return response;
+        }
+
+    }
+}

ModernKeePass.Application/Common/Interfaces/ICredentialsProxy.cs

@@ -0,0 +1,11 @@
+using ModernKeePass.Domain.Dtos;
+
+namespace ModernKeePass.Application.Common.Interfaces
+{
+    public interface ICredentialsProxy
+    {
+        string GeneratePassword(PasswordGenerationOptions options);
+        int EstimatePasswordComplexity(string password);
+        byte[] GenerateKeyFile(byte[] additionalEntropy);
+    }
+}

ModernKeePass.Application/Common/Interfaces/ICryptographyClient.cs

@@ -0,0 +1,12 @@
+using System.Collections.Generic;
+using ModernKeePass.Domain.Entities;
+
+namespace ModernKeePass.Application.Common.Interfaces
+{
+    public interface ICryptographyClient
+    {
+        IEnumerable<BaseEntity> Ciphers { get; }
+        IEnumerable<BaseEntity> KeyDerivations { get; }
+        IEnumerable<string> CompressionAlgorithms { get; }
+    }
+}

ModernKeePass.Application/Common/Interfaces/IDatabaseProxy.cs

@@ -0,0 +1,56 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using ModernKeePass.Domain.Dtos;
+using ModernKeePass.Domain.Entities;
+using ModernKeePass.Domain.Enums;
+
+namespace ModernKeePass.Application.Common.Interfaces
+{
+    public interface IDatabaseProxy
+    {
+        // PW Database properties
+        bool IsOpen { get; }
+        string Name { get; }
+        string RootGroupId { get; }
+        string RecycleBinId { get; set; }
+        string CipherId { get; set; }
+        string KeyDerivationId { get; set; }
+        string Compression { get; set; }
+        bool IsRecycleBinEnabled { get; set; }
+
+        // Custom properties
+        string FileAccessToken { get; set; }
+        int Size { get; set; }
+        bool IsDirty { get; set; }
+
+        Task Open(byte[] file, Credentials credentials);
+        Task ReOpen(byte[] file);
+        Task Create(Credentials credentials, string name, DatabaseVersion version = DatabaseVersion.V3);
+        Task<byte[]> SaveDatabase();
+        Task<byte[]> SaveDatabase(byte[] newFileContents);
+        void UpdateCredentials(Credentials credentials);
+        void CloseDatabase();
+
+        EntryEntity GetEntry(string id);
+        GroupEntity GetGroup(string id); 
+        Task AddEntry(string parentGroupId, string entryId);
+        Task MoveEntry(string parentGroupId, string entryId, int index);
+        Task AddGroup(string parentGroupId, string groupId);
+        void UpdateEntry(string entryId, string fieldName, object fieldValue);
+        void UpdateGroup(GroupEntity group);
+        Task RemoveEntry(string parentGroupId, string entryId);
+        Task RemoveGroup(string parentGroupId, string groupId);
+        void DeleteEntity(string entityId);
+        EntryEntity CreateEntry(string parentGroupId);
+        GroupEntity CreateGroup(string parentGroupId, string name, bool isRecycleBin = false);
+        void SortEntries(string groupId);
+        void SortSubGroups(string groupId);
+
+        EntryEntity AddHistory(string entryId);
+        EntryEntity RestoreFromHistory(string entryId, int historyIndex);
+        void DeleteHistory(string entryId, int historyIndex);
+
+        IEnumerable<EntryEntity> Search(string groupId, string text);
+        IEnumerable<BaseEntity> GetAllGroups(string groupId);
+    }
+}

ModernKeePass.Application/Common/Interfaces/IEntityVm.cs

@@ -0,0 +1,13 @@
+using ModernKeePass.Domain.Enums;
+
+namespace ModernKeePass.Application.Common.Interfaces
+{
+    public interface IEntityVm
+    {
+        string Id { get; set; }
+        string Title { get; set; }
+        Icon Icon { get; set; }
+        string ParentGroupId { get; set; }
+        string ParentGroupName { get; set; }
+    }
+}

ModernKeePass.Application/Common/Interfaces/IFileProxy.cs

@@ -0,0 +1,13 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+
+namespace ModernKeePass.Application.Common.Interfaces
+{
+    public interface IFileProxy
+    {
+        Task<byte[]> OpenBinaryFile(string path);
+        Task<IList<string>> OpenTextFile(string path);
+        Task WriteBinaryContentsToFile(string path, byte[] contents);
+        void ReleaseFile(string path);
+    }
+}

ModernKeePass.Application/Common/Interfaces/IImportFormat.cs

@@ -0,0 +1,9 @@
+using System.Collections.Generic;
+
+namespace ModernKeePass.Application.Common.Interfaces
+{
+    public interface IImportFormat
+    {
+        List<Dictionary<string, string>> Import(IList<string> fileContents);
+    }
+}

ModernKeePass.Application/Common/Interfaces/INotificationService.cs

@@ -0,0 +1,7 @@
+namespace ModernKeePass.Application.Common.Interfaces
+{
+    public interface INotificationService
+    {
+        void Show(string title, string text);
+    }
+}

ModernKeePass.Application/Common/Interfaces/IRecentProxy.cs

@@ -0,0 +1,12 @@
+using System.Collections.Generic;
+using ModernKeePass.Domain.Dtos;
+
+namespace ModernKeePass.Application.Common.Interfaces
+{
+    public interface IRecentProxy
+    {
+        int EntryCount { get; }
+        IEnumerable<FileInfo> GetAll();
+        void ClearAll();
+    }
+}

ModernKeePass.Application/Common/Interfaces/IResourceProxy.cs

@@ -0,0 +1,7 @@
+namespace ModernKeePass.Application.Common.Interfaces
+{
+    public interface IResourceProxy
+    {
+        string GetResourceValue(string key);
+    }
+}

ModernKeePass.Application/Common/Interfaces/ISettingsProxy.cs

@@ -0,0 +1,8 @@
+namespace ModernKeePass.Application.Common.Interfaces
+{
+    public interface ISettingsProxy
+    {
+        T GetSetting<T>(string property, T defaultValue = default(T));
+        void PutSetting<T>(string property, T value);
+    }
+}

ModernKeePass.Application/Common/Mappings/IMapFrom.cs

@@ -0,0 +1,10 @@
+using AutoMapper;
+
+namespace ModernKeePass.Application.Common.Mappings
+{
+
+    public interface IMapFrom<T>
+    {
+        void Mapping(Profile profile);
+    }
+}

ModernKeePass.Application/Common/Mappings/MappingProfile.cs

@@ -0,0 +1,30 @@
+using System;
+using System.Linq;
+using System.Reflection;
+using AutoMapper;
+
+namespace ModernKeePass.Application.Common.Mappings
+{
+    public class MappingProfile : Profile
+    {
+        public MappingProfile()
+        {
+            ApplyMappingsFromAssembly(typeof(MappingProfile).GetTypeInfo().Assembly);
+        }
+
+        private void ApplyMappingsFromAssembly(Assembly assembly)
+        {
+            var types = assembly.ExportedTypes
+                .Where(t => t.GetTypeInfo().ImplementedInterfaces.Any(i =>
+                    i.GetTypeInfo().IsGenericType && i.GetGenericTypeDefinition() == typeof(IMapFrom<>)))
+                .ToList();
+
+            foreach (var type in types)
+            {
+                var instance = Activator.CreateInstance(type);
+                var methodInfo = type.GetTypeInfo().GetDeclaredMethod("Mapping");
+                methodInfo?.Invoke(instance, new object[] { this });
+            }
+        }
+    }
+}

ModernKeePass.Application/Database/Commands/CloseDatabase/CloseDatabaseCommand.cs

@@ -0,0 +1,28 @@
+using MediatR;
+using ModernKeePass.Application.Common.Interfaces;
+using ModernKeePass.Domain.Exceptions;
+
+namespace ModernKeePass.Application.Database.Commands.CloseDatabase
+{
+    public class CloseDatabaseCommand: IRequest
+    {
+        public class CloseDatabaseCommandHandler : IRequestHandler<CloseDatabaseCommand>
+        {
+            private readonly IDatabaseProxy _database;
+
+            public CloseDatabaseCommandHandler(IDatabaseProxy database)
+            {
+                _database = database;
+            }
+            public void Handle(CloseDatabaseCommand message)
+            {
+                if (!_database.IsOpen) throw new DatabaseClosedException();
+                _database.CloseDatabase();
+
+                // Cleanup
+                _database.FileAccessToken = null;
+                _database.Size = 0;
+            }
+        }
+    }
+}

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

@@ -0,0 +1,82 @@
+using MediatR;
+using System.Threading.Tasks;
+using ModernKeePass.Application.Common.Interfaces;
+using ModernKeePass.Domain.Dtos;
+using ModernKeePass.Domain.Exceptions;
+using ModernKeePass.Domain.Enums;
+
+namespace ModernKeePass.Application.Database.Commands.CreateDatabase
+{
+    public class CreateDatabaseCommand : IRequest
+    {
+        public string FilePath { get; set; }
+        public string Password { get; set; }
+        public string KeyFilePath { get; set; }
+        public string Name { get; set; }
+        public string Version { get; set; }
+        public bool CreateSampleData { get; set; }
+
+        public class CreateDatabaseCommandHandler : IAsyncRequestHandler<CreateDatabaseCommand>
+        {
+            private readonly IDatabaseProxy _database;
+            private readonly IFileProxy _file;
+
+            public CreateDatabaseCommandHandler(IDatabaseProxy database, IFileProxy file)
+            {
+                _database = database;
+                _file = file;
+            }
+
+            public async Task Handle(CreateDatabaseCommand message)
+            {
+                if (_database.IsDirty) throw new DatabaseOpenException();
+
+                var version = DatabaseVersion.V2;
+                switch (message.Version)
+                {
+                    case "4":
+                        version = DatabaseVersion.V4;
+                        break;
+                    case "3":
+                        version = DatabaseVersion.V3;
+                        break;
+                }
+
+                await _database.Create(new Credentials
+                    {
+                        KeyFileContents = !string.IsNullOrEmpty(message.KeyFilePath) ? await _file.OpenBinaryFile(message.KeyFilePath) : null,
+                        Password = message.Password
+                    }, message.Name, version);
+                _database.FileAccessToken = message.FilePath;
+
+                if (message.CreateSampleData)
+                {
+                    var bankingGroup = _database.CreateGroup(_database.RootGroupId, "Banking");
+                    bankingGroup.Icon = Icon.Shop;
+                    _database.UpdateGroup(bankingGroup);
+
+                    var emailGroup = _database.CreateGroup(_database.RootGroupId, "Email");
+                    emailGroup.Icon = Icon.Mail;
+                    _database.UpdateGroup(emailGroup);
+
+                    var internetGroup = _database.CreateGroup(_database.RootGroupId, "Internet");
+                    internetGroup.Icon = Icon.World;
+                    _database.UpdateGroup(internetGroup);
+
+                    var sample1 = _database.CreateEntry(_database.RootGroupId);
+                    _database.UpdateEntry(sample1.Id, EntryFieldName.Title, "Sample Entry" );
+                    _database.UpdateEntry(sample1.Id, EntryFieldName.UserName, "Username" );
+                    _database.UpdateEntry(sample1.Id, EntryFieldName.Password, "Password" );
+                    _database.UpdateEntry(sample1.Id, EntryFieldName.Url, "https://keepass.info/" );
+                    _database.UpdateEntry(sample1.Id, EntryFieldName.Notes, "You may safely delete this sample" );
+
+                    var sample2 = _database.CreateEntry(_database.RootGroupId);
+                    _database.UpdateEntry(sample2.Id, EntryFieldName.Title, "Sample Entry #2" );
+                    _database.UpdateEntry(sample2.Id, EntryFieldName.UserName, "Michael321" );
+                    _database.UpdateEntry(sample2.Id, EntryFieldName.Password, "12345" );
+                    _database.UpdateEntry(sample2.Id, EntryFieldName.Url, "https://keepass.info/help/kb/testform.html" );
+                }
+            }
+        }
+    }
+}

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

@@ -0,0 +1,22 @@
+using FluentValidation;
+
+namespace ModernKeePass.Application.Database.Commands.CreateDatabase
+{
+    public class CreateDatabaseQueryValidator : AbstractValidator<CreateDatabaseCommand>
+    {
+        public CreateDatabaseQueryValidator()
+        {
+            RuleFor(v => v.FilePath)
+                .NotNull()
+                .NotEmpty();
+            RuleFor(v => v.Password)
+                .NotNull()
+                .NotEmpty()
+                .When(v => string.IsNullOrEmpty(v.KeyFilePath));
+            RuleFor(v => v.KeyFilePath)
+                .NotNull()
+                .NotEmpty()
+                .When(v => string.IsNullOrEmpty(v.Password));
+        }
+    }
+}

ModernKeePass.Application/Database/Commands/SaveDatabase/SaveDatabaseCommand.cs

@@ -0,0 +1,58 @@
+using System;
+using MediatR;
+using System.Threading.Tasks;
+using ModernKeePass.Application.Common.Interfaces;
+using ModernKeePass.Domain.Exceptions;
+
+namespace ModernKeePass.Application.Database.Commands.SaveDatabase
+{
+    public class SaveDatabaseCommand : IRequest
+    {
+        public string FilePath { get; set; }
+
+        public class SaveDatabaseCommandHandler : IAsyncRequestHandler<SaveDatabaseCommand>
+        {
+            private readonly IDatabaseProxy _database;
+            private readonly IFileProxy _file;
+
+            public SaveDatabaseCommandHandler(IDatabaseProxy database, IFileProxy file)
+            {
+                _database = database;
+                _file = file;
+            }
+
+            public async Task Handle(SaveDatabaseCommand message)
+            {
+                if (!_database.IsOpen) throw new DatabaseClosedException();
+
+                try
+                {
+                    byte[] contents;
+                    if (string.IsNullOrEmpty(message.FilePath))
+                    {
+                        contents = await _database.SaveDatabase();
+
+                        // Test DB integrity before writing changes to file
+                        _database.CloseDatabase();
+                        await _database.ReOpen(contents);
+
+                        await _file.WriteBinaryContentsToFile(_database.FileAccessToken, contents);
+                    }
+                    else
+                    {
+                        var newFileContents = await _file.OpenBinaryFile(message.FilePath);
+                        contents = await _database.SaveDatabase(newFileContents);
+                        await _file.WriteBinaryContentsToFile(message.FilePath, contents);
+
+                        _file.ReleaseFile(_database.FileAccessToken);
+                        _database.FileAccessToken = message.FilePath;
+                    }
+                }
+                catch (Exception exception)
+                {
+                    throw new SaveException(exception);
+                }
+            }
+        }
+    }
+}

ModernKeePass.Application/Database/Commands/UpdateCredentials/UpdateCredentialsCommand.cs

@@ -0,0 +1,36 @@
+using System.Threading.Tasks;
+using MediatR;
+using ModernKeePass.Application.Common.Interfaces;
+using ModernKeePass.Domain.Dtos;
+using ModernKeePass.Domain.Exceptions;
+
+namespace ModernKeePass.Application.Database.Commands.UpdateCredentials
+{
+    public class UpdateCredentialsCommand: IRequest
+    {
+        public string Password { get; set; }
+        public string KeyFilePath { get; set; }
+
+        public class UpdateCredentialsCommandHandler : IAsyncRequestHandler<UpdateCredentialsCommand>
+        {
+            private readonly IDatabaseProxy _database;
+            private readonly IFileProxy _file;
+
+            public UpdateCredentialsCommandHandler(IDatabaseProxy database, IFileProxy file)
+            {
+                _database = database;
+                _file = file;
+            }
+
+            public async Task Handle(UpdateCredentialsCommand message)
+            {
+                if (!_database.IsOpen) throw new DatabaseClosedException();
+                _database.UpdateCredentials(new Credentials
+                {
+                    KeyFileContents = !string.IsNullOrEmpty(message.KeyFilePath) ? await _file.OpenBinaryFile(message.KeyFilePath) : null,
+                    Password = message.Password
+                });
+            }
+        }
+    }
+}

ModernKeePass.Application/Database/Models/DatabaseVm.cs

@@ -0,0 +1,16 @@
+namespace ModernKeePass.Application.Database.Models
+{
+    public class DatabaseVm
+    {
+        public bool IsOpen { get; set; }
+        public string Name { get; set; }
+        public string RootGroupId { get; set; }
+        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; }
+        public int Size { get; internal set; }
+        public bool IsDirty { get; internal set; }
+    }
+}

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

@@ -0,0 +1,41 @@
+using MediatR;
+using ModernKeePass.Application.Common.Interfaces;
+using ModernKeePass.Application.Database.Models;
+using ModernKeePass.Domain.Common;
+
+namespace ModernKeePass.Application.Database.Queries.GetDatabase
+{
+    public class GetDatabaseQuery: IRequest<DatabaseVm>
+    {
+        public class GetDatabaseQueryHandler : IRequestHandler<GetDatabaseQuery, DatabaseVm>
+        {
+            private readonly IDatabaseProxy _databaseProxy;
+
+            public GetDatabaseQueryHandler(IDatabaseProxy databaseProxy)
+            {
+                _databaseProxy = databaseProxy;
+            }
+            
+            public DatabaseVm Handle(GetDatabaseQuery message)
+            {
+                var database = new DatabaseVm
+                {
+                    IsOpen = _databaseProxy.IsOpen
+                };
+                if (database.IsOpen)
+                {
+                    database.Name = _databaseProxy.Name;
+                    database.RootGroupId = _databaseProxy.RootGroupId;
+                    database.IsRecycleBinEnabled = _databaseProxy.IsRecycleBinEnabled;
+                    database.RecycleBinId = _databaseProxy.RecycleBinId == Constants.EmptyId ? null : _databaseProxy.RecycleBinId;
+                    database.Compression = _databaseProxy.Compression;
+                    database.CipherId = _databaseProxy.CipherId;
+                    database.KeyDerivationId = _databaseProxy.KeyDerivationId;
+                    database.Size = _databaseProxy.Size;
+                    database.IsDirty = _databaseProxy.IsDirty;
+                }
+                return database;
+            }
+        }
+    }
+}

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

@@ -0,0 +1,43 @@
+using System.Threading.Tasks;
+using MediatR;
+using ModernKeePass.Application.Common.Interfaces;
+using ModernKeePass.Domain.Dtos;
+using ModernKeePass.Domain.Exceptions;
+
+namespace ModernKeePass.Application.Database.Queries.OpenDatabase
+{
+    public class OpenDatabaseQuery: IRequest
+    {
+        public string FilePath { get; set; }
+        public string Password { get; set; }
+        public string KeyFilePath { get; set; }
+
+        public class OpenDatabaseQueryHandler : IAsyncRequestHandler<OpenDatabaseQuery>
+        {
+            private readonly IDatabaseProxy _database;
+            private readonly IFileProxy _file;
+
+            public OpenDatabaseQueryHandler(IDatabaseProxy database, IFileProxy file)
+            {
+                _database = database;
+                _file = file;
+            }
+
+            public async Task Handle(OpenDatabaseQuery message)
+            {
+                if (_database.IsDirty) throw new DatabaseOpenException();
+                
+                var file = await _file.OpenBinaryFile(message.FilePath);
+                var hasKeyFile = !string.IsNullOrEmpty(message.KeyFilePath);
+                await _database.Open(file, new Credentials
+                    {
+                        KeyFileContents = hasKeyFile ? await _file.OpenBinaryFile(message.KeyFilePath): null,
+                        Password = message.Password
+                    });
+                if (hasKeyFile) _file.ReleaseFile(message.KeyFilePath);
+                _database.Size = file.Length;
+                _database.FileAccessToken = message.FilePath;
+            }
+        }
+    }
+}

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

@@ -0,0 +1,22 @@
+using FluentValidation;
+
+namespace ModernKeePass.Application.Database.Queries.OpenDatabase
+{
+    public class OpenDatabaseQueryValidator : AbstractValidator<OpenDatabaseQuery>
+    {
+        public OpenDatabaseQueryValidator()
+        {
+            RuleFor(v => v.FilePath)
+                .NotNull()
+                .NotEmpty();
+            RuleFor(v => v.Password)
+                .NotNull()
+                .NotEmpty()
+                .When(v => string.IsNullOrEmpty(v.KeyFilePath));
+            RuleFor(v => v.KeyFilePath)
+                .NotNull()
+                .NotEmpty()
+                .When(v => string.IsNullOrEmpty(v.Password));
+        }
+    }
+}

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

@@ -0,0 +1,30 @@
+using System.Threading.Tasks;
+using MediatR;
+using ModernKeePass.Application.Common.Interfaces;
+using ModernKeePass.Domain.Exceptions;
+
+namespace ModernKeePass.Application.Database.Queries.ReOpenDatabase
+{
+    public class ReOpenDatabaseQuery: IRequest
+    {
+        public class ReOpenDatabaseQueryHandler : IAsyncRequestHandler<ReOpenDatabaseQuery>
+        {
+            private readonly IDatabaseProxy _database;
+            private readonly IFileProxy _file;
+
+            public ReOpenDatabaseQueryHandler(IDatabaseProxy database, IFileProxy file)
+            {
+                _database = database;
+                _file = file;
+            }
+
+            public async Task Handle(ReOpenDatabaseQuery message)
+            {
+                if (!_database.IsOpen) throw new DatabaseClosedException();
+
+                var file = await _file.OpenBinaryFile(_database.FileAccessToken);
+                await _database.ReOpen(file);
+            }
+        }
+    }
+}

ModernKeePass.Application/DependencyInjection.cs

@@ -0,0 +1,21 @@
+using System.Reflection;
+using FluentValidation;
+using MediatR;
+using Microsoft.Extensions.DependencyInjection;
+using ModernKeePass.Application.Common.Behaviors;
+
+namespace ModernKeePass.Application
+{
+    public static class DependencyInjection
+    {
+        public static IServiceCollection AddApplication(this IServiceCollection services)
+        {
+            var assembly = typeof(DependencyInjection).GetTypeInfo().Assembly;
+            services.AddMediatR(assembly);
+            services.AddTransient(typeof(IPipelineBehavior<,>), typeof(DirtyStatusBehavior<,>));
+            //services.AddValidatorsFromAssembly(assembly);
+
+            return services;
+        }
+    }
+}

ModernKeePass.Application/Entry/Commands/AddHistory/AddHistoryCommand.cs

@@ -0,0 +1,33 @@
+using AutoMapper;
+using MediatR;
+using ModernKeePass.Application.Common.Interfaces;
+using ModernKeePass.Application.Entry.Models;
+using ModernKeePass.Domain.Exceptions;
+
+namespace ModernKeePass.Application.Entry.Commands.AddHistory
+{
+    public class AddHistoryCommand : IRequest
+    {
+        public EntryVm Entry { get; set; }
+
+        public class AddHistoryCommandHandler : IRequestHandler<AddHistoryCommand>
+        {
+            private readonly IDatabaseProxy _database;
+            private readonly IMapper _mapper;
+
+            public AddHistoryCommandHandler(IDatabaseProxy database, IMapper mapper)
+            {
+                _database = database;
+                _mapper = mapper;
+            }
+
+            public void Handle(AddHistoryCommand message)
+            {
+                if (!_database.IsOpen) throw new DatabaseClosedException();
+
+                var history = _database.AddHistory(message.Entry.Id);
+                message.Entry.History.Add(_mapper.Map<EntryVm>(history));
+            }
+        }
+    }
+}

ModernKeePass.Application/Entry/Commands/DeleteHistory/DeleteHistoryCommand.cs

@@ -0,0 +1,31 @@
+using MediatR;
+using ModernKeePass.Application.Common.Interfaces;
+using ModernKeePass.Application.Entry.Models;
+using ModernKeePass.Domain.Exceptions;
+
+namespace ModernKeePass.Application.Entry.Commands.DeleteHistory
+{
+    public class DeleteHistoryCommand : IRequest
+    {
+        public EntryVm Entry { get; set; }
+        public int HistoryIndex { get; set; }
+
+        public class DeleteHistoryCommandHandler : IRequestHandler<DeleteHistoryCommand>
+        {
+            private readonly IDatabaseProxy _database;
+
+            public DeleteHistoryCommandHandler(IDatabaseProxy database)
+            {
+                _database = database;
+            }
+
+            public void Handle(DeleteHistoryCommand message)
+            {
+                if (!_database.IsOpen) throw new DatabaseClosedException();
+
+                _database.DeleteHistory(message.Entry.Id, message.HistoryIndex);
+                message.Entry.History.RemoveAt(message.HistoryIndex);
+            }
+        }
+    }
+}

ModernKeePass.Application/Entry/Commands/RestoreHistory/RestoreHistoryCommand.cs

@@ -0,0 +1,34 @@
+using AutoMapper;
+using MediatR;
+using ModernKeePass.Application.Common.Interfaces;
+using ModernKeePass.Application.Entry.Models;
+using ModernKeePass.Domain.Exceptions;
+
+namespace ModernKeePass.Application.Entry.Commands.RestoreHistory
+{
+    public class RestoreHistoryCommand : IRequest
+    {
+        public EntryVm Entry { get; set; }
+        public int HistoryIndex { get; set; }
+
+        public class RestoreHistoryCommandHandler : IRequestHandler<RestoreHistoryCommand>
+        {
+            private readonly IDatabaseProxy _database;
+            private readonly IMapper _mapper;
+
+            public RestoreHistoryCommandHandler(IDatabaseProxy database, IMapper mapper)
+            {
+                _database = database;
+                _mapper = mapper;
+            }
+
+            public void Handle(RestoreHistoryCommand message)
+            {
+                if (!_database.IsOpen) throw new DatabaseClosedException();
+
+                var entry = _database.RestoreFromHistory(message.Entry.Id, message.HistoryIndex);
+                message.Entry = _mapper.Map<EntryVm>(entry);
+            }
+        }
+    }
+}

ModernKeePass.Application/Entry/Commands/SetFieldValue/SetFieldValueCommand.cs

@@ -0,0 +1,30 @@
+using MediatR;
+using ModernKeePass.Application.Common.Interfaces;
+using ModernKeePass.Domain.Exceptions;
+
+namespace ModernKeePass.Application.Entry.Commands.SetFieldValue
+{
+    public class SetFieldValueCommand : IRequest
+    {
+        public string EntryId { get; set; }
+        public string FieldName { get; set; }
+        public object FieldValue { get; set; }
+
+        public class SetFieldValueCommandHandler : IRequestHandler<SetFieldValueCommand>
+        {
+            private readonly IDatabaseProxy _database;
+
+            public SetFieldValueCommandHandler(IDatabaseProxy database)
+            {
+                _database = database;
+            }
+
+            public void Handle(SetFieldValueCommand message)
+            {
+                if (!_database.IsOpen) throw new DatabaseClosedException();
+
+                _database.UpdateEntry(message.EntryId, message.FieldName, message.FieldValue);
+            }
+        }
+    }
+}

ModernKeePass.Application/Entry/Commands/SetFieldValue/SetFieldValueCommandValidator.cs

@@ -0,0 +1,17 @@
+using FluentValidation;
+
+namespace ModernKeePass.Application.Entry.Commands.SetFieldValue
+{
+    public class SetFieldValueCommandValidator: AbstractValidator<SetFieldValueCommand>
+    {
+        public SetFieldValueCommandValidator()
+        {
+            RuleFor(v => v.EntryId)
+                .NotNull()
+                .NotEmpty();
+            RuleFor(v => v.FieldName)
+                .NotNull()
+                .NotEmpty();
+        }
+    }
+}

ModernKeePass.Application/Entry/Models/EntryVm.cs

@@ -0,0 +1,59 @@
+using System;
+using System.Collections.Generic;
+using System.Drawing;
+using System.Linq;
+using AutoMapper;
+using ModernKeePass.Application.Common.Interfaces;
+using ModernKeePass.Application.Common.Mappings;
+using ModernKeePass.Domain.Entities;
+using ModernKeePass.Domain.Enums;
+
+namespace ModernKeePass.Application.Entry.Models
+{
+    public class EntryVm: IEntityVm, IMapFrom<EntryEntity>
+    {
+        public string ParentGroupId { get; set; }
+        public string ParentGroupName { get; set; }
+        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 string Url { get; set; }
+        public bool HasUrl => !string.IsNullOrEmpty(Url);
+        public Dictionary<string, string> AdditionalFields { get; set; }
+        public List<EntryVm> History { get; set; }
+        public Icon Icon { get; set; }
+        public Color ForegroundColor { get; set; }
+        public Color BackgroundColor { get; set; }
+        public bool HasExpirationDate { get; set; }
+        public DateTimeOffset ExpirationDate { get; set; }
+        public DateTimeOffset ModificationDate { get; set; }
+
+        public override string ToString()
+        {
+            return ModificationDate.ToString("g");
+        }
+
+        public void Mapping(Profile profile)
+        {
+            profile.CreateMap<EntryEntity, EntryVm>()
+                .ForMember(d => d.ParentGroupId, opts => opts.MapFrom(s => s.ParentId))
+                .ForMember(d => d.ParentGroupName, opts => opts.MapFrom(s => s.ParentName))
+                .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.Reverse()))
+                .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.HasExpirationDate && s.ExpirationDate < DateTimeOffset.Now ? Icon.ReportHacked : s.Icon))
+                .ForMember(d => d.ForegroundColor, opts => opts.MapFrom(s => s.ForegroundColor))
+                .ForMember(d => d.BackgroundColor, opts => opts.MapFrom(s => s.BackgroundColor));
+        }
+    }
+}

ModernKeePass.Application/Entry/Queries/GetEntry/GetEntryQuery.cs

@@ -0,0 +1,31 @@
+using AutoMapper;
+using MediatR;
+using ModernKeePass.Application.Common.Interfaces;
+using ModernKeePass.Application.Entry.Models;
+using ModernKeePass.Domain.Exceptions;
+
+namespace ModernKeePass.Application.Entry.Queries.GetEntry
+{
+    public class GetEntryQuery: IRequest<EntryVm>
+    {
+        public string Id { get; set; }
+
+        public class GetEntryQueryHandler: IRequestHandler<GetEntryQuery, EntryVm>
+        {
+            private readonly IDatabaseProxy _database;
+            private readonly IMapper _mapper;
+
+            public GetEntryQueryHandler(IDatabaseProxy database, IMapper mapper)
+            {
+                _database = database;
+                _mapper = mapper;
+            }
+
+            public EntryVm Handle(GetEntryQuery message)
+            {
+                if (!_database.IsOpen) throw new DatabaseClosedException();
+                return _mapper.Map<EntryVm>(_database.GetEntry(message.Id));
+            }
+        }
+    }
+}

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

@@ -0,0 +1,31 @@
+using System.Threading.Tasks;
+using MediatR;
+using ModernKeePass.Application.Common.Interfaces;
+using ModernKeePass.Domain.Exceptions;
+
+namespace ModernKeePass.Application.Group.Commands.AddEntry
+{
+    public class AddEntryCommand : IRequest
+    {
+        public string ParentGroupId { get; set; }
+        public string EntryId { get; set; }
+
+        public class AddEntryCommandHandler : IAsyncRequestHandler<AddEntryCommand>
+        {
+            private readonly IDatabaseProxy _database;
+
+            public AddEntryCommandHandler(IDatabaseProxy database)
+            {
+                _database = database;
+            }
+
+            public async Task Handle(AddEntryCommand message)
+            {
+                if (!_database.IsOpen) throw new DatabaseClosedException();
+
+                await _database.AddEntry(message.ParentGroupId, message.EntryId);
+                //message.ParentGroup.Entries.Add(message.Entry);
+            }
+        }
+    }
+}

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

@@ -0,0 +1,31 @@
+using System.Threading.Tasks;
+using MediatR;
+using ModernKeePass.Application.Common.Interfaces;
+using ModernKeePass.Domain.Exceptions;
+
+namespace ModernKeePass.Application.Group.Commands.AddGroup
+{
+    public class AddGroupCommand : IRequest
+    {
+        public string ParentGroupId { get; set; }
+        public string GroupId { get; set; }
+
+        public class AddGroupCommandHandler : IAsyncRequestHandler<AddGroupCommand>
+        {
+            private readonly IDatabaseProxy _database;
+
+            public AddGroupCommandHandler(IDatabaseProxy database)
+            {
+                _database = database;
+            }
+
+            public async Task Handle(AddGroupCommand message)
+            {
+                if (!_database.IsOpen) throw new DatabaseClosedException();
+
+                await _database.AddGroup(message.ParentGroupId, message.GroupId);
+                //message.ParentGroup.SubGroups.Add(message.Group);
+            }
+        }
+    }
+}

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

@@ -0,0 +1,36 @@
+using AutoMapper;
+using MediatR;
+using ModernKeePass.Application.Common.Interfaces;
+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 : IRequestHandler<CreateEntryCommand, EntryVm>
+        {
+            private readonly IDatabaseProxy _database;
+            private readonly IMapper _mapper;
+
+            public CreateEntryCommandHandler(IDatabaseProxy database, IMapper mapper)
+            {
+                _database = database;
+                _mapper = mapper;
+            }
+
+            public EntryVm Handle(CreateEntryCommand message)
+            {
+                if (!_database.IsOpen) 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,37 @@
+using AutoMapper;
+using MediatR;
+using ModernKeePass.Application.Common.Interfaces;
+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 : IRequestHandler<CreateGroupCommand, GroupVm>
+        {
+            private readonly IDatabaseProxy _database;
+            private readonly IMapper _mapper;
+
+            public CreateGroupCommandHandler(IDatabaseProxy database, IMapper mapper)
+            {
+                _database = database;
+                _mapper = mapper;
+            }
+
+            public GroupVm Handle(CreateGroupCommand message)
+            {
+                if (!_database.IsOpen) 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,46 @@
+using System.Threading.Tasks;
+using MediatR;
+using ModernKeePass.Application.Common.Interfaces;
+using ModernKeePass.Domain.Common;
+using ModernKeePass.Domain.Exceptions;
+
+namespace ModernKeePass.Application.Group.Commands.DeleteEntry
+{
+    public class DeleteEntryCommand : IRequest
+    {
+        public string ParentGroupId { get; set; }
+        public string EntryId { get; set; }
+        public string RecycleBinName { get; set; }
+
+        public class DeleteEntryCommandHandler : IAsyncRequestHandler<DeleteEntryCommand>
+        {
+            private readonly IDatabaseProxy _database;
+
+            public DeleteEntryCommandHandler(IDatabaseProxy database)
+            {
+                _database = database;
+            }
+
+            public async Task Handle(DeleteEntryCommand message)
+            {
+                if (!_database.IsOpen) throw new DatabaseClosedException();
+
+                if (_database.IsRecycleBinEnabled && (string.IsNullOrEmpty(_database.RecycleBinId) || _database.RecycleBinId.Equals(Constants.EmptyId)))
+                {
+                    _database.CreateGroup(_database.RootGroupId, message.RecycleBinName, true);
+                }
+
+                if (!_database.IsRecycleBinEnabled || message.ParentGroupId.Equals(_database.RecycleBinId))
+                {
+                    _database.DeleteEntity(message.EntryId);
+                }
+                else
+                {
+                    await _database.AddEntry(_database.RecycleBinId, message.EntryId);
+                }
+
+                await _database.RemoveEntry(message.ParentGroupId, message.EntryId);
+            }
+        }
+    }
+}

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

@@ -0,0 +1,46 @@
+using System.Threading.Tasks;
+using MediatR;
+using ModernKeePass.Application.Common.Interfaces;
+using ModernKeePass.Domain.Common;
+using ModernKeePass.Domain.Exceptions;
+
+namespace ModernKeePass.Application.Group.Commands.DeleteGroup
+{
+    public class DeleteGroupCommand : IRequest
+    {
+        public string ParentGroupId { get; set; }
+        public string GroupId { get; set; }
+        public string RecycleBinName { get; set; }
+
+        public class DeleteGroupCommandHandler : IAsyncRequestHandler<DeleteGroupCommand>
+        {
+            private readonly IDatabaseProxy _database;
+
+            public DeleteGroupCommandHandler(IDatabaseProxy database)
+            {
+                _database = database;
+            }
+
+            public async Task Handle(DeleteGroupCommand message)
+            {
+                if (!_database.IsOpen) throw new DatabaseClosedException();
+
+                if (_database.IsRecycleBinEnabled && (string.IsNullOrEmpty(_database.RecycleBinId) || _database.RecycleBinId.Equals(Constants.EmptyId)))
+                {
+                    _database.CreateGroup(_database.RootGroupId, message.RecycleBinName, true);
+                }
+
+                if (!_database.IsRecycleBinEnabled || message.ParentGroupId.Equals(_database.RecycleBinId))
+                {
+                    _database.DeleteEntity(message.GroupId);
+                }
+                else
+                {
+                    await _database.AddGroup(_database.RecycleBinId, message.GroupId);
+                }
+
+                await _database.RemoveGroup(message.ParentGroupId, message.GroupId);
+            }
+        }
+    }
+}

ModernKeePass.Application/Group/Commands/MoveEntry/MoveEntryCommand.cs

@@ -0,0 +1,34 @@
+using System.Threading.Tasks;
+using MediatR;
+using ModernKeePass.Application.Common.Interfaces;
+using ModernKeePass.Application.Entry.Models;
+using ModernKeePass.Application.Group.Models;
+using ModernKeePass.Domain.Exceptions;
+
+namespace ModernKeePass.Application.Group.Commands.MoveEntry
+{
+    public class MoveEntryCommand : IRequest
+    {
+        public GroupVm ParentGroup { get; set; }
+        public EntryVm Entry { get; set; }
+        public int Index { get; set; }
+
+        public class MoveEntryCommandHandler : IAsyncRequestHandler<MoveEntryCommand>
+        {
+            private readonly IDatabaseProxy _database;
+
+            public MoveEntryCommandHandler(IDatabaseProxy database)
+            {
+                _database = database;
+            }
+
+            public async Task Handle(MoveEntryCommand message)
+            {
+                if (!_database.IsOpen) throw new DatabaseClosedException();
+
+                await _database.MoveEntry(message.ParentGroup.Id, message.Entry.Id, message.Index);
+                message.ParentGroup.Entries.Insert(message.Index, message.Entry);
+            }
+        }
+    }
+}

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

@@ -0,0 +1,31 @@
+using System.Threading.Tasks;
+using MediatR;
+using ModernKeePass.Application.Common.Interfaces;
+using ModernKeePass.Domain.Exceptions;
+
+namespace ModernKeePass.Application.Group.Commands.RemoveEntry
+{
+    public class RemoveEntryCommand : IRequest
+    {
+        public string ParentGroupId { get; set; }
+        public string EntryId { get; set; }
+
+        public class RemoveEntryCommandHandler : IAsyncRequestHandler<RemoveEntryCommand>
+        {
+            private readonly IDatabaseProxy _database;
+
+            public RemoveEntryCommandHandler(IDatabaseProxy database)
+            {
+                _database = database;
+            }
+
+            public async Task Handle(RemoveEntryCommand message)
+            {
+                if (!_database.IsOpen) throw new DatabaseClosedException();
+
+                await _database.RemoveEntry(message.ParentGroupId, message.EntryId);
+                //message.ParentGroup.Entries.Remove(message.Entry);
+            }
+        }
+    }
+}

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

@@ -0,0 +1,31 @@
+using System.Threading.Tasks;
+using MediatR;
+using ModernKeePass.Application.Common.Interfaces;
+using ModernKeePass.Domain.Exceptions;
+
+namespace ModernKeePass.Application.Group.Commands.RemoveGroup
+{
+    public class RemoveGroupCommand : IRequest
+    {
+        public string ParentGroupId { get; set; }
+        public string GroupId { get; set; }
+
+        public class RemoveGroupCommandHandler : IAsyncRequestHandler<RemoveGroupCommand>
+        {
+            private readonly IDatabaseProxy _database;
+
+            public RemoveGroupCommandHandler(IDatabaseProxy database)
+            {
+                _database = database;
+            }
+
+            public async Task Handle(RemoveGroupCommand message)
+            {
+                if (!_database.IsOpen) throw new DatabaseClosedException();
+
+                await _database.RemoveGroup(message.ParentGroupId, message.GroupId);
+                //message.ParentGroup.SubGroups.Remove(message.Group);
+            }
+        }
+    }
+}

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

@@ -0,0 +1,31 @@
+using System.Linq;
+using MediatR;
+using ModernKeePass.Application.Common.Interfaces;
+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 : IRequestHandler<SortEntriesCommand>
+        {
+            private readonly IDatabaseProxy _database;
+
+            public SortEntriesCommandHandler(IDatabaseProxy database)
+            {
+                _database = database;
+            }
+
+            public void Handle(SortEntriesCommand message)
+            {
+                if (!_database.IsOpen) throw new DatabaseClosedException();
+
+                _database.SortEntries(message.Group.Id);
+                message.Group.Entries = message.Group.Entries.OrderBy(e => e.Title).ToList();
+            }
+        }
+    }
+}

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

@@ -0,0 +1,32 @@
+using System.Collections.Generic;
+using System.Linq;
+using MediatR;
+using ModernKeePass.Application.Common.Interfaces;
+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 : IRequestHandler<SortGroupsCommand>
+        {
+            private readonly IDatabaseProxy _database;
+
+            public SortGroupsCommandHandler(IDatabaseProxy database)
+            {
+                _database = database;
+            }
+
+            public void Handle(SortGroupsCommand message)
+            {
+                if (!_database.IsOpen) throw new DatabaseClosedException();
+
+                _database.SortSubGroups(message.Group.Id);
+                message.Group.SubGroups = message.Group.SubGroups.OrderBy(g => g.Title).ToList();
+            }
+        }
+    }
+}

ModernKeePass.Application/Group/Commands/UpdateGroup/UpdateGroupCommand.cs

@@ -0,0 +1,41 @@
+using MediatR;
+using ModernKeePass.Application.Common.Interfaces;
+using ModernKeePass.Application.Group.Models;
+using ModernKeePass.Domain.Entities;
+using ModernKeePass.Domain.Enums;
+using ModernKeePass.Domain.Exceptions;
+
+namespace ModernKeePass.Application.Group.Commands.UpdateGroup
+{
+    public class UpdateGroupCommand : IRequest
+    {
+        public GroupVm Group { get; set; }
+        public string Title { get; set; }
+        public Icon Icon { get; set; }
+
+        public class UpdateGroupCommandHandler : IRequestHandler<UpdateGroupCommand>
+        {
+            private readonly IDatabaseProxy _database;
+
+            public UpdateGroupCommandHandler(IDatabaseProxy database)
+            {
+                _database = database;
+            }
+
+            public void Handle(UpdateGroupCommand message)
+            {
+                if (!_database.IsOpen) throw new DatabaseClosedException();
+
+                var group = new GroupEntity
+                {
+                    Id = message.Group.Id,
+                    Name = message.Title,
+                    Icon = message.Icon
+                };
+                _database.UpdateGroup(group);
+                message.Group.Title = message.Title;
+                message.Group.Icon = message.Icon;
+            }
+        }
+    }
+}

ModernKeePass.Application/Group/Models/GroupVm.cs

@@ -0,0 +1,39 @@
+using System.Collections.Generic;
+using AutoMapper;
+using ModernKeePass.Application.Common.Interfaces;
+using ModernKeePass.Application.Common.Mappings;
+using ModernKeePass.Application.Entry.Models;
+using ModernKeePass.Domain.Entities;
+using ModernKeePass.Domain.Enums;
+
+namespace ModernKeePass.Application.Group.Models
+{
+    public class GroupVm: IEntityVm, IMapFrom<GroupEntity>
+    {
+        public string ParentGroupId { get; set; }
+        public string ParentGroupName { get; set; }
+        public string Id { get; set; }
+        public string Title { get; set; }
+        public Icon Icon { get; set; }
+        public List<GroupVm> SubGroups { get; set; }
+        public List<EntryVm> Entries { get; set; }
+        
+        public override string ToString()
+        {
+            return Title;
+        }
+
+        public void Mapping(Profile profile)
+        {
+            profile.CreateMap<GroupEntity, GroupVm>()
+                .ForMember(d => d.ParentGroupId, opts => opts.MapFrom(s => s.ParentId))
+                .ForMember(d => d.ParentGroupName, opts => opts.MapFrom(s => s.ParentName))
+                .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.Entries, opts => opts.MapFrom(s => s.Entries))
+                .ForMember(d => d.SubGroups, opts => opts.MapFrom(s => s.SubGroups))
+                .MaxDepth(2);
+        }
+    }
+}

ModernKeePass.Application/Group/Queries/GetAllGroups/GetAllGroupsQuery.cs

@@ -0,0 +1,35 @@
+using System.Collections.Generic;
+using System.Linq;
+using AutoMapper;
+using MediatR;
+using ModernKeePass.Application.Common.Interfaces;
+using ModernKeePass.Application.Group.Models;
+using ModernKeePass.Domain.Exceptions;
+
+namespace ModernKeePass.Application.Group.Queries.GetAllGroups
+{
+    public class GetAllGroupsQuery : IRequest<IEnumerable<GroupVm>>
+    {
+        public string GroupId { get; set; }
+
+        public class GetAllGroupsQueryHandler : IRequestHandler<GetAllGroupsQuery, IEnumerable<GroupVm>>
+        {
+            private readonly IDatabaseProxy _database;
+            private readonly IMapper _mapper;
+
+            public GetAllGroupsQueryHandler(IDatabaseProxy database, IMapper mapper)
+            {
+                _database = database;
+                _mapper = mapper;
+            }
+
+            public IEnumerable<GroupVm> Handle(GetAllGroupsQuery message)
+            {
+                if (!_database.IsOpen) throw new DatabaseClosedException();
+                var groups = new List<GroupVm> {_mapper.Map<GroupVm>(_database.GetGroup(message.GroupId))};
+                groups.AddRange(_database.GetAllGroups(message.GroupId).Select(g => _mapper.Map<GroupVm>(g)));
+                return groups;
+            }
+        }
+    }
+}

ModernKeePass.Application/Group/Queries/GetGroup/GetGroupQuery.cs

@@ -0,0 +1,31 @@
+using AutoMapper;
+using MediatR;
+using ModernKeePass.Application.Common.Interfaces;
+using ModernKeePass.Application.Group.Models;
+using ModernKeePass.Domain.Exceptions;
+
+namespace ModernKeePass.Application.Group.Queries.GetGroup
+{
+    public class GetGroupQuery : IRequest<GroupVm>
+    {
+        public string Id { get; set; }
+
+        public class GetGroupQueryHandler : IRequestHandler<GetGroupQuery, GroupVm>
+        {
+            private readonly IDatabaseProxy _database;
+            private readonly IMapper _mapper;
+
+            public GetGroupQueryHandler(IDatabaseProxy database, IMapper mapper)
+            {
+                _database = database;
+                _mapper = mapper;
+            }
+
+            public GroupVm Handle(GetGroupQuery message)
+            {
+                if (!_database.IsOpen) throw new DatabaseClosedException();
+                return _mapper.Map<GroupVm>(_database.GetGroup(message.Id));
+            }
+        }
+    }
+}

ModernKeePass.Application/Group/Queries/SearchEntries/SearchEntriesQuery.cs

@@ -0,0 +1,34 @@
+using System.Collections.Generic;
+using System.Linq;
+using AutoMapper;
+using MediatR;
+using ModernKeePass.Application.Common.Interfaces;
+using ModernKeePass.Application.Entry.Models;
+using ModernKeePass.Domain.Exceptions;
+
+namespace ModernKeePass.Application.Group.Queries.SearchEntries
+{
+    public class SearchEntriesQuery : IRequest<IEnumerable<EntryVm>>
+    {
+        public string GroupId { get; set; }
+        public string SearchText { get; set; }
+
+        public class SearchEntriesQueryHandler : IRequestHandler<SearchEntriesQuery, IEnumerable<EntryVm>>
+        {
+            private readonly IDatabaseProxy _database;
+            private readonly IMapper _mapper;
+
+            public SearchEntriesQueryHandler(IDatabaseProxy database, IMapper mapper)
+            {
+                _database = database;
+                _mapper = mapper;
+            }
+
+            public IEnumerable<EntryVm> Handle(SearchEntriesQuery message)
+            {
+                if (!_database.IsOpen) throw new DatabaseClosedException();
+                return _database.Search(message.GroupId, message.SearchText).Select(e => _mapper.Map<EntryVm>(e));
+            }
+        }
+    }
+}

ModernKeePass.Application/Parameters/Commands/SetCipher/SetCipherCommand.cs

@@ -0,0 +1,27 @@
+using MediatR;
+using ModernKeePass.Application.Common.Interfaces;
+using ModernKeePass.Domain.Exceptions;
+
+namespace ModernKeePass.Application.Parameters.Commands.SetCipher
+{
+    public class SetCipherCommand : IRequest
+    {
+        public string CipherId { get; set; }
+
+        public class SetCipherCommandHandler : IRequestHandler<SetCipherCommand>
+        {
+            private readonly IDatabaseProxy _database;
+
+            public SetCipherCommandHandler(IDatabaseProxy database)
+            {
+                _database = database;
+            }
+
+            public void Handle(SetCipherCommand message)
+            {
+                if (_database.IsOpen) _database.CipherId = message.CipherId;
+                else throw new DatabaseClosedException();
+            }
+        }
+    }
+}

ModernKeePass.Application/Parameters/Commands/SetCompression/SetCompressionCommand.cs

@@ -0,0 +1,27 @@
+using MediatR;
+using ModernKeePass.Application.Common.Interfaces;
+using ModernKeePass.Domain.Exceptions;
+
+namespace ModernKeePass.Application.Parameters.Commands.SetCompression
+{
+    public class SetCompressionCommand : IRequest
+    {
+        public string Compression { get; set; }
+
+        public class SetCompressionCommandHandler : IRequestHandler<SetCompressionCommand>
+        {
+            private readonly IDatabaseProxy _database;
+
+            public SetCompressionCommandHandler(IDatabaseProxy database)
+            {
+                _database = database;
+            }
+
+            public void Handle(SetCompressionCommand message)
+            {
+                if (_database.IsOpen) _database.Compression = message.Compression;
+                else throw new DatabaseClosedException();
+            }
+        }
+    }
+}

ModernKeePass.Application/Parameters/Commands/SetHasRecycleBin/SetHasRecycleBinCommand.cs

@@ -0,0 +1,27 @@
+using MediatR;
+using ModernKeePass.Application.Common.Interfaces;
+using ModernKeePass.Domain.Exceptions;
+
+namespace ModernKeePass.Application.Parameters.Commands.SetHasRecycleBin
+{
+    public class SetHasRecycleBinCommand : IRequest
+    {
+        public bool HasRecycleBin { get; set; }
+
+        public class SetHasRecycleBinCommandHandler : IRequestHandler<SetHasRecycleBinCommand>
+        {
+            private readonly IDatabaseProxy _database;
+
+            public SetHasRecycleBinCommandHandler(IDatabaseProxy database)
+            {
+                _database = database;
+            }
+
+            public void Handle(SetHasRecycleBinCommand message)
+            {
+                if (_database.IsOpen) _database.IsRecycleBinEnabled = message.HasRecycleBin;
+                else throw new DatabaseClosedException();
+            }
+        }
+    }
+}

ModernKeePass.Application/Parameters/Commands/SetKeyDerivation/SetKeyDerivationCommand.cs

@@ -0,0 +1,27 @@
+using MediatR;
+using ModernKeePass.Application.Common.Interfaces;
+using ModernKeePass.Domain.Exceptions;
+
+namespace ModernKeePass.Application.Parameters.Commands.SetKeyDerivation
+{
+    public class SetKeyDerivationCommand : IRequest
+    {
+        public string KeyDerivationId { get; set; }
+
+        public class SetKeyDerivationCommandHandler : IRequestHandler<SetKeyDerivationCommand>
+        {
+            private readonly IDatabaseProxy _database;
+
+            public SetKeyDerivationCommandHandler(IDatabaseProxy database)
+            {
+                _database = database;
+            }
+
+            public void Handle(SetKeyDerivationCommand message)
+            {
+                if (_database.IsOpen) _database.KeyDerivationId = message.KeyDerivationId;
+                else throw new DatabaseClosedException();
+            }
+        }
+    }
+}

ModernKeePass.Application/Parameters/Commands/SetRecycleBin/SetRecycleBinCommand.cs

@@ -0,0 +1,28 @@
+using MediatR;
+using ModernKeePass.Application.Common.Interfaces;
+using ModernKeePass.Domain.Common;
+using ModernKeePass.Domain.Exceptions;
+
+namespace ModernKeePass.Application.Parameters.Commands.SetRecycleBin
+{
+    public class SetRecycleBinCommand : IRequest
+    {
+        public string RecycleBinId { get; set; }
+
+        public class SetRecycleBinCommandHandler : IRequestHandler<SetRecycleBinCommand>
+        {
+            private readonly IDatabaseProxy _database;
+
+            public SetRecycleBinCommandHandler(IDatabaseProxy database)
+            {
+                _database = database;
+            }
+
+            public void Handle(SetRecycleBinCommand message)
+            {
+                if (!_database.IsOpen) throw new DatabaseClosedException();
+                _database.RecycleBinId = message.RecycleBinId ?? Constants.EmptyId;
+            }
+        }
+    }
+}

ModernKeePass.Application/Parameters/Models/CipherVm.cs

@@ -0,0 +1,8 @@
+namespace ModernKeePass.Application.Parameters.Models
+{
+    public class CipherVm
+    {
+        public string Id { get; set; }
+        public string Name { get; set; }
+    }
+}

ModernKeePass.Application/Parameters/Models/KeyDerivationVm.cs

@@ -0,0 +1,8 @@
+namespace ModernKeePass.Application.Parameters.Models
+{
+    public class KeyDerivationVm
+    {
+        public string Id { get; set; }
+        public string Name { get; set; }
+    }
+}

ModernKeePass.Application/Parameters/Queries/GetCiphers/GetCiphersQuery.cs

@@ -0,0 +1,30 @@
+using System.Collections.Generic;
+using System.Linq;
+using MediatR;
+using ModernKeePass.Application.Common.Interfaces;
+using ModernKeePass.Application.Parameters.Models;
+
+namespace ModernKeePass.Application.Parameters.Queries.GetCiphers
+{
+    public class GetCiphersQuery: IRequest<IEnumerable<CipherVm>>
+    {
+        public class GetCiphersQueryHandler: IRequestHandler<GetCiphersQuery, IEnumerable<CipherVm>>
+        {
+            private readonly ICryptographyClient _cryptography;
+
+            public GetCiphersQueryHandler(ICryptographyClient cryptography)
+            {
+                _cryptography = cryptography;
+            }
+
+            public IEnumerable<CipherVm> Handle(GetCiphersQuery message)
+            {
+                return _cryptography.Ciphers.Select(c => new CipherVm
+                {
+                    Id = c.Id,
+                    Name = c.Name
+                });
+            }
+        }
+    }
+}

ModernKeePass.Application/Parameters/Queries/GetCompressions/GetCompressionsQuery.cs

@@ -0,0 +1,25 @@
+using System.Collections.Generic;
+using System.Linq;
+using MediatR;
+using ModernKeePass.Application.Common.Interfaces;
+
+namespace ModernKeePass.Application.Parameters.Queries.GetCompressions
+{
+    public class GetCompressionsQuery : IRequest<IEnumerable<string>>
+    {
+        public class GetCompressionsQueryHandler : IRequestHandler<GetCompressionsQuery, IEnumerable<string>>
+        {
+            private readonly ICryptographyClient _cryptography;
+
+            public GetCompressionsQueryHandler(ICryptographyClient cryptography)
+            {
+                _cryptography = cryptography;
+            }
+
+            public IEnumerable<string> Handle(GetCompressionsQuery message)
+            {
+                return _cryptography.CompressionAlgorithms.OrderBy(c => c);
+            }
+        }
+    }
+}

ModernKeePass.Application/Parameters/Queries/GetKeyDerivations/GetKeyDerivationsQuery.cs

@@ -0,0 +1,30 @@
+using System.Collections.Generic;
+using System.Linq;
+using MediatR;
+using ModernKeePass.Application.Common.Interfaces;
+using ModernKeePass.Application.Parameters.Models;
+
+namespace ModernKeePass.Application.Parameters.Queries.GetKeyDerivations
+{
+    public class GetKeyDerivationsQuery : IRequest<IEnumerable<KeyDerivationVm>>
+    {
+        public class GetKeyDerivationsQueryHandler : IRequestHandler<GetKeyDerivationsQuery, IEnumerable<KeyDerivationVm>>
+        {
+            private readonly ICryptographyClient _cryptography;
+
+            public GetKeyDerivationsQueryHandler(ICryptographyClient cryptography)
+            {
+                _cryptography = cryptography;
+            }
+
+            public IEnumerable<KeyDerivationVm> Handle(GetKeyDerivationsQuery message)
+            {
+                return _cryptography.KeyDerivations.Select(c => new KeyDerivationVm
+                {
+                    Id = c.Id,
+                    Name = c.Name
+                });
+            }
+        }
+    }
+}

ModernKeePass.Application/Properties/AssemblyInfo.cs

@@ -0,0 +1,28 @@
+using System.Resources;
+using System.Reflection;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("ModernKeePass.Application")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("ModernKeePass.Application")]
+[assembly: AssemblyCopyright("Copyright ©  2020")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+[assembly: NeutralResourcesLanguage("en")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers 
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]

ModernKeePass.Application/Security/Commands/GenerateKeyFile/GenerateKeyFileCommand.cs

@@ -0,0 +1,38 @@
+using System;
+using System.Threading.Tasks;
+using MediatR;
+using ModernKeePass.Application.Common.Interfaces;
+
+namespace ModernKeePass.Application.Security.Commands.GenerateKeyFile
+{
+    public class GenerateKeyFileCommand : IRequest
+    {
+        public string KeyFilePath { get; set; }
+        public bool AddAdditionalEntropy { get; set; }
+
+        public class GenerateKeyFileCommandHandler : IAsyncRequestHandler<GenerateKeyFileCommand>
+        {
+            private readonly ICredentialsProxy _security;
+            private readonly IFileProxy _file;
+
+            public GenerateKeyFileCommandHandler(ICredentialsProxy security, IFileProxy file)
+            {
+                _security = security;
+                _file = file;
+            }
+
+            public async Task Handle(GenerateKeyFileCommand message)
+            {
+                byte[] entropy = null;
+                if (message.AddAdditionalEntropy)
+                {
+                    entropy = new byte[10];
+                    var random = new Random();
+                    random.NextBytes(entropy);
+                }
+                var keyFile = _security.GenerateKeyFile(entropy);
+                await _file.WriteBinaryContentsToFile(message.KeyFilePath, keyFile);
+            }
+        }
+    }
+}

ModernKeePass.Application/Security/Commands/GeneratePassword/GeneratePasswordCommand.cs

@@ -0,0 +1,48 @@
+using MediatR;
+using ModernKeePass.Application.Common.Interfaces;
+using ModernKeePass.Domain.Dtos;
+
+namespace ModernKeePass.Application.Security.Commands.GeneratePassword
+{
+    public class GeneratePasswordCommand: IRequest<string>
+    {
+        public int PasswordLength { get; set; }
+        public bool UpperCasePatternSelected { get; set; }
+        public bool LowerCasePatternSelected { get; set; }
+        public bool DigitsPatternSelected { get; set; }
+        public bool SpecialPatternSelected { get; set; }
+        public bool MinusPatternSelected { get; set; }
+        public bool UnderscorePatternSelected { get; set; }
+        public bool SpacePatternSelected { get; set; }
+        public bool BracketsPatternSelected { get; set; }
+        public string CustomChars { get; set; }
+
+        public class GeneratePasswordCommandHandler: IRequestHandler<GeneratePasswordCommand, string>
+        {
+            private readonly ICredentialsProxy _security;
+
+            public GeneratePasswordCommandHandler(ICredentialsProxy security)
+            {
+                _security = security;
+            }
+
+            public string Handle(GeneratePasswordCommand message)
+            {
+                var options = new PasswordGenerationOptions
+                {
+                    PasswordLength = message.PasswordLength,
+                    BracketsPatternSelected = message.BracketsPatternSelected,
+                    CustomChars = message.CustomChars,
+                    DigitsPatternSelected = message.DigitsPatternSelected,
+                    LowerCasePatternSelected = message.LowerCasePatternSelected,
+                    MinusPatternSelected = message.MinusPatternSelected,
+                    SpacePatternSelected = message.SpacePatternSelected,
+                    SpecialPatternSelected = message.SpecialPatternSelected,
+                    UnderscorePatternSelected = message.UnderscorePatternSelected,
+                    UpperCasePatternSelected = message.UpperCasePatternSelected
+                };
+                return _security.GeneratePassword(options);
+            }
+        }
+    }
+}

ModernKeePass.Application/Security/Queries/EstimatePasswordComplexity/EstimatePasswordComplexityQuery.cs

@@ -0,0 +1,25 @@
+using MediatR;
+using ModernKeePass.Application.Common.Interfaces;
+
+namespace ModernKeePass.Application.Security.Queries.EstimatePasswordComplexity
+{
+    public class EstimatePasswordComplexityQuery : IRequest<int>
+    {
+        public string Password { get; set; }
+
+        public class EstimatePasswordComplexityQueryHandler : IRequestHandler<EstimatePasswordComplexityQuery, int>
+        {
+            private readonly ICredentialsProxy _security;
+
+            public EstimatePasswordComplexityQueryHandler(ICredentialsProxy security)
+            {
+                _security = security;
+            }
+
+            public int Handle(EstimatePasswordComplexityQuery message)
+            {
+                return _security.EstimatePasswordComplexity(message.Password);
+            }
+        }
+    }
+}

ModernKeePass.Application/project.json

@@ -0,0 +1,16 @@
+{
+  "supports": {},
+  "dependencies": {
+    "AutoMapper": "5.2.0",
+    "FluentValidation": "8.6.2",
+    "MediatR": "3.0.1",
+    "MediatR.Extensions.Microsoft.DependencyInjection": "2.0.0",
+    "Microsoft.Extensions.DependencyInjection": "1.1.1",
+    "Microsoft.NETCore.Portable.Compatibility": "1.0.1",
+    "NETStandard.Library": "2.0.3",
+    "Splat": "3.0.0"
+  },
+  "frameworks": {
+    "netstandard1.2": {}
+  }
+}

ModernKeePass.Domain/Common/Constants.cs

@@ -0,0 +1,7 @@
+namespace ModernKeePass.Domain.Common
+{
+    public static class Constants
+    {
+        public static string EmptyId => "00000000000000000000000000000000";
+    }
+}

ModernKeePass.Domain/Domain.csproj

@@ -0,0 +1,111 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <PropertyGroup>
+    <MinimumVisualStudioVersion>14.0</MinimumVisualStudioVersion>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProjectGuid>{9A0759F1-9069-4841-99E3-3BEC44E17356}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>ModernKeePass.Domain</RootNamespace>
+    <AssemblyName>ModernKeePass.Domain</AssemblyName>
+    <DefaultLanguage>en-US</DefaultLanguage>
+    <FileAlignment>512</FileAlignment>
+    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
+    <TargetFrameworkProfile>
+    </TargetFrameworkProfile>
+    <TargetFrameworkVersion>v5.0</TargetFrameworkVersion>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x64' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\x64\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <PlatformTarget>x64</PlatformTarget>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\x86\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <PlatformTarget>x86</PlatformTarget>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x64' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\x64\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <PlatformTarget>x64</PlatformTarget>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|ARM' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\ARM\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <ItemGroup>
+    <!-- A reference to the entire .NET Framework is automatically included -->
+    <None Include="project.json" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="Common\Constants.cs" />
+    <Compile Include="Dtos\Credentials.cs" />
+    <Compile Include="Dtos\FileInfo.cs" />
+    <Compile Include="Dtos\PasswordGenerationOptions.cs" />
+    <Compile Include="Entities\BaseEntity.cs" />
+    <Compile Include="Entities\EntryEntity.cs" />
+    <Compile Include="Entities\GroupEntity.cs" />
+    <Compile Include="Enums\CredentialStatusTypes.cs" />
+    <Compile Include="Enums\DatabaseVersion.cs" />
+    <Compile Include="Enums\EntryFieldName.cs" />
+    <Compile Include="Enums\Icon.cs" />
+    <Compile Include="Enums\ImportFormat.cs" />
+    <Compile Include="Exceptions\DatabaseClosedException.cs" />
+    <Compile Include="Exceptions\DatabaseOpenException.cs" />
+    <Compile Include="Exceptions\DatabaseTooBigException.cs" />
+    <Compile Include="Exceptions\NavigationException.cs" />
+    <Compile Include="Exceptions\SaveException.cs" />
+    <Compile Include="Interfaces\IDateTime.cs" />
+    <Compile Include="Interfaces\IHasSelectableObject.cs" />
+    <Compile Include="Interfaces\IImportFormat.cs" />
+    <Compile Include="Interfaces\IIsEnabled.cs" />
+    <Compile Include="Interfaces\ISelectableModel.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+  </ItemGroup>
+  <ItemGroup />
+  <Import Project="$(MSBuildExtensionsPath32)\Microsoft\Portable\$(TargetFrameworkVersion)\Microsoft.Portable.CSharp.targets" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+</Project>

ModernKeePass.Domain/Dtos/Credentials.cs

@@ -0,0 +1,9 @@
+namespace ModernKeePass.Domain.Dtos
+{
+    public class Credentials
+    {
+        public string Password { get; set; }
+        public byte[] KeyFileContents { get; set; }
+        // TODO: add Windows Hello
+    }
+}

ModernKeePass.Domain/Dtos/FileInfo.cs

@@ -0,0 +1,9 @@
+namespace ModernKeePass.Domain.Dtos
+{
+    public class FileInfo
+    {
+        public string Id { get; set; }
+        public string Name { get; set; }
+        public string Path { get; set; }
+    }
+}

ModernKeePass.Domain/Dtos/PasswordGenerationOptions.cs

@@ -0,0 +1,16 @@
+namespace ModernKeePass.Domain.Dtos
+{
+    public class PasswordGenerationOptions
+    {
+        public int PasswordLength { get; set; }
+        public bool UpperCasePatternSelected { get; set; }
+        public bool LowerCasePatternSelected { get; set; }
+        public bool DigitsPatternSelected { get; set; }
+        public bool SpecialPatternSelected { get; set; }
+        public bool MinusPatternSelected { get; set; }
+        public bool UnderscorePatternSelected { get; set; }
+        public bool SpacePatternSelected { get; set; }
+        public bool BracketsPatternSelected { get; set; }
+        public string CustomChars { get; set; }
+    }
+}

ModernKeePass.Domain/Entities/BaseEntity.cs

@@ -0,0 +1,13 @@
+using System;
+
+namespace ModernKeePass.Domain.Entities
+{
+    public class BaseEntity
+    {
+        public string Id { get; set; }
+        public string Name { get; set; }
+        public string ParentId { get; set; }
+        public string ParentName { get; set; }
+        public DateTimeOffset LastModificationDate { get; set; }
+    }
+}

ModernKeePass.Domain/Entities/EntryEntity.cs

@@ -0,0 +1,22 @@
+using System;
+using System.Collections.Generic;
+using System.Drawing;
+using ModernKeePass.Domain.Enums;
+
+namespace ModernKeePass.Domain.Entities
+{
+    public class EntryEntity: BaseEntity
+    {
+        public string UserName { get; set; }
+        public string Password { get; set; }
+        public string Url { get; set; }
+        public string Notes { get; set; }
+        public DateTimeOffset ExpirationDate { get; set; }
+        public Dictionary<string, string> AdditionalFields { get; set; } = new Dictionary<string, string>();
+        public IEnumerable<EntryEntity> History { get; set; } = new List<EntryEntity>();
+        public Icon Icon { get; set; }
+        public Color ForegroundColor { get; set; }
+        public Color BackgroundColor { get; set; }
+        public bool HasExpirationDate { get; set; }
+    }
+}

ModernKeePass.Domain/Entities/GroupEntity.cs

@@ -0,0 +1,12 @@
+using System.Collections.Generic;
+using ModernKeePass.Domain.Enums;
+
+namespace ModernKeePass.Domain.Entities
+{
+    public class GroupEntity : BaseEntity
+    {
+        public List<GroupEntity> SubGroups { get; set; } = new List<GroupEntity>();
+        public List<EntryEntity> Entries { get; set; } = new List<EntryEntity>();
+        public Icon Icon { get; set; }
+    }
+}

ModernKeePass.Domain/Enums/CredentialStatusTypes.cs

@@ -0,0 +1,10 @@
+namespace ModernKeePass.Domain.Enums
+{
+    public enum CredentialStatusTypes
+    {
+        Normal = 0,
+        Error = 1,
+        Warning = 3,
+        Success = 5
+    }
+}

ModernKeePass.Domain/Enums/DatabaseVersion.cs

@@ -0,0 +1,9 @@
+namespace ModernKeePass.Domain.Enums
+{
+    public enum DatabaseVersion
+    {
+        V2,
+        V3,
+        V4
+    }
+}

ModernKeePass.Domain/Enums/EntryFieldName.cs

@@ -0,0 +1,16 @@
+namespace ModernKeePass.Domain.Enums
+{
+    public static class EntryFieldName
+    {
+        public const string Title = nameof(Title);
+        public const string UserName = nameof(UserName);
+        public const string Password = nameof(Password);
+        public const string Url = nameof(Url);
+        public const string Notes = nameof(Notes);
+        public const string Icon = nameof(Icon);
+        public const string ExpirationDate = nameof(ExpirationDate);
+        public const string HasExpirationDate = nameof(HasExpirationDate);
+        public const string BackgroundColor = nameof(BackgroundColor);
+        public const string ForegroundColor = nameof(ForegroundColor);
+    }
+}

ModernKeePass.Domain/Enums/Icon.cs

@@ -0,0 +1,54 @@
+namespace ModernKeePass.Domain.Enums
+{
+    public enum Icon
+    {
+        Delete,
+        Edit,
+        Save,
+        Cancel,
+        Accept,
+        Home,
+        Camera,
+        Setting,
+        Mail,
+        Find,
+        Help,
+        Clock,
+        Crop,
+        World,
+        Flag,
+        PreviewLink,
+        Document,
+        ProtectedDocument,
+        ContactInfo,
+        ViewAll,
+        Rotate,
+        List,
+        Shop,
+        BrowsePhotos,
+        Caption,
+        Repair,
+        Page,
+        Paste,
+        Important,
+        SlideShow,
+        MapDrive,
+        ContactPresence,
+        Contact,
+        Folder,
+        View,
+        Permissions,
+        Map,
+        CellPhone,
+        OutlineStar,
+        Calculator,
+        Library,
+        SyncFolder,
+        GoToStart,
+        ZeroBars,
+        FourBars,
+        Scan,
+        ReportHacked,
+        Stop
+    }
+}

ModernKeePass.Domain/Enums/ImportFormat.cs

@@ -0,0 +1,7 @@
+namespace ModernKeePass.Domain.Enums
+{
+    public enum ImportFormat
+    {
+        CSV
+    }
+}

ModernKeePass.Domain/Exceptions/DatabaseClosedException.cs

@@ -0,0 +1,7 @@
+using System;
+
+namespace ModernKeePass.Domain.Exceptions
+{
+    public class DatabaseClosedException: Exception
+    { }
+}

ModernKeePass.Domain/Exceptions/DatabaseOpenException.cs

@@ -0,0 +1,7 @@
+using System;
+
+namespace ModernKeePass.Domain.Exceptions
+{
+    public class DatabaseOpenException: Exception
+    { }
+}

ModernKeePass.Domain/Exceptions/DatabaseTooBigException.cs

@@ -0,0 +1,6 @@
+using System;
+
+namespace ModernKeePass.Domain.Exceptions
+{
+    public class DatabaseTooBigException: Exception { }
+}

ModernKeePass.Domain/Exceptions/NavigationException.cs

@@ -0,0 +1,11 @@
+using System;
+
+namespace ModernKeePass.Domain.Exceptions
+{
+    public class NavigationException: Exception
+    {
+        public NavigationException(Type pageType) : base($"Failed to load Page {pageType.FullName}")
+        {
+        }
+    }
+}

ModernKeePass.Domain/Exceptions/SaveException.cs

@@ -0,0 +1,16 @@
+using System;
+
+namespace ModernKeePass.Domain.Exceptions
+{
+    public class SaveException : Exception
+    {
+        public new string Message { get; }
+        public new string Source { get; }
+
+        public SaveException(Exception exception)
+        {
+            Message = exception.Message;
+            Source = exception.Source;
+        }
+    }
+}

ModernKeePass.Domain/Interfaces/IDateTime.cs

@@ -0,0 +1,9 @@
+using System;
+
+namespace ModernKeePass.Domain.Interfaces
+{
+    public interface IDateTime
+    {
+        DateTime Now { get; }
+    }
+}

ModernKeePass.Domain/Interfaces/IHasSelectableObject.cs

@@ -1,4 +1,4 @@
-namespace ModernKeePass.Interfaces
+namespace ModernKeePass.Domain.Interfaces
 {
     public interface IHasSelectableObject
     {

ModernKeePass.Domain/Interfaces/IImportFormat.cs

@@ -0,0 +1,10 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+
+namespace ModernKeePass.Domain.Interfaces
+{
+    public interface IImportFormat
+    {
+        Task<List<Dictionary<string, string>>> Import(string path);
+    }
+}

ModernKeePass.Domain/Interfaces/IIsEnabled.cs

@@ -1,4 +1,4 @@
-namespace ModernKeePass.Interfaces
+namespace ModernKeePass.Domain.Interfaces
 {
     public interface IIsEnabled
     {

ModernKeePass.Domain/Interfaces/ISelectableModel.cs

@@ -1,4 +1,4 @@
-namespace ModernKeePass.Interfaces
+namespace ModernKeePass.Domain.Interfaces
 {
     public interface ISelectableModel
     {

ModernKeePass.Domain/Properties/AssemblyInfo.cs

@@ -0,0 +1,28 @@
+using System.Resources;
+using System.Reflection;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("ModernKeePass.Domain")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("ModernKeePass.Domain")]
+[assembly: AssemblyCopyright("Copyright ©  2020")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+[assembly: NeutralResourcesLanguage("en")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers 
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]

ModernKeePass.Domain/project.json

@@ -0,0 +1,11 @@
+{
+  "supports": {},
+  "dependencies": {
+    "Microsoft.NETCore.Portable.Compatibility": "1.0.1",
+    "NETStandard.Library": "2.0.3",
+    "Splat": "3.0.0"
+  },
+  "frameworks": {
+    "netstandard1.2": {}
+  }
+}

ModernKeePass.Infrastructure/Common/MachineDateTime.cs

@@ -0,0 +1,10 @@
+using System;
+using ModernKeePass.Domain.Interfaces;
+
+namespace ModernKeePass.Infrastructure.Common
+{
+    public class MachineDateTime: IDateTime
+    {
+        public DateTime Now => DateTime.Now;
+    }
+}

ModernKeePass.Infrastructure/DependencyInjection.cs

@@ -0,0 +1,36 @@
+using Microsoft.Extensions.DependencyInjection;
+using ModernKeePass.Application.Common.Interfaces;
+using ModernKeePass.Domain.Interfaces;
+using ModernKeePass.Infrastructure.Common;
+using ModernKeePass.Infrastructure.KeePass;
+using ModernKeePass.Infrastructure.UWP;
+
+namespace ModernKeePass.Infrastructure
+{
+    public static class DependencyInjection
+    {
+        public static IServiceCollection AddInfrastructureCommon(this IServiceCollection services)
+        {
+            services.AddTransient(typeof(IDateTime), typeof(MachineDateTime));
+            return services;
+        }
+        
+        public static IServiceCollection AddInfrastructureKeePass(this IServiceCollection services)
+        {
+            services.AddSingleton(typeof(IDatabaseProxy), typeof(KeePassDatabaseClient));
+            services.AddTransient(typeof(ICryptographyClient), typeof(KeePassCryptographyClient));
+            services.AddTransient(typeof(ICredentialsProxy), typeof(KeePassCredentialsClient));
+            return services;
+        }
+
+        public static IServiceCollection AddInfrastructureUwp(this IServiceCollection services)
+        {
+            services.AddScoped(typeof(IFileProxy), typeof(StorageFileClient));
+            services.AddTransient(typeof(ISettingsProxy), typeof(UwpSettingsClient));
+            services.AddTransient(typeof(IRecentProxy), typeof(UwpRecentFilesClient));
+            services.AddTransient(typeof(IResourceProxy), typeof(UwpResourceClient));
+            services.AddTransient(typeof(INotificationService), typeof(ToastNotificationService));
+            return services;
+        }
+    }
+}

ModernKeePass.Infrastructure/File/CsvImportFormat.cs

@@ -0,0 +1,31 @@
+using System.Collections.Generic;
+using ModernKeePass.Application.Common.Interfaces;
+
+namespace ModernKeePass.Infrastructure.File
+{
+    public class CsvImportFormat: IImportFormat
+    {
+        private const bool HasHeaderRow = true;
+        private const char Delimiter = ';';
+        private const char LineDelimiter = '\n';
+        
+        public List<Dictionary<string, string>> Import(IList<string> fileContents)
+        {
+            var parsedResult = new List<Dictionary<string, string>>();
+            foreach (var line in fileContents)
+            {
+                var fields = line.Split(Delimiter);
+                var recordItem = new Dictionary<string, string>();
+                var i = 0;
+                foreach (var field in fields)
+                {
+                    recordItem.Add(i.ToString(), field);
+                    i++;
+                }
+                parsedResult.Add(recordItem);
+            }
+
+            return parsedResult;
+        }
+    }
+}

ModernKeePass.Infrastructure/Infrastructure.csproj

@@ -0,0 +1,122 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <PropertyGroup>
+    <MinimumVisualStudioVersion>14.0</MinimumVisualStudioVersion>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProjectGuid>{09577E4C-4899-45B9-BF80-1803D617CCAE}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>ModernKeePass.Infrastructure</RootNamespace>
+    <AssemblyName>ModernKeePass.Infrastructure</AssemblyName>
+    <DefaultLanguage>en-US</DefaultLanguage>
+    <FileAlignment>512</FileAlignment>
+    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
+    <TargetFrameworkProfile>
+    </TargetFrameworkProfile>
+    <TargetFrameworkVersion>v5.0</TargetFrameworkVersion>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x64' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\x64\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <PlatformTarget>x64</PlatformTarget>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\x86\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <PlatformTarget>x86</PlatformTarget>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x64' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\x64\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <PlatformTarget>x64</PlatformTarget>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|ARM' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\ARM\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <ItemGroup>
+    <!-- A reference to the entire .NET Framework is automatically included -->
+    <None Include="Libs\Windows.winmd" />
+    <None Include="project.json" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="Common\MachineDateTime.cs" />
+    <Compile Include="DependencyInjection.cs" />
+    <Compile Include="File\CsvImportFormat.cs" />
+    <Compile Include="KeePass\EntryFieldMapper.cs" />
+    <Compile Include="KeePass\EntryMappingProfile.cs" />
+    <Compile Include="KeePass\GroupMappingProfile.cs" />
+    <Compile Include="KeePass\IconMapper.cs" />
+    <Compile Include="KeePass\KeePassCryptographyClient.cs" />
+    <Compile Include="KeePass\KeePassDatabaseClient.cs" />
+    <Compile Include="KeePass\KeePassCredentialsClient.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="UWP\StorageFileClient.cs" />
+    <Compile Include="UWP\ToastNotificationService.cs" />
+    <Compile Include="UWP\UwpRecentFilesClient.cs" />
+    <Compile Include="UWP\UwpResourceClient.cs" />
+    <Compile Include="UWP\UwpSettingsClient.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\ModernKeePass.Application\Application.csproj">
+      <Project>{42353562-5e43-459c-8e3e-2f21e575261d}</Project>
+      <Name>Application</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\ModernKeePass.Domain\Domain.csproj">
+      <Project>{9a0759f1-9069-4841-99e3-3bec44e17356}</Project>
+      <Name>Domain</Name>
+    </ProjectReference>
+  </ItemGroup>
+  <ItemGroup>
+    <Reference Include="Windows, Version=255.255.255.255, Culture=neutral, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>Libs\Windows.winmd</HintPath>
+      <Private>False</Private>
+    </Reference>
+  </ItemGroup>
+  <ItemGroup />
+  <Import Project="$(MSBuildExtensionsPath32)\Microsoft\Portable\$(TargetFrameworkVersion)\Microsoft.Portable.CSharp.targets" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+</Project>

ModernKeePass.Infrastructure/KeePass/EntryFieldMapper.cs

@@ -0,0 +1,33 @@
+using ModernKeePass.Domain.Enums;
+using ModernKeePassLib;
+
+namespace ModernKeePass.Infrastructure.KeePass
+{
+    public static class EntryFieldMapper
+    {
+        public static string MapPwDefsToField(string value)
+        {
+            switch (value)
+            {
+                case PwDefs.TitleField: return EntryFieldName.Title;
+                case PwDefs.UserNameField: return EntryFieldName.UserName;
+                case PwDefs.PasswordField: return EntryFieldName.Password;
+                case PwDefs.NotesField: return EntryFieldName.Notes;
+                case PwDefs.UrlField: return EntryFieldName.Url;
+                default: return value;
+            }
+        }
+        public static string MapFieldToPwDef(string value)
+        {
+            switch (value)
+            {
+                case EntryFieldName.Title: return PwDefs.TitleField;
+                case EntryFieldName.UserName: return PwDefs.UserNameField;
+                case EntryFieldName.Password: return PwDefs.PasswordField;
+                case EntryFieldName.Notes: return PwDefs.NotesField;
+                case EntryFieldName.Url: return PwDefs.UrlField;
+                default: return value;
+            }
+        }
+    }
+}

ModernKeePass.Infrastructure/KeePass/EntryMappingProfile.cs

@@ -0,0 +1,35 @@
+using System;
+using System.Linq;
+using AutoMapper;
+using ModernKeePass.Domain.Entities;
+using ModernKeePassLib;
+
+namespace ModernKeePass.Infrastructure.KeePass
+{
+    public class EntryMappingProfile: Profile
+    {
+        public EntryMappingProfile()
+        {
+            CreateMap<PwEntry, EntryEntity>()
+                .ForMember(dest => dest.ParentId, opt => opt.MapFrom(src => src.ParentGroup.Uuid.ToHexString()))
+                .ForMember(dest => dest.ParentName, opt => opt.MapFrom(src => src.ParentGroup.Name))
+                .ForMember(dest => dest.Id, opt => opt.MapFrom(src => src.Uuid.ToHexString()))
+                .ForMember(dest => dest.Name, opt => opt.MapFrom(src => GetEntryValue(src, PwDefs.TitleField)))
+                .ForMember(dest => dest.UserName, opt => opt.MapFrom(src => GetEntryValue(src, PwDefs.UserNameField)))
+                .ForMember(dest => dest.Password, opt => opt.MapFrom(src => GetEntryValue(src, PwDefs.PasswordField)))
+                .ForMember(dest => dest.Url, opt => opt.MapFrom(src => GetEntryValue(src, PwDefs.UrlField)))
+                .ForMember(dest => dest.Notes, opt => opt.MapFrom(src => GetEntryValue(src, PwDefs.NotesField)))
+                .ForMember(dest => dest.ForegroundColor, opt => opt.MapFrom(src => src.ForegroundColor))
+                .ForMember(dest => dest.BackgroundColor, opt => opt.MapFrom(src => src.BackgroundColor))
+                .ForMember(dest => dest.ExpirationDate, opt => opt.MapFrom(src => new DateTimeOffset(src.ExpiryTime)))
+                .ForMember(dest => dest.HasExpirationDate, opt => opt.MapFrom(src => src.Expires))
+                .ForMember(dest => dest.Icon, opt => opt.MapFrom(src => IconMapper.MapPwIconToIcon(src.IconId)))
+                .ForMember(dest => dest.AdditionalFields, opt => opt.MapFrom(src =>
+                    src.Strings.Where(s => !PwDefs.GetStandardFields().Contains(s.Key))
+                        .ToDictionary(s => s.Key, s => GetEntryValue(src, s.Key))))
+                .ForMember(dest => dest.LastModificationDate, opt => opt.MapFrom(src => new DateTimeOffset(src.LastModificationTime)));
+        }
+        
+        private string GetEntryValue(PwEntry entry, string key) => entry.Strings.GetSafe(key).ReadString();
+    }
+}

ModernKeePass.Infrastructure/KeePass/GroupMappingProfile.cs

@@ -0,0 +1,23 @@
+using AutoMapper;
+using ModernKeePass.Domain.Entities;
+using ModernKeePassLib;
+
+namespace ModernKeePass.Infrastructure.KeePass
+{
+    public class GroupMappingProfile : Profile
+    {
+        public GroupMappingProfile()
+        {
+            CreateMap<PwGroup, GroupEntity>()
+                .ForMember(d => d.ParentId, opts => opts.MapFrom(s => s.ParentGroup.Uuid.ToHexString()))
+                .ForMember(d => d.ParentName, opts => opts.MapFrom(s => s.ParentGroup.Name))
+                .ForMember(d => d.Id, opts => opts.MapFrom(s => s.Uuid.ToHexString()))
+                .ForMember(d => d.Name, opts => opts.MapFrom(s => s.Name))
+                .ForMember(d => d.Icon, opts => opts.MapFrom(s => IconMapper.MapPwIconToIcon(s.IconId)))
+                .ForMember(d => d.LastModificationDate, opts => opts.MapFrom(s => s.LastModificationTime))
+                .ForMember(d => d.Entries, opts => opts.MapFrom(s => s.Entries))
+                .ForMember(d => d.SubGroups, opts => opts.MapFrom(s => s.Groups))
+                .MaxDepth(2);
+        }
+    }
+}

ModernKeePass.Infrastructure/KeePass/IconMapper.cs

@@ -0,0 +1,126 @@
+using ModernKeePass.Domain.Enums;
+using ModernKeePassLib;
+
+namespace ModernKeePass.Infrastructure.KeePass
+{
+    public static class IconMapper
+    {
+        public static Icon MapPwIconToIcon(PwIcon value)
+        {
+            switch (value)
+            {
+                case PwIcon.Key: return Icon.Permissions;
+                case PwIcon.WorldSocket:
+                case PwIcon.World: return Icon.World;
+                case PwIcon.Warning: return Icon.Important;
+                case PwIcon.WorldComputer:
+                case PwIcon.Drive:
+                case PwIcon.DriveWindows:
+                case PwIcon.NetworkServer: return Icon.MapDrive;
+                case PwIcon.MarkedDirectory: return Icon.Map;
+                case PwIcon.UserCommunication: return Icon.ContactInfo;
+                case PwIcon.Parts: return Icon.ViewAll;
+                case PwIcon.Notepad: return Icon.Document;
+                case PwIcon.Identity: return Icon.Contact;
+                case PwIcon.PaperReady: return Icon.SyncFolder;
+                case PwIcon.Digicam: return Icon.Camera;
+                case PwIcon.IRCommunication: return Icon.View;
+                case PwIcon.Energy: return Icon.ZeroBars;
+                case PwIcon.Scanner: return Icon.Scan;
+                case PwIcon.CDRom: return Icon.Rotate;
+                case PwIcon.Monitor: return Icon.Caption;
+                case PwIcon.EMailBox:
+                case PwIcon.EMail: return Icon.Mail;
+                case PwIcon.Configuration: return Icon.Setting;
+                case PwIcon.ClipboardReady: return Icon.Paste;
+                case PwIcon.PaperNew: return Icon.Page;
+                case PwIcon.Screen: return Icon.GoToStart;
+                case PwIcon.EnergyCareful: return Icon.FourBars;
+                case PwIcon.Disk: return Icon.Save;
+                case PwIcon.Console: return Icon.SlideShow;
+                case PwIcon.Printer: return Icon.Scan;
+                case PwIcon.ProgramIcons: return Icon.GoToStart;
+                case PwIcon.Settings:
+                case PwIcon.Tool: return Icon.Repair;
+                case PwIcon.Archive: return Icon.Crop;
+                case PwIcon.Count: return Icon.Calculator;
+                case PwIcon.Clock: return Icon.Clock;
+                case PwIcon.EMailSearch: return Icon.Find;
+                case PwIcon.PaperFlag: return Icon.Flag;
+                case PwIcon.TrashBin: return Icon.Delete;
+                case PwIcon.Expired: return Icon.ReportHacked;
+                case PwIcon.Info: return Icon.Help;
+                case PwIcon.Folder:
+                case PwIcon.FolderOpen:
+                case PwIcon.FolderPackage: return Icon.Folder;
+                case PwIcon.PaperLocked: return Icon.ProtectedDocument;
+                case PwIcon.Checked: return Icon.Accept;
+                case PwIcon.Pen: return Icon.Edit;
+                case PwIcon.Thumbnail: return Icon.BrowsePhotos;
+                case PwIcon.Book: return Icon.Library;
+                case PwIcon.List: return Icon.List;
+                case PwIcon.UserKey: return Icon.ContactPresence;
+                case PwIcon.Home: return Icon.Home;
+                case PwIcon.Star: return Icon.OutlineStar;
+                case PwIcon.Money: return Icon.Shop;
+                case PwIcon.Certificate: return Icon.PreviewLink;
+                case PwIcon.BlackBerry: return Icon.CellPhone;
+                default: return Icon.Stop;
+            }
+        }
+
+        public static PwIcon MapIconToPwIcon(Icon value)
+        {
+            switch (value)
+            {
+                case Icon.Delete: return PwIcon.TrashBin;
+                case Icon.Edit: return PwIcon.Pen;
+                case Icon.Save: return PwIcon.Disk;
+                case Icon.Cancel: return PwIcon.Expired;
+                case Icon.Accept: return PwIcon.Checked;
+                case Icon.Home: return PwIcon.Home;
+                case Icon.Camera: return PwIcon.Digicam;
+                case Icon.Setting: return PwIcon.Configuration;
+                case Icon.Mail: return PwIcon.EMail;
+                case Icon.Find: return PwIcon.EMailSearch;
+                case Icon.Help: return PwIcon.Info;
+                case Icon.Clock: return PwIcon.Clock;
+                case Icon.Crop: return PwIcon.Archive;
+                case Icon.World: return PwIcon.World;
+                case Icon.Flag: return PwIcon.PaperFlag;
+                case Icon.PreviewLink: return PwIcon.Certificate;
+                case Icon.Document: return PwIcon.Notepad;
+                case Icon.ProtectedDocument: return PwIcon.PaperLocked;
+                case Icon.ContactInfo: return PwIcon.UserCommunication;
+                case Icon.ViewAll: return PwIcon.Parts;
+                case Icon.Rotate: return PwIcon.CDRom;
+                case Icon.List: return PwIcon.List;
+                case Icon.Shop: return PwIcon.Money;
+                case Icon.BrowsePhotos: return PwIcon.Thumbnail;
+                case Icon.Caption: return PwIcon.Monitor;
+                case Icon.Repair: return PwIcon.Tool;
+                case Icon.Page: return PwIcon.PaperNew;
+                case Icon.Paste: return PwIcon.ClipboardReady;
+                case Icon.Important: return PwIcon.Warning;
+                case Icon.SlideShow: return PwIcon.Console;
+                case Icon.MapDrive: return PwIcon.NetworkServer;
+                case Icon.ContactPresence: return PwIcon.UserKey;
+                case Icon.Contact: return PwIcon.Identity;
+                case Icon.Folder: return PwIcon.Folder;
+                case Icon.View: return PwIcon.IRCommunication;
+                case Icon.Permissions: return PwIcon.Key;
+                case Icon.Map: return PwIcon.MarkedDirectory;
+                case Icon.CellPhone: return PwIcon.BlackBerry;
+                case Icon.OutlineStar: return PwIcon.Star;
+                case Icon.Calculator: return PwIcon.Count;
+                case Icon.Library: return PwIcon.Book;
+                case Icon.SyncFolder: return PwIcon.PaperReady;
+                case Icon.GoToStart: return PwIcon.Screen;
+                case Icon.ZeroBars: return PwIcon.Energy;
+                case Icon.FourBars: return PwIcon.EnergyCareful;
+                case Icon.Scan: return PwIcon.Scanner;
+                default: return PwIcon.Key;
+            }
+        }
+    }
+}

ModernKeePass.Infrastructure/KeePass/KeePassCredentialsClient.cs

@@ -0,0 +1,48 @@
+using ModernKeePass.Application.Common.Interfaces;
+using ModernKeePass.Domain.Dtos;
+using ModernKeePassLib.Cryptography;
+using ModernKeePassLib.Cryptography.PasswordGenerator;
+using ModernKeePassLib.Keys;
+using ModernKeePassLib.Security;
+
+namespace ModernKeePass.Infrastructure.KeePass
+{
+    public class KeePassCredentialsClient: ICredentialsProxy
+    {
+        public string GeneratePassword(PasswordGenerationOptions options)
+        {
+            var pwProfile = new PwProfile
+            {
+                GeneratorType = PasswordGeneratorType.CharSet,
+                Length = (uint)options.PasswordLength,
+                CharSet = new PwCharSet()
+            };
+
+            if (options.UpperCasePatternSelected) pwProfile.CharSet.Add(PwCharSet.UpperCase);
+            if (options.LowerCasePatternSelected) pwProfile.CharSet.Add(PwCharSet.LowerCase);
+            if (options.DigitsPatternSelected) pwProfile.CharSet.Add(PwCharSet.Digits);
+            if (options.SpecialPatternSelected) pwProfile.CharSet.Add(PwCharSet.Special);
+            if (options.MinusPatternSelected) pwProfile.CharSet.Add('-');
+            if (options.UnderscorePatternSelected) pwProfile.CharSet.Add('_');
+            if (options.SpacePatternSelected) pwProfile.CharSet.Add(' ');
+            if (options.BracketsPatternSelected) pwProfile.CharSet.Add(PwCharSet.Brackets);
+
+            pwProfile.CharSet.Add(options.CustomChars);
+
+            ProtectedString password;
+            PwGenerator.Generate(out password, pwProfile, null, new CustomPwGeneratorPool());
+
+            return password.ReadString();
+        }
+
+        public int EstimatePasswordComplexity(string password)
+        {
+            return (int)QualityEstimation.EstimatePasswordBits(password?.ToCharArray());
+        }
+
+        public byte[] GenerateKeyFile(byte[] additionalEntropy)
+        {
+            return KcpKeyFile.Create(additionalEntropy);
+        }
+    }
+}

ModernKeePass.Infrastructure/KeePass/KeePassCryptographyClient.cs

@@ -0,0 +1,38 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using ModernKeePass.Application.Common.Interfaces;
+using ModernKeePass.Domain.Entities;
+using ModernKeePassLib;
+using ModernKeePassLib.Cryptography.Cipher;
+using ModernKeePassLib.Cryptography.KeyDerivation;
+
+namespace ModernKeePass.Infrastructure.KeePass
+{
+    public class KeePassCryptographyClient: ICryptographyClient
+    {
+        public IEnumerable<BaseEntity> Ciphers
+        {
+            get
+            {
+                for (var inx = 0; inx < CipherPool.GlobalPool.EngineCount; inx++)
+                {
+                    var cipher = CipherPool.GlobalPool[inx];
+                    yield return new BaseEntity
+                    {
+                        Id = cipher.CipherUuid.ToHexString(),
+                        Name = cipher.DisplayName
+                    };
+                }
+            }
+        }
+
+        public IEnumerable<BaseEntity> KeyDerivations => KdfPool.Engines.Select(e => new BaseEntity
+        {
+            Id = e.Uuid.ToHexString(),
+            Name = e.Name
+        });
+
+        public IEnumerable<string> CompressionAlgorithms => Enum.GetNames(typeof(PwCompressionAlgorithm)).Take((int) PwCompressionAlgorithm.Count);
+    }
+}

ModernKeePass.Infrastructure/KeePass/KeePassDatabaseClient.cs

@@ -0,0 +1,400 @@
+using System;
+using System.Collections.Generic;
+using System.Drawing;
+using System.Linq;
+using System.Threading.Tasks;
+using AutoMapper;
+using ModernKeePass.Application.Common.Interfaces;
+using ModernKeePass.Domain.Dtos;
+using ModernKeePass.Domain.Entities;
+using ModernKeePass.Domain.Enums;
+using ModernKeePass.Domain.Interfaces;
+using ModernKeePassLib;
+using ModernKeePassLib.Collections;
+using ModernKeePassLib.Cryptography.Cipher;
+using ModernKeePassLib.Cryptography.KeyDerivation;
+using ModernKeePassLib.Interfaces;
+using ModernKeePassLib.Keys;
+using ModernKeePassLib.Security;
+using ModernKeePassLib.Serialization;
+using ModernKeePassLib.Utility;
+
+namespace ModernKeePass.Infrastructure.KeePass
+{
+    public class KeePassDatabaseClient: IDatabaseProxy, IDisposable
+    {
+        private readonly IMapper _mapper;
+        private readonly IDateTime _dateTime;
+        private readonly PwDatabase _pwDatabase = new PwDatabase();
+        private Credentials _credentials;
+        // Flag: Has Dispose already been called?
+        private bool _disposed;
+        
+        // Main information
+        public bool IsOpen => (_pwDatabase?.IsOpen).GetValueOrDefault();
+        public string Name => _pwDatabase?.Name;
+        public string RootGroupId => _pwDatabase?.RootGroup.Uuid.ToHexString();
+
+        // TODO: find a correct place for this
+        public string FileAccessToken { get; set; }
+        public int Size { get; set; }
+        public bool IsDirty { get; set; }
+
+        // Settings
+        public bool IsRecycleBinEnabled
+        {
+            get { return _pwDatabase.RecycleBinEnabled; }
+            set { _pwDatabase.RecycleBinEnabled = value; }
+        }
+
+        public string RecycleBinId 
+        {
+            get
+            {
+                return _pwDatabase.RecycleBinUuid.ToHexString();
+            }
+            set
+            {
+                _pwDatabase.RecycleBinUuid = BuildIdFromString(value);
+                _pwDatabase.RecycleBinChanged = _dateTime.Now;
+            }
+        }
+
+        public string CipherId
+        {
+            get { return _pwDatabase.DataCipherUuid.ToHexString(); }
+            set { _pwDatabase.DataCipherUuid = BuildIdFromString(value); }
+        }
+
+        public string KeyDerivationId
+        {
+            get { return _pwDatabase.KdfParameters.KdfUuid.ToHexString(); }
+            set
+            {
+                _pwDatabase.KdfParameters = KdfPool.Engines
+                    .FirstOrDefault(e => e.Uuid.Equals(BuildIdFromString(value)))?.GetDefaultParameters();
+            }
+        }
+
+        public string Compression
+        {
+            get { return _pwDatabase.Compression.ToString("G"); }
+            set { _pwDatabase.Compression = (PwCompressionAlgorithm) Enum.Parse(typeof(PwCompressionAlgorithm), value); }
+        }
+
+        public KeePassDatabaseClient(IMapper mapper, IDateTime dateTime)
+        {
+            _mapper = mapper;
+            _dateTime = dateTime;
+        }
+
+        public async Task Open(byte[] file, Credentials credentials)
+        {
+            try
+            {
+                await Task.Run(() => 
+                { 
+                    var compositeKey = CreateCompositeKey(credentials);
+                    var ioConnection = IOConnectionInfo.FromByteArray(file);
+
+                    _pwDatabase.Open(ioConnection, compositeKey, new NullStatusLogger());
+
+                    _credentials = credentials;
+                });
+            }
+            catch (InvalidCompositeKeyException ex)
+            {
+                throw new ArgumentException(ex.Message, ex);
+            }
+        }
+
+        public async Task ReOpen(byte[] file)
+        { 
+            await Open(file, _credentials);
+        }
+
+        public async Task Create(Credentials credentials, string name, DatabaseVersion version = DatabaseVersion.V4)
+        {
+            try
+            {
+                await Task.Run(() =>
+                {
+                    var compositeKey = CreateCompositeKey(credentials);
+                    var ioConnection = IOConnectionInfo.FromByteArray(new byte[] {});
+
+                    _pwDatabase.New(ioConnection, compositeKey);
+                    _pwDatabase.Name = name;
+                    _pwDatabase.RootGroup.Name = name;
+
+                    _credentials = credentials;
+
+                    switch (version)
+                    {
+                        case DatabaseVersion.V4:
+                            _pwDatabase.KdfParameters = KdfPool.Get("Argon2").GetDefaultParameters();
+                            _pwDatabase.DataCipherUuid = CipherPool.GlobalPool[1].CipherUuid;
+                            break;
+                    }
+                });
+            }
+            catch (Exception ex)
+            {
+                throw new ArgumentException(ex.Message, ex);
+            }
+        }
+
+        public async Task<byte[]> SaveDatabase()
+        {
+            return await Task.Run(() =>
+            {
+                _pwDatabase.Save(new NullStatusLogger());
+                return _pwDatabase.IOConnectionInfo.Bytes;
+            });
+        }
+
+        public async Task<byte[]> SaveDatabase(byte[] newFileContents)
+        {
+            return await Task.Run(() =>
+            {
+                _pwDatabase.SaveAs(IOConnectionInfo.FromByteArray(newFileContents), true, new NullStatusLogger());
+                return _pwDatabase.IOConnectionInfo.Bytes;
+            });
+        }
+        
+        public void CloseDatabase()
+        {
+            _pwDatabase?.Close();
+        }
+
+        public async Task AddEntry(string parentGroupId, string entryId)
+        {
+            await Task.Run(() =>
+            {
+                var parentPwGroup = _pwDatabase.RootGroup.FindGroup(BuildIdFromString(parentGroupId), true);
+                var pwEntry = _pwDatabase.RootGroup.FindEntry(BuildIdFromString(entryId), true);
+                parentPwGroup.AddEntry(pwEntry, true);
+            });
+        }
+
+        public async Task MoveEntry(string parentGroupId, string entryId, int index)
+        {
+            await Task.Run(() =>
+            {
+                var parentPwGroup = _pwDatabase.RootGroup.FindGroup(BuildIdFromString(parentGroupId), true);
+                var pwEntry = _pwDatabase.RootGroup.FindEntry(BuildIdFromString(entryId), true);
+                var currentIndex = (uint)parentPwGroup.Entries.IndexOf(pwEntry);
+
+                parentPwGroup.Entries.RemoveAt(currentIndex);
+                parentPwGroup.Entries.Insert((uint)index, pwEntry);
+            });
+        }
+
+        public async Task AddGroup(string parentGroupId, string groupId)
+        {
+            await Task.Run(() =>
+            {
+                var parentPwGroup = _pwDatabase.RootGroup.FindGroup(BuildIdFromString(parentGroupId), true);
+                var pwGroup = _pwDatabase.RootGroup.FindGroup(BuildIdFromString(groupId), true);
+                parentPwGroup.AddGroup(pwGroup, true);
+            });
+        }
+        public async Task RemoveEntry(string parentGroupId, string entryId)
+        {
+            await Task.Run(() =>
+            {
+                var parentPwGroup = _pwDatabase.RootGroup.FindGroup(BuildIdFromString(parentGroupId), true);
+                var pwEntry = parentPwGroup.FindEntry(BuildIdFromString(entryId), false);
+                parentPwGroup.Entries.Remove(pwEntry);
+            });
+        }
+
+        public async Task RemoveGroup(string parentGroupId, string groupId)
+        {
+            await Task.Run(() =>
+            {
+                var parentPwGroup = _pwDatabase.RootGroup.FindGroup(BuildIdFromString(parentGroupId), true);
+                var pwGroup = parentPwGroup.FindGroup(BuildIdFromString(groupId), false);
+                parentPwGroup.Groups.Remove(pwGroup);
+            });
+        }
+
+        public void DeleteEntity(string entityId)
+        {
+            _pwDatabase.DeletedObjects.Add(new PwDeletedObject(BuildIdFromString(entityId), _dateTime.Now));
+        }
+
+        public void UpdateEntry(string entryId, string fieldName, object fieldValue)
+        {
+            var pwEntry = _pwDatabase.RootGroup.FindEntry(BuildIdFromString(entryId), true);
+
+            switch (fieldName)
+            {
+                case EntryFieldName.Title:
+                case EntryFieldName.UserName:
+                case EntryFieldName.Password:
+                case EntryFieldName.Notes:
+                case EntryFieldName.Url:
+                    pwEntry.Strings.Set(EntryFieldMapper.MapFieldToPwDef(fieldName), new ProtectedString(true, fieldValue.ToString()));
+                    break;
+                case EntryFieldName.HasExpirationDate:
+                    pwEntry.Expires = (bool)fieldValue;
+                    break;
+                case EntryFieldName.ExpirationDate:
+                    pwEntry.ExpiryTime = (DateTime)fieldValue;
+                    break;
+                case EntryFieldName.Icon:
+                    pwEntry.IconId = IconMapper.MapIconToPwIcon((Icon)fieldValue);
+                    break;
+                case EntryFieldName.BackgroundColor:
+                    pwEntry.BackgroundColor = (Color)fieldValue;
+                    break;
+                case EntryFieldName.ForegroundColor:
+                    pwEntry.ForegroundColor = (Color)fieldValue;
+                    break;
+            }
+        }
+
+        public EntryEntity AddHistory(string entryId)
+        {
+            var pwEntry = _pwDatabase.RootGroup.FindEntry(BuildIdFromString(entryId), true);
+            pwEntry.Touch(true);
+            pwEntry.CreateBackup(null);
+            return _mapper.Map<EntryEntity>(pwEntry.History.Last());
+        }
+
+        public EntryEntity RestoreFromHistory(string entryId, int historyIndex)
+        {
+            var pwEntry = _pwDatabase.RootGroup.FindEntry(BuildIdFromString(entryId), true);
+            pwEntry.RestoreFromBackup((uint)historyIndex, _pwDatabase);
+            pwEntry.Touch(true);
+            return _mapper.Map<EntryEntity>(pwEntry);
+        }
+
+        public void DeleteHistory(string entryId, int historyIndex)
+        {
+            var pwEntry = _pwDatabase.RootGroup.FindEntry(BuildIdFromString(entryId), true);
+            pwEntry.History.RemoveAt((uint)historyIndex);
+        }
+
+        public void UpdateGroup(GroupEntity group)
+        {
+            var pwGroup = _pwDatabase.RootGroup.FindGroup(BuildIdFromString(group.Id), true);
+            pwGroup.Name = group.Name;
+            pwGroup.IconId = IconMapper.MapIconToPwIcon(group.Icon);
+            pwGroup.Touch(true);
+        }
+        
+        public EntryEntity CreateEntry(string parentGroupId)
+        {
+            var pwEntry = new PwEntry(true, true);
+            var parentPwGroup = _pwDatabase.RootGroup.FindGroup(BuildIdFromString(parentGroupId), true);
+            parentPwGroup.AddEntry(pwEntry, true);
+
+            return _mapper.Map<EntryEntity>(pwEntry);
+        }
+
+        public GroupEntity CreateGroup(string parentGroupId, string name, bool isRecycleBin = false)
+        {
+            var pwGroup = new PwGroup(true, true, name, isRecycleBin? PwIcon.TrashBin : PwIcon.Folder);
+            var parentPwGroup = _pwDatabase.RootGroup.FindGroup(BuildIdFromString(parentGroupId), true);
+            parentPwGroup.AddGroup(pwGroup, true);
+            if (isRecycleBin) _pwDatabase.RecycleBinUuid = pwGroup.Uuid;
+
+            return _mapper.Map<GroupEntity>(pwGroup);
+        }
+
+        public void SortEntries(string groupId)
+        {
+            var pwGroup = _pwDatabase.RootGroup.FindGroup(BuildIdFromString(groupId), true);
+            var comparer = new PwEntryComparer(PwDefs.TitleField, true, false);
+            pwGroup.Entries.Sort(comparer);
+        }
+
+        public void SortSubGroups(string groupId)
+        {
+            var pwGroup = _pwDatabase.RootGroup.FindGroup(BuildIdFromString(groupId), true);
+            pwGroup.SortSubGroups(false);
+        }
+
+        public EntryEntity GetEntry(string id)
+        {
+            var pwEntry = _pwDatabase.RootGroup.FindEntry(BuildIdFromString(id), true);
+            return _mapper.Map<EntryEntity>(pwEntry);
+        }
+
+        public GroupEntity GetGroup(string id)
+        {
+            var pwGroup = _pwDatabase.RootGroup.FindGroup(BuildIdFromString(id), true);
+            return _mapper.Map<GroupEntity>(pwGroup);
+        }
+
+        public void UpdateCredentials(Credentials credentials)
+        {
+            _pwDatabase.MasterKey = CreateCompositeKey(credentials);
+            _credentials = credentials;
+        }
+
+        public IEnumerable<EntryEntity> Search(string groupId, string text)
+        {
+            var pwGroup = _pwDatabase.RootGroup.FindGroup(BuildIdFromString(groupId), true);
+            var searchResults = new PwObjectList<PwEntry>();
+            pwGroup.SearchEntries(new SearchParameters
+            {
+                ComparisonMode = StringComparison.OrdinalIgnoreCase,
+                SearchInTitles = true,
+                //SearchInUserNames = true,
+                SearchString = text
+
+            }, searchResults);
+            return searchResults.Select(e => _mapper.Map<EntryEntity>(e));
+        }
+
+        public IEnumerable<BaseEntity> GetAllGroups(string groupId)
+        {
+            var pwGroup = _pwDatabase.RootGroup.FindGroup(BuildIdFromString(groupId), true);
+            var groups = pwGroup.GetGroups(true).Select(g => new GroupEntity
+            {
+                Id = g.Uuid.ToHexString(),
+                Name = g.Name,
+                ParentName = g.ParentGroup?.Name
+            });
+            return groups;
+        }
+
+        private CompositeKey CreateCompositeKey(Credentials credentials)
+        {
+            var compositeKey = new CompositeKey();
+            if (credentials.Password != null) compositeKey.AddUserKey(new KcpPassword(credentials.Password));
+            if (credentials.KeyFileContents != null)
+            {
+                compositeKey.AddUserKey(new KcpKeyFile(IOConnectionInfo.FromByteArray(credentials.KeyFileContents)));
+            }
+            return compositeKey;
+        }
+        
+        private PwUuid BuildIdFromString(string id)
+        {
+            return new PwUuid(MemUtil.HexStringToByteArray(id));
+        }
+
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        // Protected implementation of Dispose pattern.
+        protected virtual void Dispose(bool disposing)
+        {
+            if (_disposed)
+                return;
+
+            if (disposing)
+            {
+                _pwDatabase?.Close();
+            }
+
+            _disposed = true;
+        }
+    }
+}