public CovidDataManager()
{
string path = System.IO.Directory.GetCurrentDirectory() + "\\sources.json";
externalSources = new List <AddedExternalSource>();
if (System.IO.File.Exists(path))
{
string json = System.IO.File.ReadAllText(path);
externalSources.AddRange(new List <AddedExternalSource>().FromJson(json));
}
CsvConfiguration config = new CsvConfiguration(new CultureInfo("en-US", false));
config.HasHeaderRecord = true;
config.IgnoreQuotes = false;
config.IgnoreBlankLines = true;
config.HeaderValidated = null;
config.MissingFieldFound = null;
config.BadDataFound = null;
config.RegisterClassMap <HopkinsDataClassMap>();
config.RegisterClassMap <CovidGermanyStateClassMap>();
config.RegisterClassMap <WhoClassMap>();
config.AutoMap <CovidBrazilStates>();
config.AutoMap <CovidUSStates>();
config.AutoMap <RKIGeneral>();
config.AutoMap <RKILandkreis>();
csvConfig = config;
UpdateData();
hopkinsData = new List <HopkinsData>();
UpdateHopkinsAndWHO();
}
public void Apply(CsvConfiguration config)
{
// see http://joshclose.github.io/CsvHelper/
config.RegisterClassMap <RecordMap>();
config.RegisterClassMap <MetadataMap>();
}
public void Apply(CsvConfiguration config)
{
config.Delimiter = "\t";
config.QuoteAllFields = true;
config.TrimFields = true;
config.RegisterClassMap <RecordMap>();
config.RegisterClassMap <GeminiMap>();
}
public void Apply(CsvConfiguration config)
{
config.RegisterClassMap<MarineRecorderMapping.RecordMap>();
config.RegisterClassMap<MarineRecorderMapping.GeminiMap>();
config.WillThrowOnMissingField = false;
config.TrimFields = true;
}
public void Apply(CsvConfiguration config)
{
// see http://joshclose.github.io/CsvHelper/
config.TrimFields = true;
config.RegisterClassMap <RecordMap>();
config.RegisterClassMap <GeminiMap>();
}
public void Apply(CsvConfiguration config)
{
config.Delimiter = "\t";
config.RegisterClassMap <MyRecordMap>();
config.RegisterClassMap <MyMetadataMap>();
TypeConverterFactory.AddConverter <List <MetadataKeyword> >(new Exporter.MetadataKeywordConverter());
TypeConverterFactory.AddConverter <List <Extent> >(new Exporter.ExtentListConverter());
}
public void MapMultipleTypesTest()
{
var config = new CsvConfiguration();
config.RegisterClassMap <AMap>();
config.RegisterClassMap <BMap>();
Assert.IsNotNull(config.Maps[typeof(A)]);
Assert.IsNotNull(config.Maps[typeof(B)]);
}
public void Apply(CsvConfiguration config)
{
// see http://joshclose.github.io/CsvHelper/
config.Delimiter = "\t";
config.QuoteAllFields = true;
config.TrimFields = true;
config.SkipEmptyRecords = true;
config.RegisterClassMap <RecordMap>();
config.RegisterClassMap <GeminiMap>();
}
public void Apply(CsvConfiguration config)
{
config.PrefixReferenceHeaders = true;
// TypeConverterFactory.AddConverter<List<MetadataKeyword>>(new Exporter.MetadataKeywordConverter());
// TypeConverterFactory.AddConverter<List<Extent>>(new Exporter.ExtentListConverter());
config.RegisterClassMap <RecordMap>();
config.RegisterClassMap <GeminiMap>();
// there's no id field because they deleted it
config.WillThrowOnMissingField = false;
}
private void config <T>(CsvConfiguration csvConfig, Configuracao config)
{
config = config == null ? new Configuracao() : config;
csvConfig.Delimiter = config.Delimitador;
csvConfig.IgnoreHeaderWhiteSpace = config.IgnoreEspacoEmBrancoHeader;
csvConfig.TrimFields = config.RemoverEspacoEmBrancoCampos;
if (config.Map.Count > 0)
{
var customerMap = new CsvHelper.Configuration.DefaultCsvClassMap <T>();
var sampleObject = Activator.CreateInstance <T>();
foreach (var map in config.Map)
{
var propertyInfo = sampleObject.GetType().GetProperty(map.NomeDaPropriedade);
var newMap = new CsvPropertyMap(propertyInfo);
newMap.Name(map.NomeDaColuna);
if (map.Converter != null)
{
newMap.ConvertUsing(
row => map.Converter.Conversao(row.GetField <string>(map.Converter.NomeDaColuna))
);
}
customerMap.PropertyMaps.Add(newMap);
}
csvConfig.RegisterClassMap(customerMap);
}
}
private IEnumerable <ILexOfficeRecord> LexOfficeRecords(IFormFile file, ISettings settings)
{
var config = new CsvConfiguration(CultureInfo.DefaultThreadCurrentCulture)
{
Delimiter = ",",
Encoding = System.Text.Encoding.UTF8,
HasHeaderRecord = true
};
config.RegisterClassMap(new RevolutMap());
if (file.Length <= 0)
{
yield break;
}
var filePath = Path.GetTempFileName();
using (var stream = System.IO.File.Create(filePath))
{
using var reader = new StreamReader(file.OpenReadStream());
using var csv = new CsvReader(reader, config);
var result = csv.GetRecords <RevolutRecord>();
foreach (var record in result)
{
yield return(new LexOfficeRecordFromRevolutRecord(settings, record));
}
}
}
private static void WriteConvertedFile(CsvConfiguration config, string fileName, Settings settings, string targetFileName)
{
var file = File.OpenRead(fileName);
config.RegisterClassMap(new RevolutMap());
if (file.Length > 0)
{
using (var targetFile = System.IO.File.Create(targetFileName))
{
using (var reader = new StreamReader(file, true))
using (var csv = new CsvReader(reader, config))
{
var result = csv.GetRecords <RevolutRecord>();
foreach (var record in result)
{
targetFile.Write(
System.Text.Encoding.UTF8.GetBytes(
new LexOfficeCsvLine(
new LexOfficeRecordFromRevolutRecord(settings, record)
).ToString() + "\r\n"
)
);
}
}
}
System.Console.WriteLine($"Wrote to file: {targetFileName}");
}
}
private static CsvConfiguration GetCsvConfig()
{
var config = new CsvConfiguration();
config.RegisterClassMap <CsvItemClassMap>();
return(config);
}
public static void RegisterClassMapCollection(this CsvConfiguration csvConfiguration, Assembly assembly)
{
assembly.GetTypes()
.Where(t => t.Name.EndsWith("Map") || t.IsSubclassOf(typeof(ClassMap)))
.ToList()
.ForEach(t => csvConfiguration.RegisterClassMap(t));
}
public string WriteRecords(List <T> records, bool hasHeader, ClassMap <T> classMap, string delimiter, bool shouldQuote)
{
var contents = string.Empty;
var config = new CsvConfiguration(CultureInfo.CurrentCulture)
{
HasHeaderRecord = hasHeader,
TrimOptions = TrimOptions.Trim,
Delimiter = delimiter,
ShouldQuote = (field, context) => shouldQuote,
};
if (classMap != null)
{
config.RegisterClassMap(classMap);
}
using (var stream = new MemoryStream())
using (var reader = new StreamReader(stream))
using (var writer = new StreamWriter(stream))
using (var csv = new CsvWriter(writer, config))
{
csv.WriteRecords(records);
writer.Flush();
stream.Position = 0;
contents = reader.ReadToEnd();
}
return(contents);
}
/// <summary>
/// Builds the product category loader tasks.
/// </summary>
/// <returns>A task used to load the product category table.</returns>
private ITask BuildProductCategoryTask()
{
using (var builder = new SimpleDataflowBuilder <ProductCategory>())
{
var categoryFile = Path.Combine(Program.Options.SourcePath, "ProductCategory.csv");
var csvConfiguration = new CsvConfiguration {
HasHeaderRecord = false, Delimiter = "\t"
};
csvConfiguration.RegisterClassMap <ProductCategoryFileMap>();
return(builder
.CsvSource(categoryFile, csvConfiguration)
.BulkLoad(
"dbo.DimProductCategory",
this.targetFactory,
new Dictionary <string, string>()
{
{ "AlternateKey", "ProductCategoryAlternateKey" },
{ "Name", "EnglishProductCategoryName" },
{ "SpanishName", "SpanishProductCategoryName" },
{ "FrenchName", "FrenchProductCategoryName" }
})
.Build("Load product category dimension"));
}
}
/// <summary>
/// Builds the product loader tasks.
/// </summary>
/// <returns>A task used to load the product subcategory table.</returns>
private ITask BuildProductTask()
{
using (var builder = new SimpleDataflowBuilder <Product>())
{
var productFile = Path.Combine(Program.Options.SourcePath, "Product.csv");
var csvConfiguration = new CsvConfiguration {
HasHeaderRecord = false, Delimiter = "\t"
};
csvConfiguration.RegisterClassMap <ProductFileMap>();
return(builder
.CsvSource(productFile, csvConfiguration)
.Map(x =>
{
x.ProductSubcategoryKey =
this.productSubcategoryMapper.Map(
x.ProductSubcategoryAlternateKey.ToString(CultureInfo.CurrentCulture));
return x;
})
.BulkLoad(
"dbo.DimProduct",
this.targetFactory,
new Dictionary <string, string>()
{
{ "ProductSubcategoryKey", "ProductSubcategoryKey" },
{ "AlternateKey", "ProductAlternateKey" },
{ "Name", "EnglishProductName" },
})
.Build("Load product dimension"));
}
}
public Repository(string musicContractsPath, string distributionContractsPath)
{
Check <FileNotFoundException>(File.Exists(Path.GetFullPath(musicContractsPath)), $"File doesn't exist or incorrect path: {musicContractsPath}");
Check <FileNotFoundException>(File.Exists(Path.GetFullPath(distributionContractsPath)), $"File doesn't exist or incorrect path: {distributionContractsPath}");
_distributionContractsPath = distributionContractsPath;
_musicContractsPath = musicContractsPath;
_csvConfig = new CsvConfiguration
{
Delimiter = "|",
HasHeaderRecord = true
};
_csvConfig.RegisterClassMap <MusicContractMap>();
_csvConfig.RegisterClassMap <DistributionContractMap>();
}
public void WriteFieldTrimTest()
{
var record = new TestRecord
{
IntColumn = 1,
DateColumn = new DateTime(2012, 10, 1, 12, 12, 12),
DecimalColumn = 150.99m,
FirstColumn = "first column ",
};
var config = new CsvConfiguration {
CultureInfo = new CultureInfo("en-US"), TrimFields = true
};
config.RegisterClassMap <TestRecordMap>();
var stream = new MemoryStream();
var writer = new StreamWriter(stream)
{
AutoFlush = true
};
var csv = new CsvWriter(writer, config);
csv.WriteRecord(record);
csv.NextRecord();
stream.Position = 0;
var reader = new StreamReader(stream);
var csvFile = reader.ReadToEnd();
var expected = "first column,0001,10/1/2012,$150.99\r\n";
Assert.AreEqual(expected, csvFile);
}
/// <summary>
/// Returns records of a IMDb CSV rating or list file.
/// </summary>
/// <typeparam name="T">IMDbListItem or IMDbRateItem</typeparam>
/// <param name="aFileStreamReader">CSV file stream reader</param>
/// <returns>Records of type T</returns>
private List <T> ParseCsvFile <T>(StreamReader aFileStreamReader)
{
CsvConfiguration csvConfiguration = new CsvConfiguration
{
IsHeaderCaseSensitive = false,
// IMDb use "." for decimal seperator so set culture to cater for this
CultureInfo = new System.Globalization.CultureInfo("en-US"),
// if we're unable parse a row, log the details for analysis
IgnoreReadingExceptions = true,
ReadingExceptionCallback = (ex, row) =>
{
FileLog.Error($"Error reading row '{ex.Data["CsvHelper"]}'");
}
};
csvConfiguration.RegisterClassMap <IMDbListCsvMap>();
using (var csv = new CsvReader(aFileStreamReader, csvConfiguration))
{
List <T> records = csv.GetRecords <T>().ToList();
aFileStreamReader.Close();
return(records);
}
}
static void Main(string[] args)
{
var content = File.ReadAllText("..\\..\\..\\kusovkymagic.csv");
// konfigurace cteni CSV
var configuration = new CsvConfiguration(CultureInfo.InvariantCulture)
{
IncludePrivateMembers = false,
Delimiter = ";",
HasHeaderRecord = true,
Escape = '"',
};
configuration.RegisterClassMap <KusovkaMapper>();
configuration.BadDataFound = x =>
{
Console.Write($"- bad data: '{x.RawRecord}'");
};
configuration.MissingFieldFound = (headerNames, index, x) =>
{
Console.Write($"- field at index '{index}' was not found in: '{x.RawRecord}'.");
};
using (var textReader = new StringReader(content))
using (var stringReader = new EscapeToDoubleQuoteReader(textReader))
using (var parser = new CsvReader(stringReader, configuration))
{
var res = parser.GetRecords <ImportKusovka>().ToList();
Console.Write($"READ: {res.Count} records of '{typeof(ImportKusovka).Name}'");
}
}
/// <summary>
/// The open file.
/// </summary>
public void OpenFile()
{
try
{
var dataStream = new StreamReader(File.Open(this.fileName, FileMode.Open));
var csvConfiguration = new CsvConfiguration {
HasHeaderRecord = true
};
csvConfiguration.RegisterClassMap <ValueMap>();
var csv = new CsvReader(dataStream, csvConfiguration);
this.data = csv.GetRecords <ValueDataRow>().ToList();
this.StatNames = this.data.Select(x => x.Statistic).Distinct().Select(
x =>
{
var matching = this.Stats.Where(s => s.Description == x).ToList();
if (matching.Count() == 1)
{
return(new ImporterStatisticMapping(matching.First(), x));
}
return(new ImporterStatisticMapping(x));
});
this.Stage = 1;
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
public async Task <List <T> > ReadRecords <T>(IS3Path path, Func <T, bool> predicate, bool isOptional = false)
{
_logger.Information("Reading {Type} records from {@S3Path}", typeof(T).Name, path);
var configuration = new CsvConfiguration
{
Delimiter = "|",
QuoteNoFields = true,
HasHeaderRecord = true
};
var customerMap = new DefaultCsvClassMap <T>();
foreach (var prop in typeof(T).GetProperties())
{
var name = prop.Name.ToSnakeCase();
var map = new CsvPropertyMap(prop).Name(name);
customerMap.PropertyMaps.Add(map);
}
configuration.RegisterClassMap(customerMap);
try
{
using (var response = await _s3Client.GetObjectAsync(new GetObjectRequest {
BucketName = path.BucketName, Key = path.Key
}))
{
using (var responseStream = response.ResponseStream)
{
using (var streamReader = new StreamReader(responseStream))
{
using (var reader = new CsvReader(streamReader, configuration))
{
var results = reader.GetRecords <T>();
if (predicate != null)
{
results = results.Where(predicate);
}
return(results.ToList());
}
}
}
}
}
catch (AmazonS3Exception ex)
{
if (ex.ErrorCode == "NoSuchKey" && isOptional)
{
return(new List <T>());
}
throw;
}
catch (Exception e)
{
_logger.Fatal("Exception when trying to read csv file: {@Message}", e.Message);
throw;
}
}
public void RegisterClassMapNonGenericTest()
{
var config = new CsvConfiguration();
Assert.IsNull(config.Maps[typeof(TestClass)]);
config.RegisterClassMap(typeof(TestClassMappings));
Assert.IsNotNull(config.Maps[typeof(TestClass)]);
}
public void AddingMappingsWithInstanceMethodTest()
{
var config = new CsvConfiguration();
config.RegisterClassMap(new TestClassMappings());
Assert.AreEqual(2, config.Maps[typeof(TestClass)].PropertyMaps.Count);
}
public void AddingMappingsWithGenericMethod2Test()
{
var config = new CsvConfiguration();
config.RegisterClassMap <TestClassMappings>();
Assert.AreEqual(2, config.Maps[typeof(TestClass)].PropertyMaps.Count);
}
public void RegisterClassInstanceTest()
{
var config = new CsvConfiguration();
Assert.IsNull(config.Maps[typeof(TestClass)]);
config.RegisterClassMap(new TestClassMappings());
Assert.IsNotNull(config.Maps[typeof(TestClass)]);
}
public void PropertyMapAccessTest()
{
var config = new CsvConfiguration();
config.RegisterClassMap <AMap>();
config.Maps.Find <A>().Map(m => m.AId).Ignore();
Assert.AreEqual(true, config.Maps[typeof(A)].PropertyMaps[0].Data.Ignore);
}
public DataImportClient()
{
/*
* groups = fields.GroupBy(
* f => f.Substring(
* 0, f.IndexOf('.')
* ), f => f.Remove(
* 0, f.IndexOf('.') + 1
* )
* ).Select(g => new Group(
* g.Key, g.ToArray()
* )).OrderBy(g => g.prefix).ToArray();*/
cfg = new CsvConfiguration();
cfg.Delimiter = "\t";
cfg.DetectColumnCountChanges = true;
cfg.TrimFields = true;
//cfg.RegisterClassMap(typeof(Group));
csvMapping = (Lookup <string, Lookup <string, string> >)fields.ToLookup(
f => f.Substring(0, f.IndexOf('.')),
f => (Lookup <string, string>)Enumerable
.Empty <string>().ToLookup(
p => f.Remove(
0, f.IndexOf('.'))));
/* var csvMap = new DefaultCsvClassMap<Lookup<string, string>>();
* foreach(var group in csvMapping)
* {
* foreach(var subgroup in group)
* {
* foreach(var item in subgroup)
* {
* var newMap = new CsvPropertyMap(
* typeof(IGrouping<string, string>).GetType().GetProperty(item.Key)
* );
* }
* }
* }*/
fileFormatMap = new DefaultCsvClassMap <FileFormatSkeleton>();
Type ffs = typeof(FileFormatSkeleton);
ffsFields = ffs.GetFields(BindingFlags.SetProperty).ToDictionary(f => f.Name, f => f);
var fieldNames = fields.Select(f => new KeyValuePair <string, string>(f, f.Replace('.', '_')));
foreach (var field in fieldNames)
{
var newMap = new CsvPropertyMap(
ffs.GetProperty(field.Value));
newMap.Name(field.Key);
fileFormatMap.PropertyMaps.Add(newMap);
}
cfg.RegisterClassMap(fileFormatMap);
}
public OpcConfigurationCsvReader(string configFileName)
{
this.configFileName = configFileName;
csvConfiguration = new CsvConfiguration();
csvConfiguration.RegisterClassMap <CsvConfigurationRecordMapper>();
csvConfiguration.IgnoreBlankLines = true;
csvConfiguration.IgnoreHeaderWhiteSpace = true;
csvConfiguration.IsHeaderCaseSensitive = false;
}
public Fact[] Read(string message)
{
var csvConfig = new CsvConfiguration
{
Delimiter = "|",
Encoding = Encoding.UTF8,
HasHeaderRecord = true,
};
csvConfig.RegisterClassMap<FactMap>();
csvConfig.CultureInfo = CultureInfo.InvariantCulture;
using (var reader = new StringReader(message))
using (var parser = new CsvHelper.CsvReader(reader, csvConfig))
{
return parser.GetRecords<Fact>().ToArray();
}
}
/// <summary>
/// Builds a task to load the currency dimension.
/// </summary>
/// <returns>A task for loading the currency dimension.</returns>
public ITask Build()
{
using (var builder = new SimpleDataflowBuilder<Currency>())
{
var currencyFile = Path.Combine(Program.Options.SourcePath, "currency.csv");
var csvConfiguration = new CsvConfiguration { HasHeaderRecord = false, Delimiter = "\t" };
csvConfiguration.RegisterClassMap<CurrencyFileMap>();
return builder
.CsvSource(currencyFile, csvConfiguration)
.BulkLoad(
"dbo.DimCurrency",
this.targetFactory,
new Dictionary<string, string>()
{
{ "AlternateKey", "CurrencyAlternateKey" },
{ "Name", "CurrencyName" }
})
.Build("Load currency dimension");
}
}
/// <summary>
/// Builds the product category loader tasks.
/// </summary>
/// <returns>A task used to load the product category table.</returns>
private ITask BuildProductCategoryTask()
{
using (var builder = new SimpleDataflowBuilder<ProductCategory>())
{
var categoryFile = Path.Combine(Program.Options.SourcePath, "ProductCategory.csv");
var csvConfiguration = new CsvConfiguration { HasHeaderRecord = false, Delimiter = "\t" };
csvConfiguration.RegisterClassMap<ProductCategoryFileMap>();
return builder
.CsvSource(categoryFile, csvConfiguration)
.BulkLoad(
"dbo.DimProductCategory",
this.targetFactory,
new Dictionary<string, string>()
{
{ "AlternateKey", "ProductCategoryAlternateKey" },
{ "Name", "EnglishProductCategoryName" },
{ "SpanishName", "SpanishProductCategoryName" },
{ "FrenchName", "FrenchProductCategoryName" }
})
.Build("Load product category dimension");
}
}
// Import des raws
private ICollection<OperationRawSG> ExtraireRaws(StreamReader streamReader, IList<string> _erreurs)
{
/* A new configuration instance that you can change at will */
CsvConfiguration config = new CsvConfiguration();
config.Delimiter = ";";
config.RegisterClassMap<SGOperationRawMapClass>();
/* Give it to your CsvReader */
CsvReader csvReader = new CsvReader(streamReader, config);
IEnumerable<OperationRawSG> _raws = new List<OperationRawSG>();
try
{
_raws = csvReader.GetRecords<OperationRawSG>().Reverse().ToList();
foreach (var item in _raws)
{
item.Etat = EtatOperationRaw.CREEE;
item.Libelle = this.Egaliser(item.Libelle);
item.Detail = this.Egaliser(item.Detail);
}
}
catch (Exception e)
{
var message = "Les écritures du fichier importé ne semblent pas correctement formattées. Etês-vous certain de charger un fichier Société générale ?";
_erreurs.Add(message);
var message2 = e.Message;
_erreurs.Add(message2);
}
// return
return _raws.ToList();
}
/// <summary>
/// Builds the product loader tasks.
/// </summary>
/// <returns>A task used to load the product subcategory table.</returns>
private ITask BuildProductTask()
{
using (var builder = new SimpleDataflowBuilder<Product>())
{
var productFile = Path.Combine(Program.Options.SourcePath, "Product.csv");
var csvConfiguration = new CsvConfiguration { HasHeaderRecord = false, Delimiter = "\t" };
csvConfiguration.RegisterClassMap<ProductFileMap>();
return builder
.CsvSource(productFile, csvConfiguration)
.Map(x =>
{
x.ProductSubcategoryKey =
this.productSubcategoryMapper.Map(
x.ProductSubcategoryAlternateKey.ToString(CultureInfo.CurrentCulture));
return x;
})
.BulkLoad(
"dbo.DimProduct",
this.targetFactory,
new Dictionary<string, string>()
{
{ "ProductSubcategoryKey", "ProductSubcategoryKey" },
{ "AlternateKey", "ProductAlternateKey" },
{ "Name", "EnglishProductName" },
})
.Build("Load product dimension");
}
}
private void OnCommandExportContent(object sender, EventArgs e) {
// Export to CSV
IDataMigrationView view = base._view as IDataMigrationView;
IDataMigrationModel model = base._model as IDataMigrationModel;
PresenterBase.SetModelPropertiesFromView<IDataMigrationModel, IDataMigrationView>(
ref model, view
);
IMainPresenter presenter = SimpleResolver.Instance.Get<IMainPresenter>();
try {
if (SyncContext != null) {
SyncContext.Post(delegate {
presenter.EnableControl(false);
presenter.ActivateSpinner(true);
presenter.UpdateProgressInfo("Preparing Report...");
}, null);
}
FileInfo fileInfo = new FileInfo(model.OutputFileName);
if (Directory.Exists(fileInfo.DirectoryName)) {
Thread writeReport = new Thread(() => {
CsvConfiguration config = new CsvConfiguration() {
HasHeaderRecord = true,
Delimiter = ",",
Encoding = System.Text.Encoding.UTF8
};
config.RegisterClassMap(new DataMigrationHeaderMap());
int total = model.Contents.Count;
using (CsvWriter writer = new CsvWriter(new StreamWriter(model.OutputFileName), config)) {
writer.WriteHeader<DataMigrationHeaderRecord>();
for (int i = 0; i < model.Contents.Count; i++) {
ContentDisplayListViewItemModel lvItem = model.Contents[i];
writer.WriteField<string>(!string.IsNullOrEmpty(lvItem.OwnerName) ? lvItem.OwnerName : "");
writer.WriteField<string>(lvItem.Email);
writer.WriteField<string>(lvItem.ItemPathDisplay);
writer.WriteField<string>(!string.IsNullOrEmpty(lvItem.ItemPathId) ? lvItem.ItemPathId : "");
writer.WriteField<string>(lvItem.ItemName);
writer.WriteField<string>(!string.IsNullOrEmpty(lvItem.ItemId) ? lvItem.ItemId : "");
writer.WriteField<string>(lvItem.ItemType);
writer.WriteField<string>(!string.IsNullOrEmpty(lvItem.ItemSize) ? lvItem.ItemSize : "");
writer.WriteField<string>(!string.IsNullOrEmpty(lvItem.Created) ? lvItem.Created : "");
writer.WriteField<string>(!string.IsNullOrEmpty(lvItem.LastModified) ? lvItem.LastModified : "");
writer.WriteField<string>(!string.IsNullOrEmpty(lvItem.Uploaded) ? lvItem.Uploaded : "");
writer.NextRecord();
if (SyncContext != null) {
SyncContext.Post(delegate {
presenter.UpdateProgressInfo(string.Format("Writing Record: {0}/{1}", (i + 1), total));
}, null);
}
}
}
if (SyncContext != null) {
SyncContext.Post(delegate {
presenter.EnableControl(true);
presenter.ActivateSpinner(false);
presenter.UpdateProgressInfo("Completed");
}, null);
}
});
writeReport.Start();
} else {
throw new InvalidDataException(ErrorMessages.INVALID_EXPORT_FOLDER);
}
} catch (Exception ex) {
if (SyncContext != null) {
SyncContext.Post(delegate {
presenter.EnableControl(true);
presenter.ActivateSpinner(false);
presenter.UpdateProgressInfo("Completed with exception: " + ex.Message);
}, null);
}
}
}