public async Task Should_write_asset_urls() { var me = new RefToken(RefTokenType.Subject, "123"); var assetsUrl = "https://old.squidex.com/api/assets/"; var assetsUrlApp = "https://old.squidex.com/api/assets/my-app"; A.CallTo(() => urlGenerator.AssetContentBase()) .Returns(assetsUrl); A.CallTo(() => urlGenerator.AssetContentBase(appId.Name)) .Returns(assetsUrlApp); var writer = A.Fake <IBackupWriter>(); var context = new BackupContext(appId.Id, new UserMapping(me), writer); await sut.BackupEventAsync(Envelope.Create(new AppCreated { Name = appId.Name }), context); A.CallTo(() => writer.WriteJsonAsync(A <string> ._, A <BackupContents.Urls> .That.Matches(x => x.Assets == assetsUrl && x.AssetsApp == assetsUrlApp))) .MustHaveHappened(); }
public async Task BackupAsync(BackupContext context, CancellationToken ct) { var json = await appUISettings.GetAsync(context.AppId, null); await context.Writer.WriteJsonAsync(SettingsFile, json, ct); }
public void Store_Directory() { var fileSystem = new MockFileSystem(); fileSystem.RegisterDirectory(@"C:\dir"); var dateTime = new MockDateTime(new DateTime(2010, 10, 1, 0, 0, 0)); var serviceContainer = new ManualServiceContainer(); serviceContainer.Register <IFileSystem>(fileSystem); serviceContainer.Register <IDateTimeService>(dateTime); var executionContext = new ExecutionContext(serviceContainer); var directory = new DirectoryObject(@"C:\dir", fileSystem); var storage = new DirectoryStorage(@"C:\backup"); var storageInstance = storage.CreateInstance(executionContext); var backupContext = new BackupContext(null, executionContext); var result = storageInstance.Store(directory, backupContext).ToArray(); var expected = new IOperation[] { new CreateDirectoryOperation(new DirectoryObject(@"C:\backup\2010-10-01 00-00-00\C\dir", fileSystem), fileSystem, executionContext) }; CollectionAssert.AreEqual(expected, result); }
public void GetObjects() { var fileSystem = new MockFileSystem(); fileSystem.RegisterDirectory(@"C:\dir"); fileSystem.RegisterDirectory(@"C:\dir\dir1"); fileSystem.RegisterFile(@"C:\dir\file1"); fileSystem.RegisterFile(@"C:\file2"); var serviceContainer = new ManualServiceContainer(); serviceContainer.Register <IFileSystem>(fileSystem); var executionContext = new ExecutionContext(serviceContainer); var roots = new IFileSystemRoot[] { new DirectoryRoot(@"C:\dir", fileSystem), new FileRoot(@"C:\file2", fileSystem) }; var source = new FileSystemSource(roots); var sourceInstance = source.CreateInstance(executionContext); var backupContext = new BackupContext(null, executionContext); var result = sourceInstance.GetObjects(backupContext).ToArray(); var expected = new IObject[] { new DirectoryObject(@"C:\dir", fileSystem), new FileObject(@"C:\dir\file1", fileSystem), new DirectoryObject(@"C:\dir\dir1", fileSystem), new FileObject(@"C:\file2", fileSystem) }; CollectionAssert.AreEqual(expected, result); }
/// <summary> /// Add entity to the repository /// </summary> /// <param name="entity">the entity to add</param> public void Add(ClientInfo entity) { BackupContext.ClientInfos.Add(entity); var scheduledBackups = GetScheduledBackupsForNewlyRegisteredClient(entity); BackupContext.ScheduledBackups.AddRange(scheduledBackups); BackupContext.SaveChanges(); }
public static DisposeWrapper <BackupContext> Create() { var tmpFile = new TempFile(); var ctx = BackupContext.FromFile(tmpFile.Filename); ctx.Database.EnsureCreated(); return(new DisposeWrapper <BackupContext>(ctx, _ => tmpFile.Dispose())); }
public async Task BackupEventAsync(Envelope <IEvent> @event, BackupContext context) { if (@event.Payload is AppCreated appCreated) { var urls = GetUrls(appCreated.Name); await context.Writer.WriteJsonAsync(UrlsFile, urls); } }
public Task BackupEventAsync(Envelope <IEvent> @event, BackupContext context) { switch (@event.Payload) { case AssetCreated assetCreated: return(WriteAssetAsync(assetCreated.AssetId, assetCreated.FileVersion, context.Writer)); case AssetUpdated assetUpdated: return(WriteAssetAsync(assetUpdated.AssetId, assetUpdated.FileVersion, context.Writer)); } return(Task.CompletedTask); }
public async Task BackupEventAsync(Envelope <IEvent> @event, BackupContext context) { switch (@event.Payload) { case AppContributorAssigned appContributorAssigned: context.UserMapping.Backup(appContributorAssigned.ContributorId); break; case AppImageUploaded _: await WriteAssetAsync(context.AppId, context.Writer); break; } }
private async Task BackupTagsAsync(BackupContext context, CancellationToken ct) { var tags = await tagService.GetExportableTagsAsync(context.AppId, TagGroups.Assets); if (tags.Tags != null) { await context.Writer.WriteJsonAsync(TagsFile, tags.Tags, ct); } if (tags.Alias?.Count > 0) { await context.Writer.WriteJsonAsync(TagsAliasFile, tags.Alias, ct); } }
public void Store_Drive() { var fileSystem = new MockFileSystem(); fileSystem.RegisterDrive(@"C:"); var dateTime = new MockDateTime(new DateTime(2010, 10, 1, 0, 0, 0)); var serviceContainer = new ManualServiceContainer(); serviceContainer.Register <IFileSystem>(fileSystem); serviceContainer.Register <IDateTimeService>(dateTime); var executionContext = new ExecutionContext(serviceContainer); var drive = new DriveObject(@"C:", fileSystem); var storage = new DirectoryStorage(@"C:\backup"); var storageInstance = storage.CreateInstance(executionContext); var backupContext = new BackupContext(null, executionContext); var result = storageInstance.Store(drive, backupContext).ToArray(); }
private async Task BackupTagsAsync(BackupContext context) { var tags = await tagService.GetExportableTagsAsync(context.AppId, TagGroups.Assets); await context.Writer.WriteJsonAsync(TagsFile, tags); }
/// <summary> /// Mark entity to be deleted within the repository /// </summary> /// <param name="entity">The entity to delete</param> public void Delete(ClientInfo entity) { BackupContext.ClientInfos.Remove(entity); BackupContext.SaveChanges(); }
public static DisposeWrapper <BackupContext> Create(IEnumerable <string> entries) { var tmpFile = new TempFile(); var ctx = BackupContext.FromFile(tmpFile.Filename); ctx.Database.EnsureCreated(); var resErrors = entries.Select(Fs.ReadEntry).ToList(); var res = resErrors.Where(x => x.Stat) .Select(x => (x.Path, x.Name, Stat: x.Stat.Value)).ToList(); var dirs = res.Where(x => x.Stat.IsDir()).ToList(); var files = res.Where(x => x.Stat.IsFile()).ToList(); var symlinks = res.Where(x => x.Stat.IsSymlink()).ToList(); var dms = dirs.Select(d => { var(path, name, stat) = d; var dm = new DirectoryModel { Attributes = new AttributesModel(), Name = name, Path = path }; dm.Attributes.SetStat(stat); ctx.Directories.Add(dm); return(dm); }).ToList(); foreach (var(path, name, stat) in files) { var parent = dms.FirstOrDefault(d => d.Path == Paths.Directory(path)); if (parent == null) { throw new FsException(path, "No parent directory found in context.", Errno.ENOENT); } var fm = new FileModel { Attributes = new AttributesModel(), Directory = parent, Filename = name }; fm.Attributes.SetStat(stat); ctx.Files.Add(fm); } foreach (var(path, name, stat) in symlinks) { var parent = dms.FirstOrDefault(d => d.Path == Paths.Directory(path)); if (parent == null) { throw new FsException(path, "No parent directory found in context."); } var sm = new SymlinkModel { Attributes = new AttributesModel(), Directory = parent, Filename = name }; sm.Attributes.SetStat(stat); ctx.Symlinks.Add(sm); } return(new DisposeWrapper <BackupContext>(ctx, _ => tmpFile.Dispose())); }
public async Task BackupAsync(BackupContext context) { var json = await appUISettings.GetAsync(context.AppId, null); await context.Writer.WriteJsonAsync(SettingsFile, json); }
public BackupRepository(BackupContext context) { _context = context; }
/// <summary> /// Mark entity to be deleted within the repository /// </summary> /// <param name="entity">The entity to delete</param> public void Delete(ScheduledBackup entity) { BackupContext.ScheduledBackups.Remove(entity); BackupContext.SaveChanges(); }
/// <summary> /// Add entity to the repository /// </summary> /// <param name="entity">the entity to add</param> public void Add(ScheduledBackup entity) { BackupContext.ScheduledBackups.Add(entity); BackupContext.SaveChanges(); }
/// <summary> /// Initializes a new instance of the <see cref="ScheduledBackupRepository"/> class. /// </summary> /// <param name="backupContext">The backup context.</param> internal ScheduledBackupRepository(BackupContext backupContext) : base(backupContext) { }
/// <summary> /// Updates entity within the the repository /// </summary> /// <param name="entity">the entity to update</param> public void Update(ScheduledBackup entity) { BackupContext.Entry(entity).State = EntityState.Modified; BackupContext.SaveChanges(); }
/// <summary> /// Updates entity within the the repository /// </summary> /// <param name="entity">the entity to update</param> public void Update(ActivityInfo entity) { BackupContext.Entry(entity).State = EntityState.Modified; BackupContext.SaveChanges(); }
/// <summary> /// Initializes a new instance of the <see cref="ActivityInfoRepository"/> class. /// </summary> /// <param name="backupContext">The backup context.</param> internal ActivityInfoRepository(BackupContext backupContext) : base(backupContext) { }
public Task BackupAsync(BackupContext context) { return(BackupTagsAsync(context)); }
/// <summary> /// Add entity to the repository /// </summary> /// <param name="entity">the entity to add</param> public void Add(ActivityInfo entity) { BackupContext.ActivityInfos.Add(entity); BackupContext.SaveChanges(); }
/// <summary> /// Mark entity to be deleted within the repository /// </summary> /// <param name="entity">The entity to delete</param> public void Delete(ActivityInfo entity) { BackupContext.ActivityInfos.Remove(entity); BackupContext.SaveChanges(); }
protected BaseEntityFrameworkRepository(BackupContext backupContext) { BackupContext = backupContext; }
public Task BackupAsync(BackupContext context, CancellationToken ct) { return(BackupTagsAsync(context, ct)); }
/// <summary> /// Initializes a new instance of the <see cref="ClientInfoRepository"/> class. /// </summary> /// <param name="backupContext">The backup context.</param> internal ClientInfoRepository(BackupContext backupContext) : base(backupContext) { }