private static EditorViewModel GetViewModel(string fileName, int address, WindowsFileSystem fileSystem, bool[] options)
{
bool useMetadata = options[0];
bool showDevMenu = options[1];
if (fileName != string.Empty)
{
fileName = Path.GetFullPath(fileName);
}
SetInitialWorkingDirectory();
var editor = new EditorViewModel(fileSystem, fileSystem, allowLoadingMetadata: useMetadata)
{
ShowDeveloperMenu = showDevMenu
};
DebugLog(editor, "------");
DebugLog(editor, fileName);
CheckIsNewerVersionAvailable(editor);
if (!File.Exists(fileName))
{
return(editor);
}
DebugLog(editor, "File Exists");
TryOpenFile(editor, fileSystem, fileName, address);
return(editor);
}
private void ExecuteDropMove(object parameter)
{
var sourceFileSystem = new WindowsFileSystem(droppedFiles.First().FullName);
var operation = new MoveOperation(droppedFiles, ActiveView.FullPath, sourceFileSystem, ActiveView.FileSystem);
OperationsManager.ExecuteOperation(operation);
}
public void CSVParseTestSuccess()
{
var dataSource = new WindowsFileSystem(_csvDataFilePath);
var dataFromFileSystem = dataSource.FetchData();
var dataToImport = new CSVDataToImport(dataFromFileSystem);
var dataSourceLocation = new CSVDataSourceLocation(6, 3);
var dataDateTimeSourceLocation = new CSVDataSourceLocation(6, 0);
var parser = new CellParser(new DefaultParserFactory());
var parseDoubleResult = parser.Parse(dataToImport, dataSourceLocation, typeof(double));
Assert.NotNull(parseDoubleResult);
Assert.AreEqual(parseDoubleResult.Level, ResultLevel.INFO);
Assert.AreEqual(parseDoubleResult.Message, "Parsing value successfully");
Assert.AreEqual(0.3, ((IParsingResult)parseDoubleResult).Value);
var parseDateTimeResult = parser.Parse(dataToImport, dataDateTimeSourceLocation, typeof(DateTime));
Assert.NotNull(parseDateTimeResult);
Assert.AreEqual(parseDateTimeResult.Level, ResultLevel.INFO);
Assert.AreEqual(parseDateTimeResult.Message, "Parsing value successfully");
Assert.AreEqual(new DateTime(2013, 12, 12, 14, 0, 0), ((IParsingResult)parseDateTimeResult).Value);
}
public void Execute()
{
string normalizedCurrentDirectory;
string errorMessage;
if (!WindowsFileSystem.TryGetNormalizedPathImplementation(Environment.CurrentDirectory, out normalizedCurrentDirectory, out errorMessage))
{
throw new Exception("Unable to get normalized path: " + errorMessage);
}
string enlistmentRoot;
if (!WindowsPlatform.TryGetGVFSEnlistmentRootImplementation(Environment.CurrentDirectory, out enlistmentRoot, out errorMessage))
{
throw new Exception("Unable to get GVFS Enlistment root: " + errorMessage);
}
string enlistmentPipename = Paths.GetNamedPipeName(enlistmentRoot);
AcquireLock(enlistmentPipename);
Console.ReadLine();
if (!this.NoReleaseLock)
{
ReleaseLock(enlistmentPipename, enlistmentRoot);
}
}
public void PublishDacpac(string rFile)
{
var fs = new WindowsFileSystem();
var settings = new SqlSProcPublishSettings();
settings.TargetType = PublishTargetType.Dacpac;
SetupProjectMocks("project.rproj");
var builder = Substitute.For <IDacPacBuilder>();
builder.When(x => x.Build(Arg.Any <string>(), Arg.Any <string>(), Arg.Any <IEnumerable <string> >())).Do(c => {
c.Args()[0].Should().Be("project.dacpac");
c.Args()[1].Should().Be("project");
var e = c.Args()[2] as IEnumerable <string>;
e.Should().HaveCount(1);
e.First().Should().StartWith("CREATE PROCEDURE ProcName");
});
_dacServices.GetBuilder().Returns(builder);
var files = new string[] { Path.Combine(_files.DestinationPath, rFile) };
var publisher = new SProcPublisher(_shell, _pss, fs, _dacServices);
publisher.Publish(settings, files);
builder.Received(1).Build(Arg.Any <string>(), Arg.Any <string>(), Arg.Any <IEnumerable <string> >());
}
public void CSVParseTestSuccess()
{
var dataSource = new WindowsFileSystem(_csvDataFilePath);
var dataFromFileSystem = dataSource.FetchData();
var dataToImport = new CSVDataToImport(dataFromFileSystem);
var dataSourceLocation = new CSVDataSourceLocation(6, 3);
var dataDateTimeSourceLocation = new CSVDataSourceLocation(6, 0);
var parser = new CellParser(new DefaultParserFactory());
var parseDoubleResult = parser.Parse(dataToImport, dataSourceLocation, typeof(double));
Assert.NotNull(parseDoubleResult);
Assert.AreEqual(parseDoubleResult.Level, ResultLevel.INFO);
Assert.AreEqual(parseDoubleResult.Message, "Parsing value successfully");
Assert.AreEqual(0.3, ((IParsingResult)parseDoubleResult).Value);
var parseDateTimeResult = parser.Parse(dataToImport, dataDateTimeSourceLocation, typeof(DateTime));
Assert.NotNull(parseDateTimeResult);
Assert.AreEqual(parseDateTimeResult.Level, ResultLevel.INFO);
Assert.AreEqual(parseDateTimeResult.Message, "Parsing value successfully");
Assert.AreEqual(new DateTime(2013, 12, 12, 14, 0, 0), ((IParsingResult)parseDateTimeResult).Value);
}
private static bool TryGetGVFSEnlistmentRootImplementation(string directory, out string enlistmentRoot, out string errorMessage)
{
if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
{
return(POSIXPlatform.TryGetGVFSEnlistmentRootImplementation(directory, out enlistmentRoot, out errorMessage));
}
// Not able to use WindowsPlatform here - because of its dependency on WindowsIdentity (and also kernel32.dll).
enlistmentRoot = null;
string finalDirectory;
if (!WindowsFileSystem.TryGetNormalizedPathImplementation(directory, out finalDirectory, out errorMessage))
{
return(false);
}
enlistmentRoot = Paths.GetRoot(finalDirectory, GVFSConstants.DotGVFS.Root);
if (enlistmentRoot == null)
{
errorMessage = $"Failed to find the root directory for {GVFSConstants.DotGVFS.Root} in {finalDirectory}";
return(false);
}
return(true);
}
public CommandContext()
{
Streams = new StandardStreams();
Trace = new Trace();
Git = new LibGit2(Trace);
if (PlatformUtils.IsWindows())
{
FileSystem = new WindowsFileSystem();
Environment = new WindowsEnvironment(FileSystem);
Terminal = new WindowsTerminal(Trace);
CredentialStore = WindowsCredentialManager.Open();
}
else if (PlatformUtils.IsPosix())
{
if (PlatformUtils.IsMacOS())
{
FileSystem = new MacOSFileSystem();
CredentialStore = MacOSKeychain.Open();
}
else if (PlatformUtils.IsLinux())
{
throw new NotImplementedException();
}
Environment = new PosixEnvironment(FileSystem);
Terminal = new PosixTerminal(Trace);
}
string repoPath = Git.GetRepositoryPath(FileSystem.GetCurrentDirectory());
Settings = new Settings(Environment, Git, repoPath);
HttpClientFactory = new HttpClientFactory(Trace, Settings, Streams);
}
protected override void OnStartup(StartupEventArgs e)
{
base.OnStartup(e);
var(path, address, options) = ParseArgs(e.Args);
singleInstanceApplicationMutex = new Mutex(true, appInstanceIdentifier, out var mutexIsNew);
if (!mutexIsNew)
{
SendParams(path, address);
}
var fileSystem = new WindowsFileSystem(Dispatcher);
var viewModel = GetViewModel(path, address, fileSystem, options);
SetupServer(viewModel);
DebugLog(viewModel, e.Args);
DebugLog(viewModel, "Have Editor");
UpdateThemeDictionary(Resources, viewModel.Theme);
viewModel.Theme.PropertyChanged += (sender, _) => UpdateThemeDictionary(Resources, viewModel.Theme);
MainWindow = new MainWindow(viewModel);
MainWindow.Resources.Add("FileSystem", fileSystem);
MainWindow.Resources.Add("PaletteMixer", new PaletteCollection().Fluent(mixer => mixer.SetContents(new short[16])));
MainWindow.Resources.Add("IsPaletteMixerExpanded", new EditableValue <bool>());
MainWindow.Show();
DebugLog(viewModel, "All Started!");
}
private DirectorySecurity GetServiceDirectorySecurity(string serviceDataRootPath)
{
DirectorySecurity serviceDataRootSecurity;
if (Directory.Exists(serviceDataRootPath))
{
this.tracer.RelatedInfo($"{nameof(this.GetServiceDirectorySecurity)}: {serviceDataRootPath} exists, modifying ACLs.");
serviceDataRootSecurity = Directory.GetAccessControl(serviceDataRootPath);
}
else
{
this.tracer.RelatedInfo($"{nameof(this.GetServiceDirectorySecurity)}: {serviceDataRootPath} does not exist, creating new ACLs.");
serviceDataRootSecurity = new DirectorySecurity();
}
// Protect the access rules from inheritance and remove any inherited rules
serviceDataRootSecurity.SetAccessRuleProtection(isProtected: true, preserveInheritance: false);
// Remove any existing ACLs and add new ACLs for users and admins
WindowsFileSystem.RemoveAllFileSystemAccessRulesFromDirectorySecurity(serviceDataRootSecurity);
WindowsFileSystem.AddUsersAccessRulesToDirectorySecurity(serviceDataRootSecurity, grantUsersModifyPermissions: false);
WindowsFileSystem.AddAdminAccessRulesToDirectorySecurity(serviceDataRootSecurity);
return(serviceDataRootSecurity);
}
/// <summary>
/// Runs the application.
/// </summary>
/// <param name="appPaths">The app paths.</param>
/// <param name="logManager">The log manager.</param>
/// <param name="runService">if set to <c>true</c> [run service].</param>
/// <param name="options">The options.</param>
private static void RunApplication(ServerApplicationPaths appPaths, ILogManager logManager, bool runService, StartupOptions options)
{
var fileSystem = new WindowsFileSystem(new PatternsLogger(logManager.GetLogger("FileSystem")));
fileSystem.AddShortcutHandler(new MbLinkShortcutHandler(fileSystem));
var nativeApp = new WindowsApp(fileSystem)
{
IsRunningAsService = runService
};
_appHost = new ApplicationHost(appPaths,
logManager,
options,
fileSystem,
"emby.windows.zip",
nativeApp);
var initProgress = new Progress <double>();
if (!runService)
{
if (!options.ContainsOption("-nosplash"))
{
ShowSplashScreen(_appHost.ApplicationVersion, initProgress, logManager.GetLogger("Splash"));
}
// Not crazy about this but it's the only way to suppress ffmpeg crash dialog boxes
SetErrorMode(ErrorModes.SEM_FAILCRITICALERRORS | ErrorModes.SEM_NOALIGNMENTFAULTEXCEPT |
ErrorModes.SEM_NOGPFAULTERRORBOX | ErrorModes.SEM_NOOPENFILEERRORBOX);
}
var task = _appHost.Init(initProgress);
task = task.ContinueWith(new Action <Task>(a => _appHost.RunStartupTasks()));
if (runService)
{
StartService(logManager);
}
else
{
Task.WaitAll(task);
task = InstallVcredistIfNeeded(_appHost, _logger);
Task.WaitAll(task);
SystemEvents.SessionEnding += SystemEvents_SessionEnding;
SystemEvents.SessionSwitch += SystemEvents_SessionSwitch;
HideSplashScreen();
ShowTrayIcon();
task = ApplicationTaskCompletionSource.Task;
Task.WaitAll(task);
}
}
public void GenerateEmpty()
{
var fs = new WindowsFileSystem();
var g = new SProcProjectFilesGenerator(_pss, fs);
var settings = new SqlSProcPublishSettings();
g.Generate(settings, Enumerable.Empty <string>(), _project);
}
static void Main(string[] args)
{
// Let's create our file system instance
IFileSystem fileSystem = new WindowsFileSystem();
// Create our directories
fileSystem.CreateDirectories("/home/XXX/Documents/Users/Pepe/datos/", "/home/XXX/Documents/Users/Juan");
}
public void CSVDataToImportReadCSVFileTest()
{
var dataSource = new WindowsFileSystem(_csvDataFilePath);
var dataFromFileSystem = dataSource.FetchData();
var dataToImport = new CSVDataToImport(dataFromFileSystem);
AssertData(Path.GetFileName(_csvDataFilePath), dataToImport);
}
private CSVDataToImport CreateCSVDataToImport(string filePath)
{
var dataSource = new WindowsFileSystem(filePath);
var dataFromFileSystem = dataSource.FetchData();
var dataToImport = new CSVDataToImport(dataFromFileSystem);
return(dataToImport);
}
private void bCompare_Click(object sender, RoutedEventArgs e)
{
//load directory content
WindowsFileSystem fileSystem = new WindowsFileSystem();
IEnumerable <IDirectoryViewItem> leftItems = fileSystem.GetDirectoryContent(LeftDir);
List <IDirectoryViewItem> rightItems = fileSystem.GetDirectoryContent(RightDir).ToList();//list need for remove functionality
comparisonResult = new List <DirectoryComparison>();
IDirectoryViewItem rightItem;
foreach (IDirectoryViewItem item in leftItems)
{
if (item == null || item.IsMoveUp)
{
continue;
}
rightItem = rightItems.SingleOrDefault(dvi => dvi != null && dvi.Name == item.Name);//right item that matches left name
if (rightItem != null)
{
if (item.IsDirectory)
{
comparisonResult.Add(new DirectoryComparison(item, rightItem, DirectoryComparisonResult.Equal));
}
else if (item.LastModifiedTime > rightItem.LastModifiedTime)
{
comparisonResult.Add(new DirectoryComparison(item, rightItem, DirectoryComparisonResult.LeftNewer));
}
else if (item.LastModifiedTime < rightItem.LastModifiedTime)
{
comparisonResult.Add(new DirectoryComparison(item, rightItem, DirectoryComparisonResult.RightNewer));
}
else
{
comparisonResult.Add(new DirectoryComparison(item, rightItem, DirectoryComparisonResult.Equal));
}
rightItems.Remove(rightItem);//no need in futher comparison
}
else
{
comparisonResult.Add(new DirectoryComparison(item, null, DirectoryComparisonResult.LeftNewer));
}
}
//every item from right collection don't exist in left
foreach (IDirectoryViewItem item in rightItems)
{
if (item == null || item.IsMoveUp)
{
continue;
}
comparisonResult.Add(new DirectoryComparison(null, item, DirectoryComparisonResult.RightNewer));
}
lvCompare.ItemsSource = comparisonResult;
}
public void XMLDataToImportReadXMLFileTest()
{
var dataSource = new WindowsFileSystem(_xmlDataFilePath);
var dataFromFileSystem = dataSource.FetchData();
var dataToImport = new XMLDataToImport(dataFromFileSystem);
AssertData(Path.GetFileName(_xmlDataFilePath), dataToImport);
}
Storage CreateStorage()
{
FileSystem filesystem = new WindowsFileSystem();
var serializer = new JsonSerializer(readableFormatting: true);
var path = filesystem.CreatePath(filesystem.TempDirectory, @"MyTestFile.json");
var storage = new TextFileStorage(filesystem, serializer, path);
return(storage);
}
public static XMLDataToImport CreateXMLDatoToImport(string filePath)
{
var dataSource = new WindowsFileSystem(filePath);
var dataFromFileSystem = dataSource.FetchData();
var dataToImport = new XMLDataToImport(dataFromFileSystem);
return(dataToImport);
}
private IDataToImport GetDataToImport(string fileName)
{
var path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "DataFiles", fileName);
var dataSource = new WindowsFileSystem(path);
var dataFromFileSystem = dataSource.FetchData();
var dataToImport = new CSVDataToImport(dataFromFileSystem);
return(dataToImport);
}
private IDataToImport GetDataToImport(string fileName)
{
var path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "DataFiles", fileName);
var dataSource = new WindowsFileSystem(path);
var dataFromFileSystem = dataSource.FetchData();
var dataToImport = new XMLDataToImport(dataFromFileSystem);
return dataToImport;
}
public static void Main(string[] args)
{
try
{
if (args.Length < 2)
{
ExitWithError("Usage: gvfs.hooks.exe --git-pid=<pid> <hook> <git verb> [<other arguments>]");
}
bool unattended = GVFSEnlistment.IsUnattended(tracer: null);
string errorMessage;
string normalizedCurrentDirectory;
if (!WindowsFileSystem.TryGetNormalizedPathImplementation(Environment.CurrentDirectory, out normalizedCurrentDirectory, out errorMessage))
{
ExitWithError($"Failed to determine final path for current directory {Environment.CurrentDirectory}. Error: {errorMessage}");
}
if (!WindowsPlatform.TryGetGVFSEnlistmentRootImplementation(Environment.CurrentDirectory, out enlistmentRoot, out errorMessage))
{
// Nothing to hook when being run outside of a GVFS repo.
// This is also the path when run with --git-dir outside of a GVFS directory, see Story #949665
Environment.Exit(0);
}
enlistmentPipename = Paths.GetNamedPipeName(enlistmentRoot);
switch (GetHookType(args))
{
case PreCommandHook:
CheckForLegalCommands(args);
RunLockRequest(args, unattended, AcquireGVFSLockForProcess);
RunPreCommands(args);
break;
case PostCommandHook:
// Do not release the lock if this request was only run to see if it could acquire the GVFSLock,
// but did not actually acquire it.
if (!CheckGVFSLockAvailabilityOnly(args))
{
RunLockRequest(args, unattended, ReleaseGVFSLock);
}
break;
default:
ExitWithError("Unrecognized hook: " + string.Join(" ", args));
break;
}
}
catch (Exception ex)
{
ExitWithError("Unexpected exception: " + ex.ToString());
}
}
public PreviewView()
{
InitializeComponent();
FileSystem = new WindowsFileSystem();
History = new History <IDirectoryViewItem>();
Binding bind = new Binding("Items");
bind.Source = FileSystem;
lbContent.SetBinding(ListBox.ItemsSourceProperty, bind);
lbContent.ItemContainerGenerator.StatusChanged += new EventHandler(ItemContainerGenerator_StatusChanged);
}
public static int Main(string[] args)
{
Stopwatch commandStopwatch = new Stopwatch();
commandStopwatch.Start();
XmlConfigurator.Configure();
IRazorCompiler razorCompiler = new InMemoryRazorCompiler();
IFileSystem fileSystem = new WindowsFileSystem();
//IFtpChannelFactory ftpChannelFactory = new FtpChannelFactoryUsingSockets ();
//IFtpCommunicator ftpCommunicator = new FtpCommunicator ();
//IFtpSessionFactory ftpSessionFactory = new FtpSessionFactory(ftpChannelFactory, ftpCommunicator, fileSystem);
IFreudeTemplatingEngine freudeTemplatingEngine = new FreudeTemplatingEngine(razorCompiler);
IWikiTextTokenizer wikiTextTokenizer = new WikiTextTokenizer();
IFreudeTextParser freudeTextParser = new FreudeTextParser(wikiTextTokenizer);
IProjectBuilder projectBuilder = new ProjectBuilder(fileSystem);
ConsoleShell consoleShell = new ConsoleShell("Freude.Engine.exe");
consoleShell.RegisterCommand(new BuildCommand(fileSystem, projectBuilder, freudeTextParser, freudeTemplatingEngine));
//consoleShell.RegisterCommand (new DeployCommand(projectBuilder, ftpSessionFactory));
try
{
ConsoleShellResult consoleShellResult = consoleShell.ParseCommandLine(args);
if (consoleShellResult.ExitCode.HasValue)
{
return(consoleShellResult.ExitCode.Value);
}
foreach (IConsoleCommand consoleCommand in consoleShellResult.CommandsToExecute)
{
consoleCommand.Execute(consoleShell);
}
TimeSpan elapsed = commandStopwatch.Elapsed;
log.InfoFormat("Command done in {0}", elapsed);
return(0);
}
catch (Exception ex)
{
log.Fatal("Program failed", ex);
return(1);
}
}
private IExtractConfiguration CreateSampleFileDataExtractConfiguration()
{
var path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "DataFiles", "SampleFileExample.csv");
var dataSource = new WindowsFileSystem(path);
var dataFromFileSystem = dataSource.FetchData();
var dataToImport = new CSVDataToImport(dataFromFileSystem);
var simpleValueAssginer = new SimpleValueAssigner();
var sampleDataImporter = ESDATTestHelper.BuildSampleDataFileImporter();
var childObjectExtractConfiguration = new SampleFileChildObjectExtractConfiguration(sampleDataImporter, "SampleFileData", simpleValueAssginer);
return(childObjectExtractConfiguration);
}
private static void TryOpenFile(EditorViewModel editor, WindowsFileSystem fileSystem, string fileName, int address)
{
var loadedFile = fileSystem.LoadFile(fileName);
editor.Open.Execute(loadedFile);
DebugLog(editor, "Tab Added");
var tab = editor[editor.SelectedIndex] as ViewPort;
if (tab != null && address >= 0)
{
DebugLog(editor, $"Loading at Script {address:X6}.");
tab.Model.AfterInitialized(() => fileSystem.DispatchWork(() => tab.CascadeScript(address)));
editor.GotoViewModel.ControlVisible = false;
}
}
protected override void OnStartup(StartupEventArgs e)
{
base.OnStartup(e);
var(path, address, useMetadata) = ParseArgs(e.Args);
var fileSystem = new WindowsFileSystem(Dispatcher);
var viewModel = GetViewModel(path, address, fileSystem, useMetadata);
UpdateThemeDictionary(viewModel);
viewModel.Theme.PropertyChanged += (sender, _) => UpdateThemeDictionary(viewModel);
MainWindow = new MainWindow(viewModel);
MainWindow.Resources.Add("FileSystem", fileSystem);
MainWindow.Show();
}
public ThreeColumnView()
{
InitializeComponent();
fileSystem1 = new WindowsFileSystem();
fileSystem2 = new WindowsFileSystem();
fileSystem3 = new WindowsFileSystem();
history = new History <IDirectoryViewItem>();
Binding bind2 = new Binding("Items");//bind to second(middle) ListBox
bind2.Source = FileSystem;
lbContent2.SetBinding(ListBox.ItemsSourceProperty, bind2);
lbContent2.ItemContainerGenerator.StatusChanged += new EventHandler(ItemContainerGenerator_StatusChanged);
}
public void Generate(string rFile, RCodePlacement codePlacement, SqlQuoteType quoteType, string sprocName)
{
var fs = new WindowsFileSystem();
var settings = new SqlSProcPublishSettings();
var g = new SProcProjectFilesGenerator(_pss, fs);
var targetProjItem = Substitute.For <EnvDTE.ProjectItem>();
var targetProjItems = Substitute.For <EnvDTE.ProjectItems>();
targetProjItem.ProjectItems.Returns(targetProjItems);
var rootProjItems = Substitute.For <EnvDTE.ProjectItems>();
rootProjItems.Item("R").Returns((EnvDTE.ProjectItem)null);
rootProjItems.AddFolder("R").Returns(targetProjItem);
_project.ProjectItems.Returns(rootProjItems);
var templateFile = Path.Combine(_files.DestinationPath, Path.GetFileNameWithoutExtension(rFile) + SProcFileExtensions.SProcFileExtension);
var sprocFiles = new string[] {
Path.Combine(_files.DestinationPath, rFile),
Path.Combine(_files.DestinationPath, Path.GetFileNameWithoutExtension(rFile) + SProcFileExtensions.QueryFileExtension),
templateFile
};
settings.CodePlacement = codePlacement;
settings.QuoteType = quoteType;
g.Generate(settings, sprocFiles, _project);
rootProjItems.Received().AddFolder("R");
var targetFolder = Path.Combine(_files.DestinationPath, "R\\");
var rFilePath = Path.Combine(targetFolder, rFile);
var sprocFile = Path.ChangeExtension(Path.Combine(targetFolder, sprocName), ".sql");
targetProjItem.ProjectItems.Received().AddFromFile(sprocFile);
if (codePlacement == RCodePlacement.Table)
{
targetProjItem.ProjectItems.Received().AddFromFile(Path.Combine(targetFolder, SProcProjectFilesGenerator.PostDeploymentScriptName));
targetProjItem.ProjectItems.Received().AddFromFile(Path.Combine(targetFolder, SProcProjectFilesGenerator.CreateRCodeTableScriptName));
}
var mode = codePlacement == RCodePlacement.Inline ? "inline" : "table";
var baseline = fs.ReadAllText(Path.Combine(_files.DestinationPath, Invariant($"{Path.GetFileNameWithoutExtension(rFile)}.{mode}.baseline.sql")));
string actual = fs.ReadAllText(sprocFile);
BaselineCompare.CompareStringLines(baseline, actual);
}
public DirectoryViewModel()
{
ExecuteItemCommand = new DelegateCommand(ExecuteExecuteItem, CanExecuteExecuteItem);
History = new History <IDirectoryViewItem>();
FileSystem = new WindowsFileSystem();
propObserver = new PropertyObserver <DirectoryViewModel>(this);
propObserver.RegisterHandler(x => x.SearchText, ManageSearch);
fileSystemWatcher = new FileSystemWatcher {
IncludeSubdirectories = false,
};
fileSystemWatcher.Created += fileSystemWatcher_Changed;
fileSystemWatcher.Renamed += fileSystemWatcher_Changed;
fileSystemWatcher.Deleted += fileSystemWatcher_Changed;
}
public void ExtractDataTest()
{
var path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "DataFiles", "XMLSample.xml");
var dataSource = new WindowsFileSystem(path);
var dataFromFileSystem = dataSource.FetchData();
var dataToImport = new XMLDataToImport(dataFromFileSystem);
var dataImporter = new TestXMLImporterBuilder().Build();
var extractedDataSet = dataImporter.Extract <ESDATModel>(dataToImport);
Assert.NotNull(extractedDataSet);
Assert.AreEqual(true, extractedDataSet.IsExtractedSuccess);
Assert.AreEqual(1, extractedDataSet.ExtractedEntities.Count());
}
public void ExtractDataTest()
{
var path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "DataFiles", "XMLSample.xml");
var dataSource = new WindowsFileSystem(path);
var dataFromFileSystem = dataSource.FetchData();
var dataToImport = new XMLDataToImport(dataFromFileSystem);
var dataImporter = new TestXMLImporterBuilder().Build();
var extractedDataSet = dataImporter.Extract<ESDATModel>(dataToImport);
Assert.NotNull(extractedDataSet);
Assert.AreEqual(true, extractedDataSet.IsExtractedSuccess);
Assert.AreEqual(1, extractedDataSet.ExtractedEntities.Count());
}
public void ParsingSuccessTest()
{
var path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "DataFiles", "XMLSample.xml");
var dataSource = new WindowsFileSystem(path);
var dataFromFileSystem = dataSource.FetchData();
var dataToImport = new XMLDataToImport(dataFromFileSystem);
var dataSourceLocation = new XMLDataSourceLocation("LabReport", "Lab_Report_Number");
var parserFactory = new DefaultParserFactory();
var testCellParser = new ElementParser(parserFactory);
var testParsingResult = testCellParser.Parse(dataToImport, dataSourceLocation, typeof(string)) as ParsingResult;
Assert.NotNull(testParsingResult);
Assert.AreEqual(ResultLevel.INFO, testParsingResult.Level);
Assert.AreEqual("Parsing value successfully", testParsingResult.Message);
Assert.AreEqual("LR04927",testParsingResult.Value);
}
public void Setup()
{
IFileSystem fileSystem = new WindowsFileSystem();
IRazorCompiler razorCompiler = new InMemoryRazorCompiler();
engine = new RazorViewRenderingEngine(fileSystem, razorCompiler);
RazorEngineCompileSettings razorEngineCompileSettings = new RazorEngineCompileSettings();
razorEngineCompileSettings.DefaultNamespace = "Syborg.Tests";
razorEngineCompileSettings.DefaultClassName = "SyborgTestRazorTemplate";
razorEngineCompileSettings.NamespaceImports.Add("System");
razorEngineCompileSettings.NamespaceImports.Add("System.Collections");
razorEngineCompileSettings.NamespaceImports.Add("System.Collections.Generic");
razorEngineCompileSettings.DefaultBaseClass = typeof(RazorTemplateBase).FullName;
razorEngineCompileSettings.ReferenceAssemblies.Add(typeof(HtmlString).Assembly);
razorEngineCompileSettings.DebugMode = DebugMode;
engine.Initialize("Views", razorEngineCompileSettings);
}
public void ParsingSuccessTest()
{
var path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "DataFiles", "XMLSample.xml");
var dataSource = new WindowsFileSystem(path);
var dataFromFileSystem = dataSource.FetchData();
var dataToImport = new XMLDataToImport(dataFromFileSystem);
var dataSourceLocation = new XMLDataSourceLocation("LabReport", "Lab_Report_Number");
var parserFactory = new DefaultParserFactory();
var testCellParser = new ElementParser(parserFactory);
var testParsingResult = testCellParser.Parse(dataToImport, dataSourceLocation, typeof(string)) as ParsingResult;
Assert.NotNull(testParsingResult);
Assert.AreEqual(ResultLevel.INFO, testParsingResult.Level);
Assert.AreEqual("Parsing value successfully", testParsingResult.Message);
Assert.AreEqual("LR04927", testParsingResult.Value);
}
public void ExtractChemistryFileDataTest()
{
var path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "DataFiles", "ChemistryFileExample.csv");
var dataSource = new WindowsFileSystem(path);
var dataFromFileSystem = dataSource.FetchData();
var dataToImport = new CSVDataToImport(dataFromFileSystem);
var chemistryFileImporter = BuildChemistryFileImporter();
var extractResult = chemistryFileImporter.Extract<ChemistryFileData>(dataToImport);
var allFailResults = extractResult.AllParsingResults.Where(x => x.Level == ResultLevel.ERROR).ToList();
Assert.NotNull(extractResult);
Assert.AreEqual(ResultLevel.ERROR, extractResult.ThresholdLevel);
Assert.False(allFailResults.Any());
Assert.AreEqual(true, extractResult.IsExtractedSuccess);
Assert.AreEqual(9, extractResult.ExtractedEntities.Count());
var firstEntity = extractResult.ExtractedEntities.FirstOrDefault();
Assert.NotNull(firstEntity);
Assert.AreEqual("5828314", firstEntity.SampleCode);
Assert.AreEqual("100-41-4", firstEntity.ChemCode);
Assert.AreEqual("Ethylbenzene", firstEntity.OriginalChemName);
Assert.AreEqual("<", firstEntity.Prefix);
Assert.AreEqual(0.0005, firstEntity.Result);
Assert.AreEqual("mg/L", firstEntity.ResultUnit);
Assert.AreEqual("T", firstEntity.TotalOrFiltered);
Assert.AreEqual("REG", firstEntity.ResultType);
Assert.AreEqual("Inorganic", firstEntity.MethodType);
Assert.AreEqual("TO 0332", firstEntity.MethodName);
Assert.AreEqual(new DateTime(2014, 9, 23), firstEntity.ExtractionDate);
Assert.AreEqual(new DateTime(2014, 9, 24), firstEntity.AnalysedDate);
Assert.AreEqual(0.0005, firstEntity.EQL);
Assert.AreEqual("mg/L", firstEntity.EQLUnits);
Assert.AreEqual(string.Empty, firstEntity.Comments);
Assert.AreEqual(50.0d, firstEntity.UCL);
Assert.AreEqual(null, firstEntity.LCL);
}
public void OutOfRangeTest()
{
var path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "DataFiles", "XMLSample.xml");
var dataSource = new WindowsFileSystem(path);
var dataFromFileSystem = dataSource.FetchData();
var dataSourceLocation = new XMLDataSourceLocation("here","there");
var dataToImport = new XMLDataToImport(dataFromFileSystem);
var parserFactory = new DefaultParserFactory();
var testElementParser = new ElementParser(parserFactory);
var testParsingResult = testElementParser.Parse(dataToImport, dataSourceLocation, typeof(int)) as ParsingResult;
Assert.NotNull(testParsingResult);
Assert.AreEqual(ResultLevel.FATAL, testParsingResult.Level);
//Assert.AreEqual("Argument is out of range", testParsingResult.Message);
Assert.Null(testParsingResult.Value);
}
public void ChemistryFilePropertyTest()
{
var path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "DataFiles", "ChemistryFileExample.csv");
var dataSource = new WindowsFileSystem(path);
var dataFromFileSystem = dataSource.FetchData();
var dataToImport = new CSVDataToImport(dataFromFileSystem);
var simpleValueAssginer = new SimpleValueAssigner();
var chemistryImporter = ESDATTestHelper.BuildChemistryFileImporter();
var childObjectExtractConfiguration = new ChemistryFileChildObjectExtractConfiguration(chemistryImporter, "ChemistryData", simpleValueAssginer);
Assert.AreEqual(typeof(ChemistryFileData), childObjectExtractConfiguration.ChildObjectType);
var testESDATModel = new ESDATModel();
var extractResult = childObjectExtractConfiguration.ExtractData(testESDATModel, dataToImport);
Assert.NotNull(extractResult);
Assert.AreEqual(9, testESDATModel.ChemistryData.Count());
}
public void ChemistryFilePropertyTest()
{
var path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "DataFiles", "SampleFileExample.csv");
var dataSource = new WindowsFileSystem(path);
var dataFromFileSystem = dataSource.FetchData();
var dataToImport = new CSVDataToImport(dataFromFileSystem);
var simpleValueAssginer = new SimpleValueAssigner();
var sampleDataImporter = ESDATTestHelper.BuildSampleDataFileImporter();
var childObjectExtractConfiguration = new SampleFileChildObjectExtractConfiguration(sampleDataImporter, "SampleFileData", simpleValueAssginer);
Assert.AreEqual(typeof(SampleFileData), childObjectExtractConfiguration.ChildObjectType);
var testESDATModel = new ESDATModel();
var extractResult = childObjectExtractConfiguration.ExtractData(testESDATModel, dataToImport);
Assert.NotNull(extractResult);
Assert.AreEqual(3, testESDATModel.SampleFileData.Count());
var firstSampleData = testESDATModel.SampleFileData.FirstOrDefault();
Assert.NotNull(firstSampleData);
Assert.AreEqual("5828314", firstSampleData.SampleCode);
Assert.AreEqual(new DateTime(2014, 9, 16), firstSampleData.SampledDateTime);
Assert.AreEqual("FRL-1 @ 16:00", firstSampleData.FieldID);
Assert.Null(firstSampleData.SampleDepth);
Assert.AreEqual("Water", firstSampleData.MatrixType);
Assert.AreEqual("Normal", firstSampleData.SampleType);
Assert.AreEqual(string.Empty, firstSampleData.ParentSample);
Assert.AreEqual("14J891101", firstSampleData.SDG);
Assert.AreEqual("AGAT", firstSampleData.LabName);
Assert.AreEqual("5828314", firstSampleData.LabSampleID);
Assert.AreEqual(string.Empty, firstSampleData.Comments);
Assert.AreEqual("14J891101", firstSampleData.LabReportNumber);
}
public void ParseTest()
{
var path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "DataFiles", "TestJSONFile.json");
var dataSource = new WindowsFileSystem(path);
var dataFromFileSystem = dataSource.FetchData();
var dataSourceLocation = new JSONDataSourceLocation("objects[*].name", true);
var dataToImport = new JSONDataToImport(dataFromFileSystem);
var parserFactory = new DefaultParserFactory();
var testParser = new SimpleJSONObjectParser(parserFactory);
var parseResults = testParser.Parse(dataToImport, dataSourceLocation, typeof(string)) as ParsingResult;
dynamic result = parseResults.Value;
Assert.NotNull(parseResults);
Assert.AreEqual("Cruise", result[0]);
Assert.AreEqual("Data retrieval", result[1]);
Assert.AreEqual("Derivation", result[2]);
}
public void ExtractSampleDataFileTest()
{
var path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "DataFiles", "SampleFileExample.csv");
var dataSource = new WindowsFileSystem(path);
var dataFromFileSystem = dataSource.FetchData();
var dataToImport = new CSVDataToImport(dataFromFileSystem);
var sampleDataFileImporter = ESDATTestHelper.BuildSampleDataFileImporter();
var extractResult = sampleDataFileImporter.Extract<SampleFileData>(dataToImport);
var allFailResults = extractResult.AllParsingResults.Where(x => x.Level == ResultLevel.ERROR).ToList();
Assert.NotNull(extractResult);
Assert.AreEqual(ResultLevel.ERROR, extractResult.ThresholdLevel);
Assert.False(allFailResults.Any());
Assert.AreEqual(true, extractResult.IsExtractedSuccess);
Assert.AreEqual(3, extractResult.ExtractedEntities.Count());
var firstEntity = extractResult.ExtractedEntities.FirstOrDefault();
Assert.NotNull(firstEntity);
Assert.AreEqual("5828314", firstEntity.SampleCode);
Assert.AreEqual(new DateTime(2014, 9, 16), firstEntity.SampledDateTime);
Assert.AreEqual("FRL-1 @ 16:00", firstEntity.FieldID);
Assert.Null(firstEntity.SampleDepth);
Assert.AreEqual("Water", firstEntity.MatrixType);
Assert.AreEqual("Normal", firstEntity.SampleType);
Assert.AreEqual(string.Empty, firstEntity.ParentSample);
Assert.AreEqual("14J891101", firstEntity.SDG);
Assert.AreEqual("AGAT", firstEntity.LabName);
Assert.AreEqual("5828314", firstEntity.LabSampleID);
Assert.AreEqual(string.Empty, firstEntity.Comments);
Assert.AreEqual("14J891101", firstEntity.LabReportNumber);
}
private XMLDataToImport CreateXMLDatoToImport(string filePath)
{
var dataSource = new WindowsFileSystem(filePath);
var dataFromFileSystem = dataSource.FetchData();
var dataToImport = new XMLDataToImport(dataFromFileSystem);
return dataToImport;
}
public static CSVDataToImport CreateCSVDataToImport(string filePath)
{
var dataSource = new WindowsFileSystem(filePath);
var dataFromFileSystem = dataSource.FetchData();
var dataToImport = new CSVDataToImport(dataFromFileSystem);
return dataToImport;
}
public static IExtractConfiguration CreateSampleFileDataExtractConfiguration()
{
var path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "DataFiles", "SampleFileExample.csv");
var dataSource = new WindowsFileSystem(path);
var dataFromFileSystem = dataSource.FetchData();
var dataToImport = new CSVDataToImport(dataFromFileSystem);
var simpleValueAssginer = new SimpleValueAssigner();
var sampleDataImporter = ESDATTestHelper.BuildSampleDataFileImporter();
var childObjectExtractConfiguration = new SampleFileChildObjectExtractConfiguration(sampleDataImporter, "SampleFileData", simpleValueAssginer);
return childObjectExtractConfiguration;
}
