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