private async Task SynchronizeAsync(
Synchronization synchronization,
NoteMeContext context,
CancellationToken cts)
{
await _dispatcher.DispatchAsync(synchronization, context, cts);
}
public CleanService(
ApiWebSettings apiWebSettings,
NoteMeContext context)
{
_apiWebSettings = apiWebSettings;
_context = context;
}
public CdnService(
CdnSettings settings,
NoteMeContext context)
{
_settings = settings;
_context = context;
}
public AttachmentQueryHandler(
INoteMeMapper mapper,
NoteMeContext context)
{
_mapper = mapper;
_context = context;
}
public NoteQueryHandler(
INoteMeMapper mapper,
NoteMeContext context)
{
_mapper = mapper;
_context = context;
}
private async Task SendNotesToApi <TCommand>(Func <TCommand, Task <NoteDto> > sendAsync,
Expression <Func <Note, bool> > predicate,
NoteMeContext context,
CancellationToken cts)
where TCommand : IIdProvider
{
cts.ThrowIfCancellationRequested();
var toInserts = await context.Notes
.AsTracking()
.Where(predicate)
.ToListAsync(cts);
var insertsCommands = _mapper.MapTo <ICollection <TCommand> >(toInserts);
foreach (var command in insertsCommands)
{
var created = await sendAsync.Invoke(command);
var entity = toInserts.First(x => x.Id == command.Id);
entity.LastSynchronization = DateTime.UtcNow;
entity.CreatedAt = created.CreatedAt;
entity.Status = created.Status;
entity.StatusSynchronization = SynchronizationStatusEnum.Ok;
}
await context.SaveChangesAsync(cts);
}
private async Task UpdateAllNotesAsync(NoteMeContext context, CancellationToken cts)
{
await SendNotesToApi <UpdateNoteCommand>(
(cmd) => _webService.SendAsync <NoteDto>(HttpMethod.Put, Endpoints.Notes._ + cmd.Id, cmd),
note => note.StatusSynchronization == SynchronizationStatusEnum.NeedUpdate,
context,
cts);
}
public GenericCommandHandler(
ICacheService cacheService,
INoteMeMapper mapper,
NoteMeContext context)
{
_cacheService = cacheService;
_mapper = mapper;
_context = context;
}
public AuthCommandHandler(
ISecurityService securityService,
ICacheService cacheService,
INoteMeMapper mapper,
NoteMeContext context)
{
_securityService = securityService;
_cacheService = cacheService;
_mapper = mapper;
_context = context;
}
public UserCommandHandler(
ICacheService memoryCacheService,
ISecurityService encrypterService,
INoteMeMapper mapper,
NoteMeContext context)
{
_memoryCacheService = memoryCacheService;
_encrypterService = encrypterService;
_mapper = mapper;
_context = context;
}
public NoteCommandHandler(
IGenericCommandHandler genericCommandHandler,
ICacheService cacheService,
INoteMeMapper mapper,
NoteMeContext noteMeContext)
{
_genericCommandHandler = genericCommandHandler;
_cacheService = cacheService;
_mapper = mapper;
_noteMeContext = noteMeContext;
}
public async Task HandleAsync(
Domain.Synchronization.Synchronization synchronization,
NoteMeContext context,
CancellationToken cts)
{
await FetchAllAttachmentsAsync(synchronization, context, cts);
await DownloadAllAttachmentsAsync(context, cts);
await CreateAllAttachmentsAsync(synchronization, context, cts);
await UploadAllAttachmentsAsync(context, cts);
}
public Task DispatchAsync(Synchronization synchronization, NoteMeContext context, CancellationToken ctx)
{
ctx.ThrowIfCancellationRequested();
var type = Type.GetType(synchronization.Type);
var handlerType = typeof(ISynchronizationHandler <>).MakeGenericType(type);
var handler = _container.Resolve(handlerType);
if (handlerType == null)
{
throw new NoteMeNotRegisteredComponentException(handlerType);
}
var method = handlerType.GetMethod(nameof(ISynchronizationHandler <ISynchronizationProvider> .HandleAsync));
return(method.Invoke(handler, new object [] { synchronization, context, ctx }) as Task);
}
private async Task DownloadAllAttachmentsAsync(NoteMeContext context, CancellationToken cts)
{
cts.ThrowIfCancellationRequested();
var attachmentsWithoutPath = await context.Attachments
.AsTracking()
.ToListAsync(cts);
foreach (var attachment in attachmentsWithoutPath.Where(x => string.IsNullOrEmpty(x.Path) || !File.Exists(x.Path)))
{
cts.ThrowIfCancellationRequested();
var fullFilePath = Path.Combine(_filePathService.GetFilesDirectory(), attachment.Name);
await _apiWebService.DownloadAsync(Endpoints.Attachments.Download + attachment.Id, fullFilePath);
attachment.Path = fullFilePath;
await context.SaveChangesAsync(cts);
}
}
private async Task UploadAllAttachmentsAsync(
NoteMeContext context,
CancellationToken cts)
{
cts.ThrowIfCancellationRequested();
var attachmentsToUpload = await context.Attachments
.Where(x => x.StatusSynchronization == SynchronizationStatusEnum.NeedUpload)
.AsTracking()
.ToListAsync(cts);
foreach (var attachment in attachmentsToUpload)
{
await _apiWebService.UploadAsync(Endpoints.Attachments.Upload, attachment.Path, attachment.Id);
attachment.StatusSynchronization = SynchronizationStatusEnum.Ok;
await context.SaveChangesAsync(cts);
cts.ThrowIfCancellationRequested();
}
}
private async Task CreateAllAttachmentsAsync(Domain.Synchronization.Synchronization synchronization, NoteMeContext context, CancellationToken cts)
{
cts.ThrowIfCancellationRequested();
var toInserts = await context.Attachments
.AsTracking()
.Where(x => x.StatusSynchronization == SynchronizationStatusEnum.NeedInsert)
.ToListAsync(cts);
var insertsCommands = _mapper.MapTo <ICollection <CreateAttachmentCommand> >(toInserts);
foreach (var command in insertsCommands)
{
var created = await _apiWebService.SendAsync <AttachmentDto>(HttpMethod.Post, Endpoints.Attachments._, command);
var entity = toInserts.First(x => x.Id == command.Id);
entity.LastSynchronization = DateTime.UtcNow;
entity.CreatedAt = created.CreatedAt;
entity.StatusSynchronization = SynchronizationStatusEnum.NeedUpload;
}
await context.SaveChangesAsync(cts);
}
private async Task FetchAllAttachmentsAsync(Domain.Synchronization.Synchronization synchronization, NoteMeContext context,
CancellationToken cts)
{
cts.ThrowIfCancellationRequested();
var syncDate = synchronization.LastSynchronization;
var hasMore = false;
do
{
var filterBy = $@"{nameof(Attachment.CreatedAt)} > ""{syncDate}""";
var orderBy = $"{nameof(Attachment.CreatedAt)}-desc";
var query = new GetAttachmentQuery()
.SetNormalWhere(filterBy)
.SetNormalOrderBy(orderBy);
var items = await _apiWebService.SendAsync <PaginationDto <AttachmentDto> >(HttpMethod.Get,
Endpoints.Attachments._ + query.ToUri());
if (!items.Data.Any())
{
return;
}
hasMore = items.Data.Count == query.PageSize;
foreach (var itemDto in items.Data)
{
var item = await context.Attachments.FirstOrDefaultAsync(x => x.Id == itemDto.Id, cts);
if (item != null)
{
continue;
}
item = _mapper.MapTo <Attachment>(itemDto);
item.StatusSynchronization = SynchronizationStatusEnum.Ok;
await context.AddRangeAsync(item);
}
} while (hasMore);
await context.SaveChangesAsync(cts);
}
public async Task HandleAsync(Domain.Synchronization.Synchronization synchronization, NoteMeContext context, CancellationToken cts)
{
await UpdateAllNotesAsync(context, cts);
await FetchAllResultsAsync(synchronization, context, cts);
await SendAllNotesAsync(context, cts);
}
public DataSeeder(IDataSeeder <User> userSeeder,
NoteMeContext noteMeContext)
{
_userSeeder = userSeeder;
_noteMeContext = noteMeContext;
}
private async Task FetchAllResultsAsync(Domain.Synchronization.Synchronization synchronization, NoteMeContext context, CancellationToken cts)
{
cts.ThrowIfCancellationRequested();
var syncDate = synchronization.LastSynchronization;
var hasMore = false;
var allNotes = new List <Note>();
do
{
var filterBy = $@"{nameof(Note.CreatedAt)} > ""{syncDate}""";
var orderBy = $"{nameof(Note.CreatedAt)}-desc";
var query = new GetNotesQuery()
.SetNormalWhere(filterBy)
.SetNormalOrderBy(orderBy);
var notes = await _webService.SendAsync <PaginationDto <NoteDto> >(HttpMethod.Get,
Endpoints.Notes._ + query.ToUri());
if (!notes.Data.Any() && !allNotes.Any())
{
return;
}
hasMore = notes.Data.Count == query.PageSize;
foreach (var noteDto in notes.Data)
{
var note = await context.Notes.FirstOrDefaultAsync(x => x.Id == noteDto.Id, cts);
if (note != null)
{
note.Content = noteDto.Content;
note.Tags = noteDto.Tags;
note.Name = noteDto.Name;
}
else
{
note = _mapper.MapTo <Note>(noteDto);
if (note.Status == StatusEnum.Normal)
{
allNotes.Add(note);
}
await context.AddRangeAsync(note);
}
}
} while (hasMore);
await context.SaveChangesAsync(cts);
NPublisher.PublishIt(new NewNotesMessage(allNotes));
}
public CommandDispatcher(NoteMeContext context,
IComponentContext container)
{
_context = context;
_container = container;
}
