/// <summary>
/// Creates instance of <see cref="IFileFsClient"/>.
/// </summary>
/// <param name="fileFsStoragePath">Path to FileFS storage file.</param>
/// <param name="options">Options for FileFS client.</param>
/// <param name="logger">Logger instance.</param>
/// <returns>Instance of <see cref="IFileFsClient"/>.</returns>
public static IFileFsClient Create(string fileFsStoragePath, FileFsClientOptions options, ILogger logger)
{
ITransactionWrapper CreateTransactionWrapper(bool enableTransactions) =>
enableTransactions
? (ITransactionWrapper) new TransactionWrapper(fileFsStoragePath, logger)
: (ITransactionWrapper) new NullTransactionWrapper();
FileFsClientOptionsValidator.Validate(options);
var storageStreamProvider = new StorageStreamProvider(fileFsStoragePath, logger);
var connection = new StorageConnection(storageStreamProvider, options.ByteBufferSize, logger);
var filesystemDescriptorSerializer = new FilesystemDescriptorSerializer(logger);
var filesystemDescriptorAccessor = new FilesystemDescriptorAccessor(connection, filesystemDescriptorSerializer, logger);
var entryDescriptorSerializer = new EntryDescriptorSerializer(filesystemDescriptorAccessor, logger);
var entryDescriptorRepository = new EntryDescriptorRepository(connection, filesystemDescriptorAccessor, entryDescriptorSerializer, logger);
var operationLocker = new StorageOperationLocker();
var optimizer = new StorageOptimizer(connection, entryDescriptorRepository, filesystemDescriptorAccessor, operationLocker, logger);
var extender = new StorageExtender(connection, filesystemDescriptorAccessor, operationLocker, logger);
var allocator = new FileAllocator(connection, filesystemDescriptorAccessor, entryDescriptorRepository, optimizer, extender, operationLocker, logger);
var entryRepository = new EntryRepository(filesystemDescriptorAccessor, entryDescriptorRepository, logger);
var fileRepository = new FileRepository(connection, allocator, filesystemDescriptorAccessor, entryDescriptorRepository, logger);
var directoryRepository = new DirectoryRepository(filesystemDescriptorAccessor, entryDescriptorRepository, logger);
var externalFileManager = new ExternalFileManager(logger);
var transactionWrapper = CreateTransactionWrapper(options.EnableTransactions);
var client = new FileFsClient(fileRepository, directoryRepository, entryRepository, externalFileManager, optimizer, transactionWrapper, operationLocker);
return(client);
}
public async void RemoveDirectory(WallpaperDirectory directory)
{
ContentDialog removeDialog = new ContentDialog
{
Title = "Remove Directory?",
Content = "Are you sure you want to remove this directory from the theme?",
PrimaryButtonText = "Remove",
CloseButtonText = "Cancel"
};
ContentDialogResult result = await removeDialog.ShowAsync();
if (result == ContentDialogResult.Primary)
{
// Remove from the Lists
if (directory.IsExcluded)
{
ExcludedWallpaperDirectories.Remove(directory);
}
else
{
WallpaperDirectories.Remove(directory);
}
// Delete the Directory
DirectoryRepository.RemoveAndCommit(directory.ID);
// Update the Cache
Progress <IndicatorProgressReport> progress = new Progress <IndicatorProgressReport>();
progress.ProgressChanged += Progress_ProgressChanged;
RefreshFileCache(progress);
}
}
static void Main(string[] args)
{
var directorySearch = new DirectoryRepository();
var modifyDirectoryName = new ModifyDirectoryName();
List <DirectoryInfo> movieList = new List <DirectoryInfo>();
try
{
movieList = GetMovieList(directorySearch);
foreach (var movie in movieList)
{
var rating = GetMovieInfo(movie.Name);
if (rating != null)
{
UpdateMovieDirectoryNameWithRating(movie, rating, modifyDirectoryName);
}
}
Console.ReadLine();
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
Console.ReadLine();
}
}
public MainWindowViewModel()
{
Content = new HomeMenuViewModel();
CategoryRepository.Initialize();
TagRepository.Initialize();
DirectoryRepository.Initialize();
FileSystemConnector.EnsureCreated();
}
public void IndexService()
{
var data = new DirectoryRepository().GetDirectories();
Assert.IsNotNull(data);
Assert.IsTrue(data.Count() > 0);
Assert.IsTrue(data.ToList().First().Name == "$root");
}
public async Task Test_DirectoryRepository_Fetch_Package_Not_Found()
{
var localRepoFeedConfig = new Settings.Feed
{
Name = "local.choco",
};
localRepoFeedConfig.Settings.Add("Uri", LocalRepoFolder);
var sourceRepo = new DirectoryRepository(localRepoFeedConfig, LoggerFactory);
Assert.Null(await sourceRepo.FetchAsync("PackageJunkName", "1.0.0"));
}
public async Task Test_DirectoryRepository_Uri_Doesnt_Exist()
{
var localRepoFeedConfig = new Settings.Feed
{
Name = "local.choco.notfound",
};
localRepoFeedConfig.Settings.Add("Uri", LocalRepoFolder + "-not-found");
var sourceRepo = new DirectoryRepository(localRepoFeedConfig, LoggerFactory);
var packages = await sourceRepo.ListAsync(NotepadPlusPlusPackageId, false, true).ToListAsync();
Assert.Empty(packages);
}
private static List <DirectoryInfo> GetMovieList(DirectoryRepository directorySearch)
{
var movies = directorySearch.GetDirectoryList();
if (movies == null || movies.Count == 0)
{
Console.WriteLine("No movie exist at the specified path.");
}
else
{
Console.WriteLine("Movie list retrieved.");
}
return(movies);
}
public async Task Test_ProgetRepository_Copy_And_Delete_Packages()
{
var localRepoFeedConfig = new Settings.Feed
{
Name = "local.choco",
};
localRepoFeedConfig.Settings.Add("Uri", LocalRepoFolder);
var targetRepoFeedConfig = new Settings.Feed
{
Name = "nuget.test",
};
targetRepoFeedConfig.Settings.Add("Uri", RepoUrl);
targetRepoFeedConfig.Settings.Add("ApiKey", ApiKey);
var sourceRepo = new DirectoryRepository(localRepoFeedConfig, LoggerFactory);
var targetRepo = new ProgetRepository(targetRepoFeedConfig, LoggerFactory);
var sourcePackages = await sourceRepo.ListAsync(NotepadPlusPlusPackageId, false, true).ToListAsync();
foreach (var package in sourcePackages)
{
var p = await sourceRepo.FetchAsync(package.Id, package.Version);
Assert.NotNull(p.Content);
await targetRepo.AddAsync(p);
}
var targetPackages = await targetRepo.ListAsync(NotepadPlusPlusPackageId, false, true).ToListAsync();
Assert.Equal(NotepadPlusPlusPackageCount, sourcePackages.Count);
Assert.Equal(NotepadPlusPlusPackageCount, targetPackages.Count);
foreach (var targetPackage in targetPackages)
{
var targetPackageWithContent = await targetRepo.FetchAsync(targetPackage.Id, targetPackage.Version);
Assert.NotNull(targetPackageWithContent.Content);
await targetRepo.DeleteAsync(targetPackage.Id, targetPackage.Version);
}
targetPackages = await targetRepo.ListAsync(NotepadPlusPlusPackageId, false, true).ToListAsync();
Assert.Empty(targetPackages);
}
public void OneTimeSetup()
{
var configuration = new ContainerConfiguration(typeof(CassandraFileSystem).Assembly);
var container = new Container(configuration);
var settings = new FileLogSettings();
var logger = new CompositeLog(new ConsoleLog(), new FileLog(settings));
container.Configurator.ForAbstraction <ILog>().UseInstances(logger);
container.Configurator.ForAbstraction <Config>().UseInstances(Config);
CassandraConfigurator.ConfigureCassandra(container, logger);
directoryRepository = container.Get <DirectoryRepository>();
fileRepository = container.Get <FileRepository>();
var session = container.Get <ISession>();
directoriesTableEvent = new Table <CQLDirectory>(session);
filesTableEvent = new Table <CQLFile>(session);
}
public async Task Test_DirectoryRepository_List()
{
var localRepoFeedConfig = new Settings.Feed
{
Name = "local.choco",
};
localRepoFeedConfig.Settings.Add("Uri", LocalRepoFolder);
var sourceRepo = new DirectoryRepository(localRepoFeedConfig, LoggerFactory);
var packages = await sourceRepo.ListAsync(NotepadPlusPlusPackageId, false, true).ToListAsync();
var packagesPrerelease = (await sourceRepo.ListAsync(NotepadPlusPlusPackageId, true, true).ToListAsync()).Where(p => p.IsPrerelease).ToList();
var packagesIncludingPrerelease = await sourceRepo.ListAsync(NotepadPlusPlusPackageId, true, true).ToListAsync();
Assert.Equal(NotepadPlusPlusPackageCount, packages.Count);
Assert.Single(packagesPrerelease);
Assert.Equal(NotepadPlusPlusPackageCount + NotepadPlusPlusPrereleasePackageCount, packagesIncludingPrerelease.Count);
}
public DomainContext()
{
IsLoading = false;
IsWaiting = false;
waitFormSupported = new[]
{
AsyncOperationType.LoadCatalog,
AsyncOperationType.LoadBrands,
AsyncOperationType.LoadDirectories,
AsyncOperationType.CheckDatabase,
AsyncOperationType.GetSumBasket
};
Messenger = new Messenger();
ColorService = new ColorService();
ImageService = new ImageService();
PhotoService = new PhotoService(Messenger, ImageService);
PrecisionService = new PrecisionService(2, true);
DataService = new DataService();
UserDecisionsService = new UserDecisionsService();
AsyncOperationService = new AsyncOperationService(UserDecisionsService, UIContext.Current);
OptionService = new OptionService();
WebService = new WebService(OptionService);
TemplateService = new TemplateService(OptionService);
ConvertService = new ConvertService();
BrandRepository = new BrandRepository(DataService);
BrandRepository.Load();
DirectoryRepository = new DirectoryRepository(DataService);
DirectoryRepository.Load();
Init();
SubscribeEvents();
pingTimer = new DispatcherTimer();
pingTimer.Interval = TimeSpan.FromMilliseconds(1000);
pingTimer.Tick += PingTimerOnTick;
pingTimer.Start();
}
public FileSystemRepository(FileRepository fileRepository, DirectoryRepository directoryRepository)
{
this.directoryRepository = directoryRepository;
this.fileRepository = fileRepository;
}
public DirectoryController()
{
DirectoryRepository directoryRepository = new DirectoryRepository();
_directoryRepository = directoryRepository;
}
public DirectoryViewComponent(DirectoryRepository _dr, IMapper _mapper, DocumentRepository _doc)
{
dr = _dr;
mapper = _mapper;
doc = _doc;
}
public DirectoryHelper(string currentPath)
{
directories = new DirectoryRepository(currentPath);
}
public DirectoryController(DirectoryRepository _dr, IMapper _mapper, DocumentRepository _doc)
{
dr = _dr;
mapper = _mapper;
doc = _doc;
}
public HomeController(ILogger <HomeController> logger, DirectoryRepository dir, DocumentRepository doc)
{
_logger = logger;
this._dir = dir;
_doc = doc;
}
