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();
}
}
public ExcelToDTOMapper(IRepository excelRepository, IClassGenerator classGenerator, IAssemblyGenerator assemblyGenerator, IFileConfiguration fileConfiguration)
{
_excelRepository = excelRepository;
_classGenerator = classGenerator;
_assemblyGenerator = assemblyGenerator;
_fileConfiguration = fileConfiguration;
}
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);
}
private void PrepareHost(IFileConfiguration fileConfig, ICommonConfiguration commonConfig
, IList classesNotFound)
{
fileConfig.Storage = _storage;
PrepareCommon(commonConfig, classesNotFound);
}
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)));
}
