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