public MockFileSystem(IDictionary <string, MockFileData> files, string currentDirectory = "")
{
if (string.IsNullOrEmpty(currentDirectory))
{
currentDirectory = IO.Path.GetTempPath();
}
pathVerifier = new PathVerifier(this);
this.files = new Dictionary <string, MockFileData>(StringComparer.OrdinalIgnoreCase);
pathField = new MockPath(this);
file = new MockFile(this);
directory = new MockDirectory(this, file, currentDirectory);
fileInfoFactory = new MockFileInfoFactory(this);
directoryInfoFactory = new MockDirectoryInfoFactory(this);
driveInfoFactory = new MockDriveInfoFactory(this);
if (files != null)
{
foreach (var entry in files)
{
AddFile(entry.Key, entry.Value);
}
}
}
public VirtualFileSystem(IDictionary <string, VirtualFileData> files, string currentDirectory = "")
{
if (string.IsNullOrEmpty(currentDirectory))
{
currentDirectory = System.IO.Path.GetTempPath();
}
_pathVerifier = new PathVerifier(this);
this._files = new Dictionary <string, VirtualFileData>(StringComparer.OrdinalIgnoreCase);
_pathField = new VirtualPath(this);
_file = new VirtualFile(this);
_directory = new VirtualDirectory(this, _file, currentDirectory);
_fileInfoFactory = new VirtualFileInfoFactory(this);
_directoryInfoFactory = new VirtualDirectoryInfoFactory(this);
_driveInfoFactory = new VirtualDriveInfoFactory(this);
if (files != null)
{
foreach (var entry in files)
{
AddFile(entry.Key, entry.Value);
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="DirectoryCreator"/> class
/// </summary>
public DirectoryCreator(
IDirectoryInfoFactory directoryInfoFactory)
{
Argument.NotNull(directoryInfoFactory, nameof(directoryInfoFactory));
_directoryInfoFactory = directoryInfoFactory;
}
public DirectoryInfoAdapter(IDirectoryInfoFactory directoryInfoFactory
, IFileInfoFactory fileInfoFactory
, DirectoryInfo directoryInfo)
{
this.DirectoryInfoFactory = directoryInfoFactory;
this.FileInfoFactory = fileInfoFactory;
this.DirectoryInfo = directoryInfo;
}
public SomeService(IDirectoryInfoFactory directoryInfoFactory)
{
if (directoryInfoFactory == null)
{
throw new ArgumentNullException("directoryInfoFactory");
}
this.directoryInfoFactory = directoryInfoFactory;
}
public static IDirectoryInfo GetFromDirectoryInfo(this IDirectoryInfoFactory directoryInfoFactory, IDirectoryInfo info)
{
if (directoryInfoFactory is not ILinuxDirectoryInfoFactory dir)
{
throw new Exception("IDirectoryInfoFactory is not the linux version");
}
return(dir.FromDirectoryInfo(info));
}
public DirectoryService(IDirectoryInfoFactory directoryInfoFactory
, IPathTransformer pathTransformer
)
{
this.directoryInfoFactory = directoryInfoFactory;
this.pathTransformer = pathTransformer;
this.Self = this;
}
public FileSystem(
IFileInfoFactory fileInfoFactory,
IDirectoryInfoFactory directoryInfoFactory)
{
FileInfo = fileInfoFactory;
DirectoryInfo = directoryInfoFactory;
File = new FileAdapter();
Directory = new DirectoryAdapter();
Path = new PathAdapter();
}
/// <summary>
/// Initializes a new instance of the <see cref="ListCleanFolderFileQueryHandler"/> class
/// </summary>
/// <param name="configuration">Injected cleanup folder configuration</param>
/// <param name="directoryInfoFactory">Injected directory info factory</param>
/// <param name="dateTimeProvider">Injected date time provider</param>
public ListCleanFolderFileQueryHandler(
IOptions <CleanupFolderConfiguration> configuration,
IDirectoryInfoFactory directoryInfoFactory,
IDateTimeProvider dateTimeProvider)
{
_configuration = configuration;
_directoryInfoFactory = directoryInfoFactory;
_dateTimeProvider = dateTimeProvider;
}
/// <summary>
/// Initializes a new instance of the <see cref="EnvironmentDirectoryInfoProvider" /> class.
/// </summary>
/// <param name="environment">The environment.</param>
/// <param name="environmentVariableKey">The environment variable key.</param>
/// <param name="factory">The factory.</param>
/// <param name="directoryFileSystem">The directory file system.</param>
public EnvironmentDirectoryInfoProvider(
IEnvironment environment,
string environmentVariableKey,
IDirectoryInfoFactory factory,
IDirectory directoryFileSystem)
{
_environment = environment;
_environmentVariableKey = environmentVariableKey;
_factory = factory;
_directoryFileSystem = directoryFileSystem;
}
/// <summary>
/// Initializes a new instance of the <see cref="CleanupDownloadFolderCommandHandler"/> class
/// </summary>
/// <param name="directoryInfoFactory">Injected directory info factory</param>
/// <param name="integrationConfiguration">Injected configuration</param>
public CleanupDownloadFolderCommandHandler(
IDirectoryInfoFactory directoryInfoFactory,
IOptions <IntegrationExportConfiguration> integrationConfiguration)
{
Argument.NotNull(integrationConfiguration, nameof(integrationConfiguration));
Argument.NotNull(directoryInfoFactory, nameof(directoryInfoFactory));
_directoryInfoFactory = directoryInfoFactory;
_integrationConfiguration = integrationConfiguration;
}
public MockFileSystem(IDictionary<string, MockFileData> files)
{
this.files = new Dictionary<string, MockFileData>(
files,
StringComparer.InvariantCultureIgnoreCase);
file = new MockFile(this);
directory = new MockDirectory(this, file);
fileInfoFactory = new MockFileInfoFactory(this);
path = new MockPath();
directoryInfoFactory = new MockDirectoryInfoFactory(this);
}
public MockFileSystem(IDictionary <string, MockFileData> files)
{
this.files = new Dictionary <string, MockFileData>(
files,
StringComparer.InvariantCultureIgnoreCase);
file = new MockFile(this);
directory = new MockDirectory(this, file);
fileInfoFactory = new MockFileInfoFactory(this);
path = new MockPath();
directoryInfoFactory = new MockDirectoryInfoFactory(this);
}
public MockFileSystem(IDictionary<string, MockFileData> files, string currentDirectory = @"C:\Foo\Bar")
{
this.files = new Dictionary<string, MockFileData>(StringComparer.OrdinalIgnoreCase);
pathField = new MockPath(this);
file = new MockFile(this);
directory = new MockDirectory(this, file, FixPath(currentDirectory));
fileInfoFactory = new MockFileInfoFactory(this);
directoryInfoFactory = new MockDirectoryInfoFactory(this);
if (files == null) return;
foreach (var entry in files)
AddFile(entry.Key, entry.Value);
}
public NewWorkspaceInvestigationWizardVm(IDirectoryInfoFactory directoryInfoManager, IWindsorContainer applicationWindsorContainer, Workspace model,
InvestigationInfo investigationInfo, IInvestigationFactory investigationFactory, IDetectiveMessenger detectiveMessenger,
CreateWorkspaceCommand createWorkspaceCommand, CreateInvestigationCommand createInvestigationCommand) : this(directoryInfoManager,
applicationWindsorContainer, investigationInfo, investigationFactory, detectiveMessenger, createWorkspaceCommand, createInvestigationCommand)
{
// workaround: in some cases this constructor is executed even though it should not be
if (!string.IsNullOrEmpty(model.Name))
{
this.Workspace = model;
this.InvestigationName = "Initial investigation";
this.WorkspaceName = model.Name;
this.SqlConnectionStringBuilder = new SqlConnectionStringBuilder(model.ConnectionString);
}
}
public ProjectRepository(
IOptionsMonitor <ZealotConfiguration> zealotConfiguration
, IDirectoryInfoFactory directoryInfoFactory
, IFileInfoFactory fileInfoFactory
, IJsonFileConverter <Project> projectJsonDump
, IJsonFileConverter <List <Project> > projectsConfigListFileConverter
, IAnnexFileConverter annexFileConverter)
{
_configuration = zealotConfiguration.CurrentValue;
_directoryInfoFactory = directoryInfoFactory;
_fileInfoFactory = fileInfoFactory;
_projectFileConverter = projectJsonDump;
_projectsConfigListFileConverter = projectsConfigListFileConverter;
_annexFileConverter = annexFileConverter;
}
public MockFileSystem(IDictionary<string, MockFileData> files, string currentDirectory = "")
{
if (String.IsNullOrEmpty(currentDirectory))
currentDirectory = IO.Path.GetTempPath();
this.files = new Dictionary<string, MockFileData>(StringComparer.OrdinalIgnoreCase);
pathField = new MockPath(this);
file = new MockFile(this);
directory = new MockDirectory(this, file, currentDirectory);
fileInfoFactory = new MockFileInfoFactory(this);
directoryInfoFactory = new MockDirectoryInfoFactory(this);
if (files == null) return;
foreach (var entry in files)
AddFileWithCreate(entry.Key, entry.Value);
}
/// <summary>
/// Initializes a new <see cref="FusionCatalogue"/> with it's dependencies.
/// </summary>
/// <param name="configStore">Store used to retrieve configuration values.</param>
/// <param name="antFactory">Factory to create <see cref="IAnt"/> instances.</param>
/// <param name="directoryInfoFactory">Factory to create <see cref="IDirectoryInfo"/> instances.</param>
public FusionCatalogue(
IConfigStore configStore,
IAntFactory antFactory,
IDirectoryInfoFactory directoryInfoFactory)
{
this.configStore = configStore;
this.antFactory = antFactory;
this.directoryInfoFactory = directoryInfoFactory;
rootDirectory = FormatRootDirectory(AppDomain.CurrentDomain.BaseDirectory);
if (!Directory.Exists(rootDirectory))
{
Directory.CreateDirectory(rootDirectory);
}
}
public NewWorkspaceInvestigationWizardVm(IDirectoryInfoFactory directoryInfoManager, IWindsorContainer applicationWindsorContainer,
InvestigationInfo investigationInfo, IInvestigationFactory investigationFactory,
IDetectiveMessenger detectiveMessenger, CreateWorkspaceCommand createWorkspaceCommand, CreateInvestigationCommand createInvestigationCommand) : base(applicationWindsorContainer)
{
_createInvestigationCommand = createInvestigationCommand;
_createWorkspaceCommand = createWorkspaceCommand;
_detectiveMessenger = detectiveMessenger;
_investigationFactory = investigationFactory;
_directoryInfoManager = directoryInfoManager ?? throw new ArgumentNullException(nameof(directoryInfoManager));
this.InvestigationInfo = investigationInfo;
this.ViewType = typeof(INewWorkspaceInvestionWizardView);
var ts = DateTime.Now.Millisecond;
this.SqlConnectionStringBuilder = this.CreateDefaultConnectionStringBuilder();
this.InvestigationName = $"Initial investigation - {ts}";
this.WorkspaceName = $"NFX workspace - {ts}";
}
public MockFileSystem(IDictionary <string, MockFileData> files, string currentDirectory = @"C:\Foo\Bar")
{
this.files = new Dictionary <string, MockFileData>(StringComparer.InvariantCultureIgnoreCase);
pathField = new MockPath(this);
file = new MockFile(this);
directory = new MockDirectory(this, file, FixPath(currentDirectory));
fileInfoFactory = new MockFileInfoFactory(this);
directoryInfoFactory = new MockDirectoryInfoFactory(this);
if (files == null)
{
return;
}
foreach (var entry in files)
{
AddFile(entry.Key, entry.Value);
}
}
public MainWindowViewModel(IDirectoryInfoFactory directoryInfoFactory, IFileInfoFactory fileInfoFactory)
{
SyncFolders = new ObservableCollection <SyncFolderPairViewModel>();
var foldersFile = fileInfoFactory.FromFileName(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), "LocalSyncFolders.txt"));
using var reader = foldersFile.OpenText();
string line;
while ((line = reader.ReadLine()) != null)
{
var parts = line.Split('|');
if (parts.Length != 2)
{
throw new Exception("Each line in the settings file must be a pair of folders separated by `|`");
}
SyncFolders.Add(new SyncFolderPairViewModel(directoryInfoFactory.FromDirectoryName(parts[0].Trim()), directoryInfoFactory.FromDirectoryName(parts[1].Trim())));
}
}
public MockFileSystem(IDictionary<string, MockFileData> files)
{
file = new MockFile(this);
directory = new MockDirectory(this, file);
fileInfoFactory = new MockFileInfoFactory(this);
path = new MockPath();
directoryInfoFactory = new MockDirectoryInfoFactory(this);
//For each mock file add a file to the files dictionary
//Also add a file entry for all directories leading up to this file
this.files = new Dictionary<string, MockFileData>(StringComparer.InvariantCultureIgnoreCase);
foreach (var entry in files)
{
var directoryPath = Path.GetDirectoryName(entry.Key);
if (!directory.Exists(directoryPath))
directory.CreateDirectory(directoryPath);
if (!file.Exists(entry.Key))
this.files.Add(entry.Key, entry.Value);
}
}
public QueryFileSystemInfo(IDirectoryInfoFactory directoryInfoFactory)
{
_directoryInfoFactory = directoryInfoFactory;
}
public ScanAgent(IDirectory directory, IDirectoryInfoFactory directoryInfoFactory, IFileInfoFactory fileInfoFactory)
{
_fileInfoFactory = fileInfoFactory;
_directoryInfoFactory = directoryInfoFactory;
_directory = directory;
}
/// <summary>
/// Initializes a new instance of the <see cref="FileSystemInfoFactory" /> class.
/// </summary>
/// <param name="fileInfoFactory">The file information factory.</param>
/// <param name="directoryInfoFactory">The directory information factory.</param>
public FileSystemInfoFactory(IFileInfoFactory fileInfoFactory, IDirectoryInfoFactory directoryInfoFactory)
{
_fileInfoFactory = fileInfoFactory;
_directoryInfoFactory = directoryInfoFactory;
}
/// <summary>
/// Initializes a new instance of the <see cref="CurrentDirectoryProvider" /> class.
/// </summary>
/// <param name="factory">The factory.</param>
/// <param name="directoryFileSystem">The directory file system.</param>
public CurrentDirectoryProvider(IDirectoryInfoFactory factory,
IDirectory directoryFileSystem)
{
_factory = factory;
_directoryFileSystem = directoryFileSystem;
}
public static IEnumerable <IDirectoryInfo> GetFromDirectoryInfos(this IDirectoryInfoFactory directoryInfoFactory,
IEnumerable <IDirectoryInfo> infos)
{
return(infos.ToList().ConvertAll(info => directoryInfoFactory.GetFromDirectoryInfo(info)));
}
