wismna/modernkeepass
1
0
Fork 0
mirror of https://github.com/wismna/ModernKeePass.git synced 2025-10-03 15:40:18 -04:00
Code Issues Packages Projects Releases Wiki Activity

Most services are implemented as command/queries

Browse Source 
Code cleanup
This commit is contained in:
Geoffroy BONNEVILLE
2020-03-26 19:04:51 +01:00
parent 903e7649e4
commit 22072bb2fe
46 changed files with 567 additions and 390 deletions
Download Patch File Download Diff File Expand all files Collapse all files

27
ModernKeePass.Application/Application.csproj
View File

@@ -54,15 +54,18 @@
<Compile Include="Common\Interfaces\ISettingsProxy.cs" />
<Compile Include="Common\Mappings\IMapFrom.cs" />
<Compile Include="Common\Mappings\MappingProfile.cs" />
<Compile Include="Common\Mappings\MappingProfiles.cs" />
<Compile Include="Cryptography\Models\CipherVm.cs" />
<Compile Include="Cryptography\Models\KeyDerivationVm.cs" />
<Compile Include="Cryptography\Queries\GetCiphers\GetCiphersQuery.cs" />
<Compile Include="Cryptography\Queries\GetCompressions\GetCompressionsQuery.cs" />
<Compile Include="Cryptography\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\Models\MainVm.cs" />
<Compile Include="Database\Queries\GetDatabase\GetDatabaseQuery.cs" />
<Compile Include="Database\Queries\IsDatabaseOpen\IsDatabaseOpenQuery.cs" />
<Compile Include="Database\Queries\OpenDatabase\OpenDatabaseQuery.cs" />
<Compile Include="Database\Queries\OpenDatabase\OpenDatabaseQueryValidator.cs" />
<Compile Include="Database\Queries\ReOpenDatabase\ReOpenDatabaseQuery.cs" />
@@ -81,14 +84,19 @@
<Compile Include="Group\Commands\SortGroups\SortGroupsCommand.cs" />
<Compile Include="Group\Models\GroupVm.cs" />
<Compile Include="Properties\AssemblyInfo.cs" />
<Compile Include="Recent\Commands\AddRecent\AddRecentCommand.cs" />
<Compile Include="Recent\Commands\ClearAllRecent\ClearAllRecentCommand.cs" />
<Compile Include="Recent\Models\RecentVm.cs" />
<Compile Include="Recent\Queries\GetAllRecent\GetAllRecentQuery.cs" />
<Compile Include="Recent\Queries\GetRecent\GetRecentQuery.cs" />
<Compile Include="Recent\Queries\HasRecent\HasRecentQuery.cs" />
<Compile Include="Resources\Queries\GetResourceQuery.cs" />
<Content Include="Services\CryptographyService.cs" />
<Compile Include="Security\Commands\GenerateKeyFile\GenerateKeyFileCommand.cs" />
<Compile Include="Security\Commands\GeneratePassword\GeneratePasswordCommand.cs" />
<Compile Include="Security\Queries\EstimatePasswordComplexity\EstimatePasswordComplexityQuery.cs" />
<Compile Include="Settings\Commands\PutSettingCommand.cs" />
<Compile Include="Settings\Queries\GetSettingQuery.cs" />
<Content Include="Services\DatabaseService.cs" />
<Content Include="Services\FileService.cs" />
<Content Include="Services\ImportService.cs" />
<Content Include="Services\RecentService.cs" />
<Content Include="Services\SecurityService.cs" />
<Content Include="Services\SettingsService.cs" />
</ItemGroup>
<ItemGroup>
<Folder Include="Entry\Queries\GetEntry\" />
@@ -97,7 +105,6 @@
<Folder Include="Parameters\Commands\SetCipher\" />
<Folder Include="Parameters\Commands\SetCompression\" />
<Folder Include="Parameters\Commands\SetKeyDerivation\" />
<Folder Include="Settings\" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\ModernKeePass.Domain\Domain.csproj">

2
ModernKeePass.Application/ApplicationModule.cs
View File

@@ -12,7 +12,7 @@ namespace ModernKeePass.Application
protected override void Load(ContainerBuilder builder)
{
// Register Automapper profiles
builder.RegisterType<MappingProfiles>().As<Profile>();
builder.RegisterType<MappingProfile>().As<Profile>();
// Register Mediatr
builder

16
ModernKeePass.Application/Common/Mappings/MappingProfiles.cs
View File

@@ -1,16 +0,0 @@
using AutoMapper;
using ModernKeePass.Application.Database.Models;
using ModernKeePass.Application.Entry.Models;
using ModernKeePass.Application.Group.Models;
namespace ModernKeePass.Application.Common.Mappings
{
public class MappingProfiles: Profile
{
public void ApplyMappings()
{
new EntryVm().Mapping(this);
new GroupVm().Mapping(this);
}
}
}

18
ModernKeePass.Application/Cryptography/Models/CipherVm.cs Normal file
View File

@@ -0,0 +1,18 @@
using AutoMapper;
using ModernKeePass.Application.Common.Mappings;
using ModernKeePass.Domain.Entities;
namespace ModernKeePass.Application.Cryptography.Models
{
public class CipherVm: IMapFrom<BaseEntity>
{
public string Id { get; set; }
public string Name { get; set; }
public void Mapping(Profile profile)
{
profile.CreateMap<BaseEntity, CipherVm>()
.ForMember(d => d.Id, opts => opts.MapFrom(s => s.Id))
.ForMember(d => d.Name, opts => opts.MapFrom(s => s.Name));
}
}
}

19
ModernKeePass.Application/Cryptography/Models/KeyDerivationVm.cs Normal file
View File

@@ -0,0 +1,19 @@
using AutoMapper;
using ModernKeePass.Application.Common.Mappings;
using ModernKeePass.Domain.Entities;
namespace ModernKeePass.Application.Cryptography.Models
{
public class KeyDerivationVm : IMapFrom<BaseEntity>
{
public string Id { get; set; }
public string Name { get; set; }
public void Mapping(Profile profile)
{
profile.CreateMap<BaseEntity, CipherVm>()
.ForMember(d => d.Id, opts => opts.MapFrom(s => s.Id))
.ForMember(d => d.Name, opts => opts.MapFrom(s => s.Name));
}
}
}

28
ModernKeePass.Application/Cryptography/Queries/GetCiphers/GetCiphersQuery.cs Normal file
View File

@@ -0,0 +1,28 @@
using System.Collections.Generic;
using AutoMapper;
using MediatR;
using ModernKeePass.Application.Common.Interfaces;
using ModernKeePass.Application.Cryptography.Models;
namespace ModernKeePass.Application.Cryptography.Queries.GetCiphers
{
public class GetCiphersQuery: IRequest<IEnumerable<CipherVm>>
{
public class GetCiphersQueryHandler: IRequestHandler<GetCiphersQuery, IEnumerable<CipherVm>>
{
private readonly ICryptographyClient _cryptography;
private readonly IMapper _mapper;
public GetCiphersQueryHandler(ICryptographyClient cryptography, IMapper mapper)
{
_cryptography = cryptography;
_mapper = mapper;
}
public IEnumerable<CipherVm> Handle(GetCiphersQuery message)
{
yield return _mapper.Map<CipherVm>(_cryptography.Ciphers);
}
}
}
}

25
ModernKeePass.Application/Cryptography/Queries/GetCompressions/GetCompressionsQuery.cs Normal file
View File

@@ -0,0 +1,25 @@
using System.Collections.Generic;
using System.Linq;
using MediatR;
using ModernKeePass.Application.Common.Interfaces;
namespace ModernKeePass.Application.Cryptography.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);
}
}
}
}

28
ModernKeePass.Application/Cryptography/Queries/GetKeyDerivations/GetKeyDerivationsQuery.cs Normal file
View File

@@ -0,0 +1,28 @@
using System.Collections.Generic;
using AutoMapper;
using MediatR;
using ModernKeePass.Application.Common.Interfaces;
using ModernKeePass.Application.Cryptography.Models;
namespace ModernKeePass.Application.Cryptography.Queries.GetKeyDerivations
{
public class GetKeyDerivationsQuery : IRequest<IEnumerable<KeyDerivationVm>>
{
public class GetKeyDerivationsQueryHandler : IRequestHandler<GetKeyDerivationsQuery, IEnumerable<KeyDerivationVm>>
{
private readonly ICryptographyClient _cryptography;
private readonly IMapper _mapper;
public GetKeyDerivationsQueryHandler(ICryptographyClient cryptography, IMapper mapper)
{
_cryptography = cryptography;
_mapper = mapper;
}
public IEnumerable<KeyDerivationVm> Handle(GetKeyDerivationsQuery message)
{
yield return _mapper.Map<KeyDerivationVm>(_cryptography.KeyDerivations);
}
}
}
}

8
ModernKeePass.Application/Database/Commands/CloseDatabase/CloseDatabaseCommand.cs
View File

@@ -1,7 +1,6 @@
using MediatR;
using System.Threading.Tasks;
using ModernKeePass.Application.Common.Interfaces;
using ModernKeePass.Application.Database.Queries.IsDatabaseOpen;
using ModernKeePass.Domain.Exceptions;
namespace ModernKeePass.Application.Database.Commands.CloseDatabase
@@ -11,17 +10,14 @@ namespace ModernKeePass.Application.Database.Commands.CloseDatabase
public class CloseDatabaseCommandHandler : IAsyncRequestHandler<CloseDatabaseCommand>
{
private readonly IDatabaseProxy _database;
private readonly IMediator _mediator;
public CloseDatabaseCommandHandler(IDatabaseProxy database, IMediator mediator)
public CloseDatabaseCommandHandler(IDatabaseProxy database)
{
_database = database;
_mediator = mediator;
}
public async Task Handle(CloseDatabaseCommand message)
{
var isDatabaseOpen = await _mediator.Send(new IsDatabaseOpenQuery());
if (isDatabaseOpen) _database.CloseDatabase();
if (_database.IsOpen) _database.CloseDatabase();
else throw new DatabaseClosedException();
}
}

24
ModernKeePass.Application/Database/Commands/CreateDatabase/CreateDatabaseCommand.cs
View File

@@ -2,7 +2,6 @@
using System.Threading.Tasks;
using AutoMapper;
using ModernKeePass.Application.Common.Interfaces;
using ModernKeePass.Application.Database.Queries.IsDatabaseOpen;
using ModernKeePass.Application.Group.Models;
using ModernKeePass.Domain.Dtos;
using ModernKeePass.Domain.Exceptions;
@@ -11,28 +10,35 @@ namespace ModernKeePass.Application.Database.Commands.CreateDatabase
{
public class CreateDatabaseCommand : IRequest<GroupVm>
{
public FileInfo FileInfo { get; set; }
public Credentials Credentials { get; set; }
public string FilePath { get; set; }
public string Password { get; set; }
public string KeyFilePath { get; set; }
public class CreateDatabaseCommandHandler : IAsyncRequestHandler<CreateDatabaseCommand, GroupVm>
{
private readonly IDatabaseProxy _database;
private readonly IMediator _mediator;
private readonly IMapper _mapper;
public CreateDatabaseCommandHandler(IDatabaseProxy database, IMediator mediator, IMapper mapper)
public CreateDatabaseCommandHandler(IDatabaseProxy database, IMapper mapper)
{
_database = database;
_mediator = mediator;
_mapper = mapper;
}
public async Task<GroupVm> Handle(CreateDatabaseCommand message)
{
var isDatabaseOpen = await _mediator.Send(new IsDatabaseOpenQuery());
if (isDatabaseOpen) throw new DatabaseOpenException();
if (_database.IsOpen) throw new DatabaseOpenException();
var rootGroup = await _database.Create(message.FileInfo, message.Credentials);
var rootGroup = await _database.Create(
new FileInfo
{
Path = message.FilePath
},
new Credentials
{
KeyFilePath = message.KeyFilePath,
Password = message.Password
});
return _mapper.Map<GroupVm>(rootGroup);
}

22
ModernKeePass.Application/Database/Commands/CreateDatabase/CreateDatabaseQueryValidator.cs Normal file
View File

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

16
ModernKeePass.Application/Database/Commands/SaveDatabase/SaveDatabaseCommand.cs
View File

@@ -1,7 +1,6 @@
using MediatR;
using System.Threading.Tasks;
using ModernKeePass.Application.Common.Interfaces;
using ModernKeePass.Application.Database.Queries.IsDatabaseOpen;
using ModernKeePass.Domain.Dtos;
using ModernKeePass.Domain.Exceptions;
@@ -14,23 +13,18 @@ namespace ModernKeePass.Application.Database.Commands.SaveDatabase
public class SaveDatabaseCommandHandler : IAsyncRequestHandler<SaveDatabaseCommand>
{
private readonly IDatabaseProxy _database;
private readonly IMediator _mediator;
public SaveDatabaseCommandHandler(IDatabaseProxy database, IMediator mediator)
public SaveDatabaseCommandHandler(IDatabaseProxy database)
{
_database = database;
_mediator = mediator;
}
public async Task Handle(SaveDatabaseCommand message)
{
var isDatabaseOpen = await _mediator.Send(new IsDatabaseOpenQuery());
if (isDatabaseOpen)
{
if (message.FileInfo != null) await _database.SaveDatabase(message.FileInfo);
else await _database.SaveDatabase();
}
else throw new DatabaseClosedException();
if (!_database.IsOpen) throw new DatabaseClosedException();
if (message.FileInfo != null) await _database.SaveDatabase(message.FileInfo);
else await _database.SaveDatabase();
}
}
}

6
ModernKeePass.Application/Database/Commands/UpdateCredentials/UpdateCredentialsCommand.cs
View File

@@ -1,7 +1,6 @@
using System.Threading.Tasks;
using MediatR;
using ModernKeePass.Application.Common.Interfaces;
using ModernKeePass.Application.Database.Queries.IsDatabaseOpen;
using ModernKeePass.Domain.Dtos;
using ModernKeePass.Domain.Exceptions;
@@ -14,18 +13,15 @@ namespace ModernKeePass.Application.Database.Commands.UpdateCredentials
public class UpdateCredentialsCommandHandler : IAsyncRequestHandler<UpdateCredentialsCommand>
{
private readonly IDatabaseProxy _database;
private readonly IMediator _mediator;
public UpdateCredentialsCommandHandler(IDatabaseProxy database, IMediator mediator)
{
_database = database;
_mediator = mediator;
}
public async Task Handle(UpdateCredentialsCommand message)
{
var isDatabaseOpen = await _mediator.Send(new IsDatabaseOpenQuery());
if (isDatabaseOpen) await _database.UpdateCredentials(message.Credentials);
if (_database.IsOpen) await _database.UpdateCredentials(message.Credentials);
else throw new DatabaseClosedException();
}
}

7
ModernKeePass.Application/Database/Models/MainVm.cs
View File

@@ -1,7 +0,0 @@
namespace ModernKeePass.Application.Database.Models
{
public class MainVm
{
}
}

24
ModernKeePass.Application/Database/Queries/IsDatabaseOpen/IsDatabaseOpenQuery.cs
View File

@@ -1,24 +0,0 @@
using MediatR;
using ModernKeePass.Application.Common.Interfaces;
namespace ModernKeePass.Application.Database.Queries.IsDatabaseOpen
{
public class IsDatabaseOpenQuery: IRequest<bool>
{
public class IsDatabaseOpenQueryHandler: IRequestHandler<IsDatabaseOpenQuery, bool>
{
private readonly IDatabaseProxy _databaseProxy;
public IsDatabaseOpenQueryHandler(IDatabaseProxy databaseProxy)
{
_databaseProxy = databaseProxy;
}
public bool Handle(IsDatabaseOpenQuery message)
{
return _databaseProxy.IsOpen;
}
}
}
}

28
ModernKeePass.Application/Database/Queries/OpenDatabase/OpenDatabaseQuery.cs
View File

@@ -2,7 +2,6 @@
using AutoMapper;
using MediatR;
using ModernKeePass.Application.Common.Interfaces;
using ModernKeePass.Application.Database.Queries.IsDatabaseOpen;
using ModernKeePass.Application.Group.Models;
using ModernKeePass.Domain.Dtos;
using ModernKeePass.Domain.Exceptions;
@@ -11,28 +10,35 @@ namespace ModernKeePass.Application.Database.Queries.OpenDatabase
{
public class OpenDatabaseQuery: IRequest<GroupVm>
{
public FileInfo FileInfo { get; set; }
public Credentials Credentials { get; set; }
public string FilePath { get; set; }
public string Password { get; set; }
public string KeyFilePath { get; set; }
public class OpenDatabaseQueryHandler : IAsyncRequestHandler<OpenDatabaseQuery, GroupVm>
{
private readonly IMapper _mapper;
private readonly IMediator _mediator;
private readonly IDatabaseProxy _databaseProxy;
private readonly IDatabaseProxy _database;
public OpenDatabaseQueryHandler(IMapper mapper, IMediator mediator, IDatabaseProxy databaseProxy)
public OpenDatabaseQueryHandler(IMapper mapper, IDatabaseProxy database)
{
_mapper = mapper;
_mediator = mediator;
_databaseProxy = databaseProxy;
_database = database;
}
public async Task<GroupVm> Handle(OpenDatabaseQuery request)
{
var isDatabaseOpen = await _mediator.Send(new IsDatabaseOpenQuery());
if (isDatabaseOpen) throw new DatabaseOpenException();
if (_database.IsOpen) throw new DatabaseOpenException();
var rootGroup = await _databaseProxy.Open(request.FileInfo, request.Credentials);
var rootGroup = await _database.Open(
new FileInfo
{
Path = request.FilePath
},
new Credentials
{
KeyFilePath = request.KeyFilePath,
Password = request.Password
});
return _mapper.Map<GroupVm>(rootGroup);
}
}

12
ModernKeePass.Application/Database/Queries/OpenDatabase/OpenDatabaseQueryValidator.cs
View File

@@ -6,7 +6,17 @@ namespace ModernKeePass.Application.Database.Queries.OpenDatabase
{
public OpenDatabaseQueryValidator()
{
RuleFor(v => v.Credentials != null && v.FileInfo != null);
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));
}
}
}

14
ModernKeePass.Application/Database/Queries/ReOpenDatabase/ReOpenDatabaseQuery.cs
View File

@@ -2,7 +2,6 @@
using AutoMapper;
using MediatR;
using ModernKeePass.Application.Common.Interfaces;
using ModernKeePass.Application.Database.Queries.IsDatabaseOpen;
using ModernKeePass.Application.Group.Models;
using ModernKeePass.Domain.Exceptions;
@@ -13,22 +12,19 @@ namespace ModernKeePass.Application.Database.Queries.ReOpenDatabase
public class ReOpenDatabaseQueryHandler : IAsyncRequestHandler<ReOpenDatabaseQuery, GroupVm>
{
private readonly IMapper _mapper;
private readonly IMediator _mediator;
private readonly IDatabaseProxy _databaseProxy;
private readonly IDatabaseProxy _database;
public ReOpenDatabaseQueryHandler(IMapper mapper, IMediator mediator, IDatabaseProxy databaseProxy)
public ReOpenDatabaseQueryHandler(IMapper mapper, IDatabaseProxy database)
{
_mapper = mapper;
_mediator = mediator;
_databaseProxy = databaseProxy;
_database = database;
}
public async Task<GroupVm> Handle(ReOpenDatabaseQuery request)
{
var isDatabaseOpen = await _mediator.Send(new IsDatabaseOpenQuery());
if (!isDatabaseOpen) throw new DatabaseClosedException();
if (!_database.IsOpen) throw new DatabaseClosedException();
var rootGroup = await _databaseProxy.ReOpen();
var rootGroup = await _database.ReOpen();
return _mapper.Map<GroupVm>(rootGroup);
}
}

15
ModernKeePass.Application/Entry/Commands/SetFieldValue/SetFieldValueCommand.cs
View File

@@ -1,7 +1,5 @@
using System.Threading.Tasks;
using MediatR;
using MediatR;
using ModernKeePass.Application.Common.Interfaces;
using ModernKeePass.Application.Database.Queries.IsDatabaseOpen;
using ModernKeePass.Domain.Exceptions;
namespace ModernKeePass.Application.Entry.Commands.SetFieldValue
@@ -12,21 +10,18 @@ namespace ModernKeePass.Application.Entry.Commands.SetFieldValue
public string FieldName { get; set; }
public string FieldValue { get; set; }
public class SetFieldValueCommandHandler : IAsyncRequestHandler<SetFieldValueCommand>
public class SetFieldValueCommandHandler : IRequestHandler<SetFieldValueCommand>
{
private readonly IDatabaseProxy _database;
private readonly IMediator _mediator;
public SetFieldValueCommandHandler(IDatabaseProxy database, IMediator mediator)
public SetFieldValueCommandHandler(IDatabaseProxy database)
{
_database = database;
_mediator = mediator;
}
public async Task Handle(SetFieldValueCommand message)
public void Handle(SetFieldValueCommand message)
{
var isDatabaseOpen = await _mediator.Send(new IsDatabaseOpenQuery());
if (!isDatabaseOpen) throw new DatabaseClosedException();
if (!_database.IsOpen) throw new DatabaseClosedException();
_database.UpdateEntry(message.EntryId, message.FieldName, message.FieldValue);
}

8
ModernKeePass.Application/Group/Commands/AddEntry/AddEntryCommand.cs
View File

@@ -1,7 +1,6 @@
using System.Threading.Tasks;
using MediatR;
using ModernKeePass.Application.Common.Interfaces;
using ModernKeePass.Application.Database.Queries.IsDatabaseOpen;
using ModernKeePass.Application.Entry.Models;
using ModernKeePass.Application.Group.Models;
using ModernKeePass.Domain.Exceptions;
@@ -16,18 +15,15 @@ namespace ModernKeePass.Application.Group.Commands.AddEntry
public class AddEntryCommandHandler : IAsyncRequestHandler<AddEntryCommand>
{
private readonly IDatabaseProxy _database;
private readonly IMediator _mediator;
public AddEntryCommandHandler(IDatabaseProxy database, IMediator mediator)
public AddEntryCommandHandler(IDatabaseProxy database)
{
_database = database;
_mediator = mediator;
}
public async Task Handle(AddEntryCommand message)
{
var isDatabaseOpen = await _mediator.Send(new IsDatabaseOpenQuery());
if (!isDatabaseOpen) throw new DatabaseClosedException();
if (!_database.IsOpen) throw new DatabaseClosedException();
/*var entryEntity = new EntryEntity
{
Id = message.Entry.Id,

8
ModernKeePass.Application/Group/Commands/AddGroup/AddGroupCommand.cs
View File

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

15
ModernKeePass.Application/Group/Commands/CreateEntry/CreateEntryCommand.cs
View File

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

15
ModernKeePass.Application/Group/Commands/CreateGroup/CreateGroupCommand.cs
View File

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

8
ModernKeePass.Application/Group/Commands/DeleteEntry/DeleteEntryCommand.cs
View File

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

8
ModernKeePass.Application/Group/Commands/DeleteGroup/DeleteGroupCommand.cs
View File

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

8
ModernKeePass.Application/Group/Commands/RemoveEntry/RemoveEntryCommand.cs
View File

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

8
ModernKeePass.Application/Group/Commands/RemoveGroup/RemoveGroupCommand.cs
View File

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

15
ModernKeePass.Application/Group/Commands/SortEntries/SortEntriesCommand.cs
View File

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

15
ModernKeePass.Application/Group/Commands/SortGroups/SortGroupsCommand.cs
View File

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

31
ModernKeePass.Application/Recent/Commands/AddRecent/AddRecentCommand.cs Normal file
View File

@@ -0,0 +1,31 @@
using MediatR;
using ModernKeePass.Application.Common.Interfaces;
using ModernKeePass.Domain.Dtos;
namespace ModernKeePass.Application.Recent.Commands.AddRecent
{
public class AddRecentCommand: IRequest
{
public string Name { get; set; }
public string Path { get; set; }
public class AddRecentCommandHandler: IRequestHandler<AddRecentCommand>
{
private readonly IRecentProxy _recent;
public AddRecentCommandHandler(IRecentProxy recent)
{
_recent = recent;
}
public void Handle(AddRecentCommand message)
{
_recent.Add(new FileInfo
{
Name = message.Name,
Path = message.Path
});
}
}
}
}

23
ModernKeePass.Application/Recent/Commands/ClearAllRecent/ClearAllRecentCommand.cs Normal file
View File

@@ -0,0 +1,23 @@
using MediatR;
using ModernKeePass.Application.Common.Interfaces;
namespace ModernKeePass.Application.Recent.Commands.ClearAllRecent
{
public class ClearAllRecentCommand : IRequest
{
public class ClearAllRecentCommandHandler : IRequestHandler<ClearAllRecentCommand>
{
private readonly IRecentProxy _recent;
public ClearAllRecentCommandHandler(IRecentProxy recent)
{
_recent = recent;
}
public void Handle(ClearAllRecentCommand message)
{
_recent.ClearAll();
}
}
}
}

18
ModernKeePass.Application/Recent/Models/RecentVm.cs Normal file
View File

@@ -0,0 +1,18 @@
using AutoMapper;
using ModernKeePass.Application.Common.Mappings;
using ModernKeePass.Domain.Dtos;
namespace ModernKeePass.Application.Recent.Models
{
public class RecentVm: IMapFrom<FileInfo>
{
public string Name { get; set; }
public string Path { get; set; }
public void Mapping(Profile profile)
{
profile.CreateMap<FileInfo, RecentVm>()
.ForMember(d => d.Name, opts => opts.MapFrom(s => s.Name))
.ForMember(d => d.Path, opts => opts.MapFrom(s => s.Path));
}
}
}

30
ModernKeePass.Application/Recent/Queries/GetAllRecent/GetAllRecentQuery.cs Normal file
View File

@@ -0,0 +1,30 @@
using System.Collections.Generic;
using System.Threading.Tasks;
using AutoMapper;
using MediatR;
using ModernKeePass.Application.Common.Interfaces;
using ModernKeePass.Application.Recent.Models;
namespace ModernKeePass.Application.Recent.Queries.GetAllRecent
{
public class GetAllRecentQuery : IRequest<IEnumerable<RecentVm>>
{
public class GetAllRecentQueryHandler : IAsyncRequestHandler<GetAllRecentQuery, IEnumerable<RecentVm>>
{
private readonly IRecentProxy _recent;
private readonly IMapper _mapper;
public GetAllRecentQueryHandler(IRecentProxy recent, IMapper mapper)
{
_recent = recent;
_mapper = mapper;
}
public async Task<IEnumerable<RecentVm>> Handle(GetAllRecentQuery message)
{
var fileInfo = await _recent.GetAll();
return _mapper.Map<IEnumerable<RecentVm>>(fileInfo);
}
}
}
}

31
ModernKeePass.Application/Recent/Queries/GetRecent/GetRecentQuery.cs Normal file
View File

@@ -0,0 +1,31 @@
using System.Threading.Tasks;
using AutoMapper;
using MediatR;
using ModernKeePass.Application.Common.Interfaces;
using ModernKeePass.Application.Recent.Models;
namespace ModernKeePass.Application.Recent.Queries.GetRecent
{
public class GetRecentQuery : IRequest<RecentVm>
{
public string Token { get; set; }
public class GetRecentQueryHandler : IAsyncRequestHandler<GetRecentQuery, RecentVm>
{
private readonly IRecentProxy _recent;
private readonly IMapper _mapper;
public GetRecentQueryHandler(IRecentProxy recent, IMapper mapper)
{
_recent = recent;
_mapper = mapper;
}
public async Task<RecentVm> Handle(GetRecentQuery message)
{
var fileInfo = await _recent.Get(message.Token);
return _mapper.Map<RecentVm>(fileInfo);
}
}
}
}

23
ModernKeePass.Application/Recent/Queries/HasRecent/HasRecentQuery.cs Normal file
View File

@@ -0,0 +1,23 @@
using MediatR;
using ModernKeePass.Application.Common.Interfaces;
namespace ModernKeePass.Application.Recent.Queries.HasRecent
{
public class HasRecentQuery : IRequest<bool>
{
public class HasRecentQueryHandler : IRequestHandler<HasRecentQuery, bool>
{
private readonly IRecentProxy _recent;
public HasRecentQueryHandler(IRecentProxy recent)
{
_recent = recent;
}
public bool Handle(HasRecentQuery message)
{
return _recent.EntryCount > 0;
}
}
}
}

38
ModernKeePass.Application/Security/Commands/GenerateKeyFile/GenerateKeyFileCommand.cs Normal file
View File

@@ -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 IPasswordProxy _security;
private readonly IFileProxy _file;
public GenerateKeyFileCommandHandler(IPasswordProxy 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);
}
}
}
}

48
ModernKeePass.Application/Security/Commands/GeneratePassword/GeneratePasswordCommand.cs Normal file
View File

@@ -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 IPasswordProxy _security;
public GeneratePasswordCommandHandler(IPasswordProxy 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);
}
}
}
}

25
ModernKeePass.Application/Security/Queries/EstimatePasswordComplexity/EstimatePasswordComplexityQuery.cs Normal file
View File

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

22
ModernKeePass.Application/Services/CryptographyService.cs
View File

@@ -1,22 +0,0 @@
using System.Collections.Generic;
using ModernKeePass.Application.Common.Interfaces;
using ModernKeePass.Domain.Entities;
using ModernKeePass.Domain.Interfaces;
namespace ModernKeePass.Application.Services
{
public class CryptographyService : ICryptographyService
{
private readonly ICryptographyClient _cryptographyClient;
public IEnumerable<Entity> Ciphers => _cryptographyClient.Ciphers;
public IEnumerable<Entity> KeyDerivations => _cryptographyClient.KeyDerivations;
public IEnumerable<string> CompressionAlgorithms => _cryptographyClient.CompressionAlgorithms;
public CryptographyService(ICryptographyClient cryptographyClient)
{
_cryptographyClient = cryptographyClient;
}
}
}

37
ModernKeePass.Application/Services/FileService.cs
View File

@@ -1,37 +0,0 @@
using System.Collections.Generic;
using System.Threading.Tasks;
using ModernKeePass.Application.Common.Interfaces;
using ModernKeePass.Domain.Interfaces;
namespace ModernKeePass.Application.Services
{
public class FileService: IFileService
{
private readonly IFileProxy _fileProxy;
public FileService(IFileProxy fileProxy)
{
_fileProxy = fileProxy;
}
public Task<byte[]> OpenBinaryFile(string path)
{
return _fileProxy.OpenBinaryFile(path);
}
public Task WriteBinaryContentsToFile(string path, byte[] contents)
{
return _fileProxy.WriteBinaryContentsToFile(path, contents);
}
public Task<IList<string>> OpenTextFile(string path)
{
return _fileProxy.OpenTextFile(path);
}
public void ReleaseFile(string path)
{
_fileProxy.ReleaseFile(path);
}
}
}

35
ModernKeePass.Application/Services/ImportService.cs
View File

@@ -1,35 +0,0 @@
using System;
using System.Threading.Tasks;
using ModernKeePass.Application.Common.Interfaces;
using ModernKeePass.Domain.Entities;
using ModernKeePass.Domain.Enums;
using ModernKeePass.Domain.Interfaces;
namespace ModernKeePass.Application.Services
{
public class ImportService: IImportService
{
private readonly Func<ImportFormat, IImportFormat> _importFormatProviders;
public ImportService(Func<ImportFormat, IImportFormat> importFormatProviders)
{
_importFormatProviders = importFormatProviders;
}
public async Task Import(ImportFormat format, string filePath, Group group)
{
var importProvider = _importFormatProviders(format);
var data = await importProvider.Import(filePath);
/*foreach (var entity in data)
{
var entry = group.AddNewEntry();
entry.Name = entity["0"];
entry.UserName = entity["1"];
entry.Password = entity["2"];
if (entity.Count > 3) entry.Url = entity["3"];
if (entity.Count > 4) entry.Notes = entity["4"];
}*/
}
}
}

40
ModernKeePass.Application/Services/RecentService.cs
View File

@@ -1,40 +0,0 @@
using System.Collections.Generic;
using System.Threading.Tasks;
using ModernKeePass.Application.Common.Interfaces;
using ModernKeePass.Domain.Dtos;
using ModernKeePass.Domain.Interfaces;
namespace ModernKeePass.Application.Services
{
public class RecentService: IRecentService
{
private readonly IRecentProxy _recentProxy;
public RecentService(IRecentProxy recentProxy)
{
_recentProxy = recentProxy;
}
public bool HasEntries => _recentProxy.EntryCount > 0;
public async Task<FileInfo> Get(string token)
{
return await _recentProxy.Get(token);
}
public async Task<IEnumerable<FileInfo>> GetAll()
{
return await _recentProxy.GetAll();
}
public async Task Add(FileInfo recentItem)
{
await _recentProxy.Add(recentItem);
}
public void ClearAll()
{
_recentProxy.ClearAll();
}
}
}

35
ModernKeePass.Application/Services/SecurityService.cs
View File

@@ -1,35 +0,0 @@
using System.Threading.Tasks;
using ModernKeePass.Application.Common.Interfaces;
using ModernKeePass.Domain.Dtos;
using ModernKeePass.Domain.Interfaces;
namespace ModernKeePass.Application.Services
{
public class SecurityService: ISecurityService
{
private readonly IPasswordProxy _passwordProxy;
private readonly IFileService _fileService;
public SecurityService(IPasswordProxy passwordProxy, IFileService fileService)
{
_passwordProxy = passwordProxy;
_fileService = fileService;
}
public string GeneratePassword(PasswordGenerationOptions options)
{
return _passwordProxy.GeneratePassword(options);
}
public uint EstimatePasswordComplexity(string password)
{
return _passwordProxy.EstimatePasswordComplexity(password);
}
public async Task GenerateKeyFile(string filePath)
{
var fileContents = _passwordProxy.GenerateKeyFile(null);
await _fileService.WriteBinaryContentsToFile(filePath, fileContents);
}
}
}

25
ModernKeePass.Application/Services/SettingsService.cs
View File

@@ -1,25 +0,0 @@
using ModernKeePass.Application.Common.Interfaces;
using ModernKeePass.Domain.Interfaces;
namespace ModernKeePass.Application.Services
{
public class SettingsService: ISettingsService
{
private readonly ISettingsProxy _settingsProxy;
public SettingsService(ISettingsProxy settingsProxy)
{
_settingsProxy = settingsProxy;
}
public T GetSetting<T>(string property, T defaultValue = default)
{
return _settingsProxy.GetSetting<T>(property, defaultValue);
}
public void PutSetting<T>(string property, T value)
{
_settingsProxy.PutSetting<T>(property, value);
}
}
}

25
ModernKeePass.Application/Settings/Commands/PutSettingCommand.cs Normal file
View File

@@ -0,0 +1,25 @@
using MediatR;
using ModernKeePass.Application.Common.Interfaces;
namespace ModernKeePass.Application.Settings.Commands
{
public class PutSettingCommand<T> : IRequest
{
public string Key { get; set; }
public T value { get; set; }
public class PutSettingCommandHandler : IRequestHandler<PutSettingCommand<T>>
{
private readonly ISettingsProxy _settingsProxy;
public PutSettingCommandHandler(ISettingsProxy settingsProxy)
{
_settingsProxy = settingsProxy;
}
public void Handle(PutSettingCommand<T> message)
{
_settingsProxy.PutSetting(message.Key, message.value);
}
}
}
}

24
ModernKeePass.Application/Settings/Queries/GetSettingQuery.cs Normal file
View File

@@ -0,0 +1,24 @@
using MediatR;
using ModernKeePass.Application.Common.Interfaces;
namespace ModernKeePass.Application.Settings.Queries
{
public class GetSettingQuery<T> : IRequest<T>
{
public string Key { get; set; }
public class GetSettingQueryHandler : IRequestHandler<GetSettingQuery<T>, T>
{
private readonly ISettingsProxy _settingsProxy;
public GetSettingQueryHandler(ISettingsProxy settingsProxy)
{
_settingsProxy = settingsProxy;
}
public T Handle(GetSettingQuery<T> message)
{
return _settingsProxy.GetSetting<T>(message.Key);
}
}
}
}