public ExcelToDTOMapper(IRepository excelRepository, IClassGenerator classGenerator, IAssemblyGenerator assemblyGenerator, IFileConfiguration fileConfiguration) { _excelRepository = excelRepository; _classGenerator = classGenerator; _assemblyGenerator = assemblyGenerator; _fileConfiguration = fileConfiguration; }
public WaveStream(IFileMedia fileMedia, IFileConfiguration fileConfig, Interfaces.ILog log) { this.logger = log; this.fileConfig = fileConfig; this.ms = new MemoryStream(); this.writeToWaveFunc = fileMedia.GetDataSenderFunc(fileConfig, log).Result; }
public static TracerDecoration Create(IFileConfiguration config) { if (!config.Enabled) { return(NoopTracerDecorationFactory.Instance.ToPublicType()); } if (!Directory.Exists(config.RootLocation.Path)) { if (!config.RootLocation.CreateIfNotExists) { // No output location and configured not to make it, return noop return(NoopTracerDecorationFactory.Instance.ToPublicType()); } else { Directory.CreateDirectory(config.RootLocation.Path); } } var fileOutputHelper = new FileOutputHelper(config.RootLocation.Path); switch (config.OutputMode) { case OutputMode.Csv: return(new CsvFileTracerDecoration( fileOutputHelper.WriteToFile) .ToPublicType()); default: throw new ArgumentOutOfRangeException(); } }
private static Func <ISourceField, IValue> GetStringParser(string format, IFileConfiguration fileConfig) { if (fileConfig.TrimStrings) { return(source => new ValueWrapper <string>(source.Source?.Trim(), null, source.Source == null, source.Source)); } return(source => new ValueWrapper <string>(source.Source, null, source.Source == null, source.Source)); }
/// <summary> /// Choose what IFileConfiguration to use, global or the IDestinationFileConfiguration /// </summary> /// <param name="fileConfiguration">IFileConfiguration</param> /// <param name="destinationFileConfiguration">IDestinationFileConfiguration</param> /// <returns>IFileConfiguration</returns> public static IFileConfiguration Choose(this IFileConfiguration fileConfiguration, IDestinationFileConfiguration destinationFileConfiguration = null) { if (destinationFileConfiguration != null && !destinationFileConfiguration.UseOwnSettings) { return(destinationFileConfiguration); } return(fileConfiguration); }
public ExcelRepository(IDataProvider dataProvider, IFileConfiguration fileConfiguration, IFileService fileService) { _dataProvider = dataProvider; _fileService = fileService; _fileConfiguration = fileConfiguration; _resultCache = new Dictionary <string, CacheValue>(); }
private static Func <ISourceRow, long, long, IDataRow> GetRowParsers(this IFileConfiguration fileConfig) { var parsers = fileConfig.Rows.Select(x => x.GetRowParser(fileConfig)).ToList(); return((source, rowNumber, rawLineNumber) => { return parsers.Select(parser => parser(source, rowNumber, rawLineNumber)).FirstOrDefault(result => result != null); }); }
public PadWinViewModel(ICardReader cardReader, ILogger logger, IFileConfiguration fileConfiguration, IParameterPass parameterPass) { _cardReader = cardReader; _logger = logger; _fileConfiguration = fileConfiguration; _parameterPass = parameterPass; LoadCommand = new RelayCommand <ChromiumWebBrowser>(ExcuteLoadCommand); UnLoadCommand = new RelayCommand(ExcuteUnLoadCommand); CloseCommand = new RelayCommand(ExcuteCloseCommand); }
public async ValueTask <IStoredImageFile> StoreAsync(IFileConfiguration fileConfiguration) { var tmpFilePath = Path.GetTempFileName(); using var stream = new FileStream(tmpFilePath, FileMode.Create, FileAccess.Write, FileShare.ReadWrite | FileShare.Delete | FileShare.Inheritable, 4096, FileOptions.Asynchronous); fileConfiguration.DataStream.Position = 0; await fileConfiguration.DataStream.CopyToAsync(stream); return(new StoredImageFile(tmpFilePath, fileConfiguration.Name, fileConfiguration.Extension)); }
public void SetUp() { _connectionString = MockRepository.GenerateMock <IConnectionString>(); _fileConfiguration = MockRepository.GenerateMock <IFileConfiguration>(); _dataProvider = new OleDbDataProvider(new ConnectionBuilder(_connectionString), _fileConfiguration); _xlsxFile = TestData.UsersXlsx; _xlsFile = TestData.UsersXls; _workSheetName = "User"; _connectionString.Expect(x => x.Get(_xlsxFile)).Return(TestData.UsersXlsxConnectionString).Repeat.Any(); _connectionString.Expect(x => x.Get(_xlsFile)).Return(TestData.UsersXlsConnectionString).Repeat.Any(); }
public void SetUp() { _connectionString = MockRepository.GenerateMock<IConnectionString>(); _fileConfiguration = MockRepository.GenerateMock<IFileConfiguration>(); _dataProvider = new OleDbDataProvider(new ConnectionBuilder(_connectionString), _fileConfiguration); _xlsxFile = TestData.UsersXlsx; _xlsFile = TestData.UsersXls; _workSheetName = "User"; _connectionString.Expect(x => x.Get(_xlsxFile)).Return(TestData.UsersXlsxConnectionString).Repeat.Any(); _connectionString.Expect(x => x.Get(_xlsFile)).Return(TestData.UsersXlsConnectionString).Repeat.Any(); }
private static Stream GetWriterStream(this IFileMedia media, IFileConfiguration fileConfig, Interfaces.ILog log) { switch (media.MediaType) { case MediaType.Local: return(media.GetLocalStream(log)); case MediaType.Wave: return(media.GetWaveStreamWriter(fileConfig, log)); } return(null); }
public static Func <IDataRow> ParseData(this Func <ISourceRow> getLineFunc, IFileConfiguration fileConfig, Interfaces.ILog logger) { if (fileConfig == null) { var msg = Localization.GetLocalizationString("Could not get Source Configuration..."); logger?.Fatal(msg); throw new ArgumentException(msg); } logger?.Info(string.Format(Localization.GetLocalizationString("Parsing data from {0}"), fileConfig.Name)); var parsers = fileConfig.GetRowParsers(); var currentRecord = (long)0; var parsedRecords = (long)0; return(() => { var line = getLineFunc(); if (line != null) { currentRecord++; try { var row = parsers(line, currentRecord, currentRecord); if (row != null) { parsedRecords++; return row; } } catch (Exception ex) { logger?.Error(Localization.GetLocalizationString("Failed to parse line: \"{0}\"", string.Join(",", line.Fields.Select(x => x.Source)))); throw ex; } return new DataRow( new Dictionary <string, IValue> { { "raw", new ValueWrapper <string>(string.Join(",", line.Fields.Select(x => x.Source)), Localization.GetLocalizationString("Parse error"), true, string.Join(",", line.Fields.Select(x => x.Source))) } }, Localization.GetLocalizationString("Could not parse line."), currentRecord, line.LineNumber, line.Context.SourcePath, line.Context.FileConfiguration.Name); } logger?.Info(string.Format(Localization.GetLocalizationString("Parsed {0}/{1} records from {2}"), parsedRecords, currentRecord, fileConfig.Name)); return null; }); }
/// <exception cref="System.Exception"></exception> public virtual void Test() { if (CommonAndLocalConfigurationTestSuite.Subject() is IClientConfiguration) { return; } IFileConfigurationProvider config = ((IFileConfigurationProvider)Subject()); IFileConfiguration fileConfig = config.File; Config4Impl legacyConfig = Db4oLegacyConfigurationBridge.AsLegacy(config); fileConfig.BlockSize = 42; Assert.AreEqual(42, legacyConfig.BlockSize()); fileConfig.DatabaseGrowthSize = 42; Assert.AreEqual(42, legacyConfig.DatabaseGrowthSize()); fileConfig.DisableCommitRecovery(); Assert.IsTrue(legacyConfig.CommitRecoveryDisabled()); fileConfig.Freespace.DiscardSmallerThan(8); Assert.AreEqual(8, legacyConfig.DiscardFreeSpace()); fileConfig.GenerateUUIDs = ConfigScope.Globally; Assert.AreEqual(ConfigScope.Globally, legacyConfig.GenerateUUIDs()); fileConfig.GenerateCommitTimestamps = true; Assert.IsTrue(legacyConfig.GenerateCommitTimestamps().DefiniteYes()); IStorage storageFactory = new FileStorage(); fileConfig.Storage = storageFactory; Assert.AreSame(storageFactory, legacyConfig.Storage); Assert.AreSame(storageFactory, fileConfig.Storage); fileConfig.LockDatabaseFile = true; Assert.IsTrue(legacyConfig.LockFile()); fileConfig.ReserveStorageSpace = 1024; Assert.AreEqual(1024, legacyConfig.ReservedStorageSpace()); fileConfig.BlobPath = Path.GetTempPath(); Assert.AreEqual(Path.GetTempPath(), legacyConfig.BlobPath()); fileConfig.ReadOnly = true; Assert.IsTrue(legacyConfig.IsReadOnly()); ICacheConfigurationProvider cacheProvider = ((ICacheConfigurationProvider)Subject ()); ICacheConfiguration cache = cacheProvider.Cache; IIdSystemConfigurationProvider idSystemConfigurationProvider = ((IIdSystemConfigurationProvider )Subject()); IIdSystemConfiguration idSystemConfiguration = idSystemConfigurationProvider.IdSystem; Assert.AreEqual(StandardIdSystemFactory.Default, legacyConfig.IdSystemType()); idSystemConfiguration.UseStackedBTreeSystem(); Assert.AreEqual(StandardIdSystemFactory.StackedBtree, legacyConfig.IdSystemType() ); idSystemConfiguration.UsePointerBasedSystem(); Assert.AreEqual(StandardIdSystemFactory.PointerBased, legacyConfig.IdSystemType() ); }
private static Func <ISourceFileContext, Func <IDataRow> > GetStreamReader(this IFileConfiguration fileConfig, Interfaces.ILog logger) { switch (fileConfig.Format) { case FileFormat.Fixed: return(context => context?.BufferedRead(logger).FixedWidthReader(context, logger).ParseData(context.FileConfiguration, logger)); case FileFormat.CSV: return(context => context?.BufferedRead(logger).CsvReader(context, logger).ParseData(context.FileConfiguration, logger)); default: return(null); } }
private async Task OnStartImport(IFileConfiguration fileConfiguration) { MainView.WriteMessage("Master file", Path.GetFileName(FilePresenter.PathMasterFile)); MainView.WriteMessage("Test file", Path.GetFileName(FilePresenter.PathTestFile)); ComparisonHelper ComparisonHelper = new ComparisonHelper(FileReader, fileConfiguration); try { await Task.Run(() => ComparisonHelper.PrepareForComparison()); } catch (Exception ex) { MainView.WriteMessage("Error", ex.Message); return; } MainView.WriteMessage("Master", ComparisonHelper.MasterRowsCount.ToString()); MainView.WriteMessage("Test", ComparisonHelper.TestRowsCount.ToString()); MainView.WriteMessage("Actual diff", ComparisonHelper.ActualRowsDiff.ToString()); MainView.WriteMessage("Compared", ComparisonHelper.ComparedRowsCount.ToString()); MainView.WriteMessage("Extra", ComparisonHelper.ExtraRowsCount.ToString()); }
public void SetUp() { _excelRepository = MockRepository.GenerateMock<IRepository>(); _classGenerator = MockRepository.GenerateMock<IClassGenerator>(); _assemblyGenerator = MockRepository.GenerateMock<IAssemblyGenerator>(); _fileConfiguration = MockRepository.GenerateMock<IFileConfiguration>(); _excelToDtoMapper = new ExcelToDTOMapper(_excelRepository, _classGenerator, _assemblyGenerator, _fileConfiguration); _excelFiles = new List<string> { "TestExcel.xls" }; _workSheetNames = new List<string> { "Test1$", "Test2$" }; _classAttributes1 = new ClassAttributes("Test1"); _classAttributes2 = new ClassAttributes("Test2"); }
public void SetUp() { _excelRepository = MockRepository.GenerateMock <IRepository>(); _classGenerator = MockRepository.GenerateMock <IClassGenerator>(); _assemblyGenerator = MockRepository.GenerateMock <IAssemblyGenerator>(); _fileConfiguration = MockRepository.GenerateMock <IFileConfiguration>(); _excelToDtoMapper = new ExcelToDTOMapper(_excelRepository, _classGenerator, _assemblyGenerator, _fileConfiguration); _excelFiles = new List <string> { "TestExcel.xls" }; _workSheetNames = new List <string> { "Test1$", "Test2$" }; _classAttributes1 = new ClassAttributes("Test1"); _classAttributes2 = new ClassAttributes("Test2"); }
public void SetUp() { _users = new List <User> { new User { Id = 1, LastName = "LastName", FirstName = "FirstName" } }; Convert.ToDateTime("1/1/2009"); var autoMocker = new RhinoAutoMocker <ExcelRepository>(); _fileService = autoMocker.Get <IFileService>(); _dataProvider = autoMocker.Get <IDataProvider>(); _excelRepository = autoMocker.ClassUnderTest; _fileConfiguration = autoMocker.Get <IFileConfiguration>(); _fileConfiguration.Expect(x => x.FileName).Return(Testfile).Repeat.Any(); }
private static void RegisterDevice(IUnityContainer container, IFileConfiguration fileConfiguration) { var deviceType = fileConfiguration.GetConfig <Configs>().DeviceType; if (deviceType == DeviceType.Dk) { container.RegisterType <ICardReader, DkCardReader>(); return; } if (deviceType == DeviceType.Ts) { container.RegisterType <ICardReader, TsCardReader>(); return; } if (deviceType == DeviceType.Hs) { container.RegisterType <ICardReader, HsCardReader>(); return; } if (deviceType == DeviceType.Hx) { container.RegisterType <ICardReader, HxCardReader>(); } }
public ICodeGeneratorGenerateResult Produce(IFileConfiguration fileConfiguration) { return null;// return new CodeGeneratorGenerateResult(fileConfiguration); }
private static void Main(string[] args) { var tracingConfigurationSection = ((TracingConfigurationSection)ConfigurationManager.GetSection("tracing")); IConsoleConfiguration consoleConfiguration = tracingConfigurationSection.Console; IFileConfiguration fileElement = tracingConfigurationSection.File; var builder = TracingConfigurationBuilder.Instance // no file tracing //.WithFileTracing .WithConsoleTracing( "[{date:h:mm:ss tt}] {spanId}{spanIdFloatPadding} | {logCategory}{logCategoryPadding} | {outputData}", settings => settings .WithColorMode(ColorMode.BasedOnCategory) .WithColorsForTheBasedOnCategoryColorMode( ConsoleColor.Green, ConsoleColor.Red, ConsoleColor.Magenta, ConsoleColor.Blue) .WithOutputSpanNameOnCategory( activated: true, finished: true) .WithOutputDurationOnFinished(true) .WithDataSerialization( SetTagDataSerialization.Simple, LogDataSerialization.Json)); consoleConfiguration = builder.BuildConsoleConfiguration(); fileElement = builder.BuildFileConfiguration(); var tracer = new MockTracer() .Decorate(ColoredConsoleTracerDecorationFactory.Create(consoleConfiguration)) .Decorate(FileTracerDecorationFactory.Create(fileElement)); using (tracer.BuildSpan("test").StartActive()) { tracer.ActiveSpan.Log( new[] { new KeyValuePair <string, object>("a", "b"), new KeyValuePair <string, object>("b", "b"), new KeyValuePair <string, object>("c", "b"), new KeyValuePair <string, object>("d", "b"), }); Console.WriteLine("Inside span"); using (tracer.BuildSpan("inner") .WithTag("foo", "bar,\nhi") .StartActive()) { Console.WriteLine("Inside inner"); } List <object> selfReferencingObject = new List <object>(); selfReferencingObject.Add(selfReferencingObject); tracer.ActiveSpan.Log( new Dictionary <string, object> { [nameof(selfReferencingObject)] = selfReferencingObject }); } }
public CodeGeneratorGenerateResult(IFileConfiguration fileConfiguration) { FileConfiguration = fileConfiguration; }
public void SetUp() { _users = new List<User> { new User { Id = 1, LastName = "LastName", FirstName = "FirstName" } }; Convert.ToDateTime("1/1/2009"); var autoMocker = new RhinoAutoMocker<ExcelRepository>(); _fileService = autoMocker.Get<IFileService>(); _dataProvider = autoMocker.Get<IDataProvider>(); _excelRepository = autoMocker.ClassUnderTest; _fileConfiguration = autoMocker.Get<IFileConfiguration>(); _fileConfiguration.Expect(x => x.FileName).Return(Testfile).Repeat.Any(); }
/// <summary> /// Write the ISurface to the specified stream by using the supplied IFileConfiguration /// </summary> /// <param name="surface">ISurface</param> /// <param name="fileConfiguration">IFileConfiguration</param> /// <param name="destinationFileConfiguration">IDestinationFileConfiguration</param> public static string SaveNamedTmpFile(this ISurface surface, IFileConfiguration fileConfiguration, IDestinationFileConfiguration destinationFileConfiguration = null) { var outputSettings = surface.GenerateOutputSettings(fileConfiguration.Choose(destinationFileConfiguration)); return(ImageOutput.SaveNamedTmpFile(surface, surface.CaptureDetails, outputSettings)); }
/// <summary> /// Write the ISurface to the specified stream by using the supplied IFileConfiguration /// </summary> /// <param name="surface">ISurface</param> /// <param name="stream">Stream</param> /// <param name="fileConfiguration">IFileConfiguration</param> /// <param name="destinationFileConfiguration">IDestinationFileConfiguration</param> public static void WriteToStream(this ISurface surface, Stream stream, IFileConfiguration fileConfiguration, IDestinationFileConfiguration destinationFileConfiguration = null) { ImageOutput.SaveToStream(surface, stream, surface.GenerateOutputSettings(fileConfiguration.Choose(destinationFileConfiguration))); }
/// <summary> /// Generate a mimetype, used when uploading /// </summary> /// <param name="surface">ISurface</param> /// <param name="fileConfiguration">IFileConfiguration</param> /// <param name="destinationFileConfiguration">IDestinationFileConfiguration</param> /// <returns>image with the format</returns> public static string GenerateMimeType(this ISurface surface, IFileConfiguration fileConfiguration, IDestinationFileConfiguration destinationFileConfiguration = null) { return("image/" + fileConfiguration.Choose(destinationFileConfiguration).OutputFileFormat); }
/// <summary> /// Generate a filename /// </summary> /// <param name="surface">ISurface</param> /// <param name="fileConfiguration">IFileConfiguration</param> /// <param name="destinationFileConfiguration">IDestinationFileConfiguration</param> /// <returns>Filename</returns> public static string GenerateFilename(this ISurface surface, IFileConfiguration fileConfiguration, IDestinationFileConfiguration destinationFileConfiguration = null) { var selectedFileConfiguration = fileConfiguration.Choose(destinationFileConfiguration); return(Path.GetFileName(FilenameHelper.GetFilenameFromPattern(selectedFileConfiguration.OutputFileFilenamePattern, selectedFileConfiguration.OutputFileFormat, surface.CaptureDetails))); }
private static Func <string> GetMetadataBuilder(this IFileConfiguration fileConfig) { if (!(fileConfig.Rows?.Count > 0)) { throw new ArgumentOutOfRangeException(Localization.GetLocalizationString("Missing row configuration")); } if (fileConfig.Rows.Count > 1) { throw new ArgumentOutOfRangeException( Localization.GetLocalizationString("Wave analytics does not support csv with variable rows")); } if (!(fileConfig.Rows[0].Columns?.Count > 0)) { throw new ArgumentOutOfRangeException(Localization.GetLocalizationString("Missing columns configuration")); } var xmd = new XMD(); xmd.FileFormat = new XMD.XMDFileFormat { CharsetName = "UTF-8", FieldsDelimitedBy = ",", FieldsEnclosedBy = "\"", NumberOfLinesToIgnore = 0 }; xmd.Objects = new List <XMD.XMDObject> { new XMD.XMDObject { FullyQualifiedName = fileConfig.Name.Replace(" ", "_"), Label = fileConfig.Name, Name = fileConfig.Name.Replace(" ", "_"), Fields = fileConfig.Rows[0].Columns.Select(c => { var field = new XMD.XMDField(); switch (c.Type) { case ColumnType.Date: field.Type = XMD.XMDFieldType.Date; break; case ColumnType.Decimal: case ColumnType.Integer: case ColumnType.Money: field.Type = XMD.XMDFieldType.Numeric; break; default: field.Type = XMD.XMDFieldType.Text; break; } field.Name = (c.Alias ?? c.Name).Replace(" ", "_"); field.FullyQualifiedName = fileConfig.Name.Replace(" ", "_") + "." + field.Name; field.Label = field.Name; field.Description = c.Description; if (field.Type == XMD.XMDFieldType.Numeric) { field.DefaultValue = "0"; field.Precision = 18; field.Scale = 2; } if (field.Type == XMD.XMDFieldType.Date) { field.Format = c.Format ?? "yyyy-MM-dd HH:mm:ss"; } return(field); }).ToList() } }; var xmdStr = JsonConvert.SerializeObject(xmd, new JsonSerializerSettings { NullValueHandling = NullValueHandling.Ignore }); return(() => xmdStr); }
public OleDbDataProvider(IConnectionBuilder connectionBuilder, IFileConfiguration fileConfiguration) { _connectionBuilder = connectionBuilder; _fileConfiguration = fileConfiguration; }
private void PrepareHost(IFileConfiguration fileConfig, ICommonConfiguration commonConfig , IList classesNotFound) { fileConfig.Storage = _storage; PrepareCommon(commonConfig, classesNotFound); }
private static async Task <Func <MemoryStream, bool, int> > GetDataSenderFunc(this IFileMedia fileMedia, IFileConfiguration fileConfig, Interfaces.ILog log) { var chunkNumber = 0; var queue = new ConcurrentQueue <MemoryStream>(); var isFinalizing = false; var uploader = await fileMedia.GetDataChunkUploader(fileConfig, log); var senderTask = new Task(() => { while (true) { while (queue.TryDequeue(out var nextChunk)) { try { chunkNumber = uploader(nextChunk, isFinalizing && queue.IsEmpty); } catch { log.Fatal(Localization.GetLocalizationString("Upload has terminated")); return; } } if (isFinalizing && queue.IsEmpty) { return; } Thread.Sleep(100); } }); senderTask.Start(); return((stream, finalize) => { if (stream != null) { queue.Enqueue(stream); while (queue.Count > 3) { Thread.Sleep(50); } } isFinalizing = finalize; if (isFinalizing) { log.Info(Localization.GetLocalizationString("Awaiting for upload to finish.")); senderTask.Wait(); } return chunkNumber; }); }
public TvWinViewModel(IFileConfiguration fileConfiguration) { _fileConfiguration = fileConfiguration; LoadCommand = new RelayCommand <ChromiumWebBrowser>(ExcuteLoadCommand); CloseCommand = new RelayCommand(ExcuteCloseCommand); }
public SurfaceOutputSettings(IFileConfiguration fileConfiguration) : this(fileConfiguration.OutputFileFormat, fileConfiguration.OutputFileJpegQuality, fileConfiguration.OutputFileReduceColors) { }
/// <summary> /// Create OutputSettings /// </summary> /// <param name="surface">ISurface</param> /// <param name="fileConfiguration">IFileConfiguration</param> /// <param name="destinationFileConfiguration">IDestinationFileConfiguration</param> /// <returns>SurfaceOutputSettings</returns> public static SurfaceOutputSettings GenerateOutputSettings(this ISurface surface, IFileConfiguration fileConfiguration, IDestinationFileConfiguration destinationFileConfiguration = null) { return(new SurfaceOutputSettings(fileConfiguration.Choose(destinationFileConfiguration))); }