public void WeirdDateTimeTest_TypeProviderBased()
{
var typeConverterProvider = new TypeConverterProvider()
.Override(new DateTimeConverter("yyyy###MM###dd"));
CsvParserOptions csvParserOptions = new CsvParserOptions(true, new[] { ';' });
CsvReaderOptions csvReaderOptions = new CsvReaderOptions(new[] { Environment.NewLine });
CsvPersonMappingWithTypeConverterProvider csvMapper = new CsvPersonMappingWithTypeConverterProvider(typeConverterProvider);
CsvParser <Person> csvParser = new CsvParser <Person>(csvParserOptions, csvMapper);
var stringBuilder = new StringBuilder()
.AppendLine("FirstName;LastName;BirthDate")
.AppendLine("Philipp;Wagner;1986###05###12");
var result = csvParser
.ReadFromString(csvReaderOptions, stringBuilder.ToString())
.ToList();
Assert.AreEqual("Philipp", result[0].Result.FirstName);
Assert.AreEqual("Wagner", result[0].Result.LastName);
Assert.AreEqual(1986, result[0].Result.BirthDate.Year);
Assert.AreEqual(5, result[0].Result.BirthDate.Month);
Assert.AreEqual(12, result[0].Result.BirthDate.Day);
}
public void FloatArraysTest()
{
CsvParserOptions csvParserOptions = new CsvParserOptions(false, ';');
CsvReaderOptions csvReaderOptions = new CsvReaderOptions(new[] { Environment.NewLine });
CsvMeasurementMapping csvMapper = new CsvMeasurementMapping();
CsvParser <Measurement> csvParser = new CsvParser <Measurement>(csvParserOptions, csvMapper);
var stringBuilder = new StringBuilder()
.AppendLine("Device1;1.0;2.0")
.AppendLine("Device2;3.0;4.0");
var result = csvParser
.ReadFromString(csvReaderOptions, stringBuilder.ToString())
.ToList();
Assert.AreEqual(2, result.Count);
Assert.IsTrue(result.All(x => x.IsValid));
Assert.AreEqual("Device1", result[0].Result.Id);
Assert.IsNotNull(result[0].Result.Values);
Assert.AreEqual(2, result[0].Result.Values.Length);
Assert.AreEqual(1.0, result[0].Result.Values[0]);
Assert.AreEqual(2.0, result[0].Result.Values[1]);
Assert.AreEqual("Device2", result[1].Result.Id);
Assert.IsNotNull(result[1].Result.Values);
Assert.AreEqual(2, result[1].Result.Values.Length);
Assert.AreEqual(3.0, result[1].Result.Values[0]);
Assert.AreEqual(4.0, result[1].Result.Values[1]);
}
/// <summary>
/// Médoto que lee el archivo CSV y lo baja a un objeto del tipo lista
/// </summary>
/// <param name="fileName"></param>
/// <returns></returns>
public async Task <List <StockCsv> > ReadCsv()
{
var response = new List <StockCsv>();
try
{
//Creamos el objeto para el procesamiento del archivo CSV
CsvParserOptions csvParserOptions = new CsvParserOptions(true, ';');
//Obtenemos el directorio local donde se descargará el archivo .CSV
string localDirectoryPath = configuration["LocalDirectoryPath"];
//Creamos el path final donde se guardará el archivo .CSV descargado
string localFilePath = string.Format("{0}\\{1}", localDirectoryPath, FileName);
//Creamos el mapeo de la entidad donde bajaremos la información del CSV
var csvParser = new CsvParser <StockCsv>(csvParserOptions, new StockMapping());
//Leemos el archivo
var records = csvParser.ReadFromFile(localFilePath, Encoding.UTF8).ToList();
//Regresamos el listado de los registros leidos del archivo
return(records.Select(x => x.Result).ToList());
}
catch (Exception ex)
{
}
return(response);
}
public void MapUsingTest()
{
CsvParserOptions csvParserOptions = new CsvParserOptions(false, ';');
CsvReaderOptions csvReaderOptions = new CsvReaderOptions(new[] { Environment.NewLine });
CsvMainClassMapping csvMapper = new CsvMainClassMapping();
CsvParser <MainClass> csvParser = new CsvParser <MainClass>(csvParserOptions, csvMapper);
var stringBuilder = new StringBuilder()
.AppendLine("X;Y;Z")
.AppendLine("A;B;C");
var result = csvParser
.ReadFromString(csvReaderOptions, stringBuilder.ToString())
.ToList();
Assert.AreEqual(2, result.Count);
Assert.IsFalse(result[0].IsValid);
Assert.IsTrue(result[1].IsValid);
Assert.AreEqual("A", result[1].Result.Property1);
Assert.IsNotNull(result[1].Result.SubClass);
Assert.AreEqual("B", result[1].Result.SubClass.Property2);
Assert.AreEqual("C", result[1].Result.SubClass.Property3);
}
public void SkipHeaderTest()
{
CsvParserOptions csvParserOptions = new CsvParserOptions(true, new[] { ';' });
CsvReaderOptions csvReaderOptions = new CsvReaderOptions(new[] { Environment.NewLine });
CsvPersonMapping csvMapper = new CsvPersonMapping();
CsvParser <Person> csvParser = new CsvParser <Person>(csvParserOptions, csvMapper);
var stringBuilder = new StringBuilder()
.AppendLine("FirstName;LastName;BirthDate")
.AppendLine("Philipp;Wagner;1986/05/12")
.AppendLine("Max;Mustermann;2014/01/01");
var result = csvParser
.ReadFromString(csvReaderOptions, stringBuilder.ToString())
.ToList();
Assert.AreEqual(2, result.Count);
Assert.IsTrue(result.All(x => x.IsValid));
Assert.AreEqual("Philipp", result[0].Result.FirstName);
Assert.AreEqual("Wagner", result[0].Result.LastName);
Assert.AreEqual(1986, result[0].Result.BirthDate.Year);
Assert.AreEqual(5, result[0].Result.BirthDate.Month);
Assert.AreEqual(12, result[0].Result.BirthDate.Day);
Assert.AreEqual("Max", result[1].Result.FirstName);
Assert.AreEqual("Mustermann", result[1].Result.LastName);
Assert.AreEqual(2014, result[1].Result.BirthDate.Year);
Assert.AreEqual(1, result[1].Result.BirthDate.Month);
Assert.AreEqual(1, result[1].Result.BirthDate.Day);
}
public void TestSkipLastOne()
{
CsvParserOptions csvParserOptions = new CsvParserOptions(skipHeader: true, ';');
CsvPersonMapping csvMapper = new CsvPersonMapping();
CsvParser <Person> csvParser = new CsvParser <Person>(csvParserOptions, csvMapper);
var stringBuilder = new StringBuilder()
.AppendLine("FirstName;LastName;BirthDate")
.AppendLine(" Philipp;Wagner;1986/05/12 ")
.AppendLine("Max;Mustermann;2014/01/01");
var basePath = AppDomain.CurrentDomain.BaseDirectory;
var filePath = Path.Combine(basePath, "test_file.txt");
File.WriteAllText(filePath, stringBuilder.ToString(), Encoding.UTF8);
var result = csvParser
.ReadFromFile(filePath, Encoding.UTF8, skipLast: 1)
.ToList();
Assert.AreEqual(1, result.Count);
Assert.AreEqual("Philipp", result[0].Result.FirstName);
Assert.AreEqual("Wagner", result[0].Result.LastName);
}
public void InitA1()
{
var parserOptions = new CsvParserOptions(skipHeader: true, fieldsSeparator: ';');
var userParser = new CsvParser <User>(parserOptions, new UserClassMap());
var users = userParser.ReadFromFile("users.csv", Encoding.UTF8).ToList();
_context.BulkInsert(users.Select(x => x.Result));
var ratingParser = new CsvParser <Rating>(parserOptions, new RatingClassMap());
var ratings = ratingParser.ReadFromFile("ratings.csv", Encoding.UTF8).ToList();
var movies = ratings.Select(x => x.Result.Title).Distinct().ToList();
_context.BulkInsert(movies.Select(x => new Movie()
{
Title = x
}));
var m = _context.Movies.ToList(); // To get the assigned ID
for (int i = 0; i < ratings.Count; i++)
{
ratings[i].Result.MovieId = m.Find(x => x.Title == ratings[i].Result.Title).Id;
}
_context.BulkInsert(ratings.Select(x => x.Result));
}
public async Task <IActionResult> ParseData()
{
await RemoveOldCsvDataAsync();
var csvParserOptions = new CsvParserOptions(true, ',');
var csvParser = new CsvParser <CsvData>(csvParserOptions, new CsvDataMapping());
for (var i = 1; i <= 3; i++)
{
var records = csvParser.ReadFromFile($"data/data{i}.csv", Encoding.UTF8);
var csvDataList = records
.AsEnumerable()
.Select(r => new DataAccess.Entities.CsvData
{
Date = r.Result.Date,
Country = r.Result.Country,
Currency = r.Result.Currency,
Amount = r.Result.Amount
})
.ToList();
await context.AddRangeAsync(csvDataList);
}
await context.SaveChangesAsync();
return(Ok("Csv files in /Data folder has been imported to the database."));
}
public int TinyCsvParserBenchmark()
{
var totalLength = 0;
var csvParserOptions = new CsvParserOptions(false, ValueDelimeterChar, 4, true);
var csvReaderOptions = new CsvReaderOptions(RecordDelimeterStrings);
var csvMapper = new TinyCsvRecordMapping();
var csvParser = new CsvParser <Record>(csvParserOptions, csvMapper);
var results = csvParser.ReadFromString(csvReaderOptions, this.str);
foreach (var result in results)
{
var record = result.Result;
totalLength += record.Value0.Length;
totalLength += record.Value1.Length;
totalLength += record.Value2.Length;
totalLength += record.Value3.Length;
totalLength += record.Value4.Length;
totalLength += record.Value5.Length;
totalLength += record.Value6.Length;
totalLength += record.Value7.Length;
totalLength += record.Value8.Length;
totalLength += record.Value9.Length;
}
return(totalLength);
}
public DrugInteractionService()
{
CsvParserOptions csvParserOptions = new CsvParserOptions(true, '\t');
DrugDataSetMapping csvMapper = new DrugDataSetMapping();
_csvParser = new CsvParser <DrugDataSet>(csvParserOptions, csvMapper);
}
public async Task <ActionResult> Post(IFormFile file)
{
try
{
string[] permittedExtensions = { ".csv" };
var ext = System.IO.Path.GetExtension(file.FileName).ToLowerInvariant();
if (string.IsNullOrEmpty(ext) || !permittedExtensions.Contains(ext))
{
return(BadRequest("Only Allowed CSV File"));
}
CsvParserOptions csvParserOptions = new CsvParserOptions(true, ',');
CsvProductMapping csvMapper = new CsvProductMapping();
CsvParser <Product> csvParser = new CsvParser <Product>(csvParserOptions, csvMapper);
var products = csvParser.ReadFromStream(file.OpenReadStream(), Encoding.ASCII).ToList();
foreach (var product in products)
{
var result = product.Result;
}
return(Ok());
}
catch (Exception ex)
{
return(BadRequest(ex.ToString()));
}
}
public void ExecuteWithMissingValuesTest()
{
CsvParserOptions options = new CsvParserOptions(true, ';');
CsvParser <SampleEntity> customCsvParser = new CsvParser <SampleEntity>(options, new PermissiveSampleEntityMapper());
var stringBuilder = new StringBuilder()
.AppendLine("FirstName;LastName;BirthDate")
.AppendLine("1;2;3")
.AppendLine("4");
var csvReaderOptions = new CsvReaderOptions(new [] { Environment.NewLine });
var result = customCsvParser
.ReadFromString(csvReaderOptions, stringBuilder.ToString())
.ToList();
Assert.AreEqual(2, result.Count);
Assert.IsTrue(result.All(x => x.IsValid));
Assert.AreEqual("1", result[0].Result.Value1);
Assert.AreEqual("2", result[0].Result.Value2);
Assert.AreEqual("3", result[0].Result.Value3);
Assert.AreEqual("4", result[1].Result.Value1);
Assert.AreEqual(null, result[1].Result.Value2);
Assert.AreEqual(null, result[1].Result.Value3);
}
public void TinyCsvTest()
{
CsvParserOptions csvParserOptions = new CsvParserOptions(true, ',');
CsvApacheJmeterResultMapping csvMapper = new CsvApacheJmeterResultMapping();
CsvParser <BenchmarkTestItem> csvParser = new CsvParser <BenchmarkTestItem>(csvParserOptions, csvMapper);
var dirName = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
var filePath = Path.Combine(dirName + @"\\FileUploads\\TestCSVUpload.csv");
var result = csvParser
.ReadFromFile(filePath, Encoding.ASCII)
.ToList();
//Assert.Equal(21, result.Count);
//Assert.True(result.All(x => x.IsValid));
//Assert.Equal("Philipp", result[0].Result.FirstName);
//Assert.Equal("Wagner", result[0].Result.LastName);
//Assert.Equal(1986, result[0].Result.BirthDate.Year);
//Assert.Equal(5, result[0].Result.BirthDate.Month);
//Assert.Equal(12, result[0].Result.BirthDate.Day);
//Assert.Equal("Max", result[1].Result.FirstName);
//Assert.Equal("Mustermann", result[1].Result.LastName);
//Assert.Equal(2014, result[1].Result.BirthDate.Year);
//Assert.Equal(1, result[1].Result.BirthDate.Month);
//Assert.Equal(1, result[1].Result.BirthDate.Day);
}
public void TinyCsvTest()
{
CsvParserOptions csvParserOptions = new CsvParserOptions(true, new[] { ';' });
CsvPersonMapping csvMapper = new CsvPersonMapping();
CsvParser <Person> csvParser = new CsvParser <Person>(csvParserOptions, csvMapper);
var result = csvParser
.ReadFromFile(@"persons.csv", Encoding.ASCII)
.ToList();
Assert.AreEqual(2, result.Count);
Assert.IsTrue(result.All(x => x.IsValid));
Assert.AreEqual("Philipp", result[0].Result.FirstName);
Assert.AreEqual("Wagner", result[0].Result.LastName);
Assert.AreEqual(1986, result[0].Result.BirthDate.Year);
Assert.AreEqual(5, result[0].Result.BirthDate.Month);
Assert.AreEqual(12, result[0].Result.BirthDate.Day);
Assert.AreEqual("Max", result[1].Result.FirstName);
Assert.AreEqual("Mustermann", result[1].Result.LastName);
Assert.AreEqual(2014, result[1].Result.BirthDate.Year);
Assert.AreEqual(1, result[1].Result.BirthDate.Month);
Assert.AreEqual(1, result[1].Result.BirthDate.Day);
}
/// <summary>
/// Parse data from the given csv filepath into a list of hills,
/// which can then be retrieved using the public methods
/// </summary>
/// <param name="filePath"></param>
private void LoadFromFile(string filePath)
{
var hills = new List <CsvHill>();
//set up parser options - is there a header row, and the separator character
var csvParserOptions = new CsvParserOptions(true, ',');
//set up field mappings
var csvMapper = new CsvHillMapping();
//create a csv parser
var csvParser = new CsvParser <CsvHill>(csvParserOptions, csvMapper);
//load data from csv
var results = csvParser.ReadFromFile(filePath, Encoding.ASCII).ToList();
foreach (var details in results)
{
//check for invalid rows and discard
if (details.Result != null)
{
hills.Add(details.Result);
}
}
_hills = hills;
}
static void Main(string[] args)
{
//start validators
InputValidation IV = new InputValidation();
RuleValidation RV = new RuleValidation();
ReportGeneration RG = new ReportGeneration();
CsvParserOptions csvParserOptions = new CsvParserOptions(false, ',');
CsvApplicantMapping csvMapper = new CsvApplicantMapping();
CsvParser <Applicant> csvParser = new CsvParser <Applicant>(csvParserOptions, csvMapper);
//\EnrollmentApplication\EnrollmentApplication\bin\Debug\netcoreapp2.0\TestFile.csv
var parseList = csvParser
.ReadFromFile("TestFile.csv", Encoding.UTF8)
.ToList();
List <Applicant> transform = parseList.Select(i => i.Result).ToList();
IV.Validation(transform);
RV.Validation(transform);
RG.Report(transform);
Console.WriteLine("The program has finished - Press any key to exit");
Console.ReadKey();
}
public void QuotedStringTokenizerExampleTest()
{
CsvParserOptions csvParserOptions = new CsvParserOptions(true, string.Empty, new QuotedStringTokenizer(','));
CsvReaderOptions csvReaderOptions = new CsvReaderOptions(new[] { Environment.NewLine });
CsvPersonMapping csvMapper = new CsvPersonMapping();
CsvParser <Person> csvParser = new CsvParser <Person>(csvParserOptions, csvMapper);
var stringBuilder = new StringBuilder()
.AppendLine("FirstNameLastName;BirthDate")
.AppendLine("\"Philipp,Wagner\",1986/05/12")
.AppendLine("\"Max,Mustermann\",2014/01/01");
var result = csvParser
.ReadFromString(csvReaderOptions, stringBuilder.ToString())
.ToList();
// Make sure we got 2 results:
Assert.AreEqual(2, result.Count);
// And all of them have been parsed correctly:
Assert.IsTrue(result.All(x => x.IsValid));
// Now check the values:
Assert.AreEqual("Philipp,Wagner", result[0].Result.FirstNameWithLastName);
Assert.AreEqual(1986, result[0].Result.BirthDate.Year);
Assert.AreEqual(5, result[0].Result.BirthDate.Month);
Assert.AreEqual(12, result[0].Result.BirthDate.Day);
Assert.AreEqual("Max,Mustermann", result[1].Result.FirstNameWithLastName);
Assert.AreEqual(2014, result[1].Result.BirthDate.Year);
Assert.AreEqual(1, result[1].Result.BirthDate.Month);
Assert.AreEqual(1, result[1].Result.BirthDate.Day);
}
static void Main(string[] args)
{
CsvParserOptions csvParserOptions = new CsvParserOptions(true, ';');
CsvReaderOptions csvReaderOptions = new CsvReaderOptions(new[] { Environment.NewLine });
CsvCompanyMapping csvMapper = new CsvCompanyMapping();
CsvParser <Company> csvParser = new CsvParser <Company>(csvParserOptions, csvMapper);
// директория с исходником
string pathFrom = System.Configuration.ConfigurationManager.AppSettings["From"];
// директория для сохранения
string pathTo = System.Configuration.ConfigurationManager.AppSettings["To"];
string fileName = $"{pathFrom}list1.csv";
FileStream fStream = new FileStream(fileName, FileMode.Open);
string contents = null;
if (fStream.Length <= MAX_BUFFER_SIZE)
{
Byte[] bytes = new Byte[fStream.Length];
fStream.Read(bytes, 0, bytes.Length);
contents = enc8.GetString(bytes);
}
else
{
contents = ReadFromBuffer(fStream);
}
fStream.Close();
var list = csvParser.ReadFromString(csvReaderOptions, contents).ToList();
string appendText = GetResultString(list);
File.WriteAllText($"{pathTo}list1.html", appendText);
}
public ParallelQuery <DnsServer> ParseServersFromStream(Stream stream, ICsvMapping <DnsServer> format, bool skipHeaders, char separator)
{
var parserOptions = new CsvParserOptions(skipHeaders, separator);
var parser = new CsvParser <DnsServer>(parserOptions, format);
return(parser.ReadFromStream(stream, Encoding.UTF8).Where(res => res.IsValid).Select(res => res.Result));
}
//Parsing price_detail.csv to List of products using TinyCsvParser-----------------------------------------
public static List <Product> CsvToProductList(string fileName)
{
List <Product> products = new List <Product>();
if (string.IsNullOrWhiteSpace(fileName))
{
return(products);
}
CsvParserOptions csvParserOptions = new CsvParserOptions(true, '\t'); //true=skippa headern
var csvParser = new CsvParser <Product>(csvParserOptions, new CsvProductMapping());
var records = csvParser.ReadFromFile("price_detail.csv", Encoding.UTF8)
.Where(x => x.IsValid) //Parse Only the valid rows
.ToList();
//Change type, convert Raw data and save to Database-------------------------------------------------
foreach (CsvMappingResult <Product> row in records) //vilken kolumn
{
Product product = new Product()
{
PriceValuedId = row.Result.PriceValuedId,
Created = Convert.ToDateTime(row.Result.Created),
Modified = Convert.ToDateTime(row.Result.Modified),
CatalogEntryCode = Convert.ToString(row.Result.CatalogEntryCode),
MarketId = Convert.ToString(row.Result.MarketId),
CurrencyCode = Convert.ToString(row.Result.CurrencyCode),
ValidFrom = Convert.ToDateTime(row.Result.ValidFrom),
ValidUntil = Convert.ToDateTime(row.Result.ValidUntil),
UnitPrice = Convert.ToDecimal(row.Result.UnitPrice)
};
products.Add(product);
}
return(products);
}
public void StringArrayMappingTest()
{
CsvParserOptions csvParserOptions = new CsvParserOptions(false, ';');
CsvReaderOptions csvReaderOptions = new CsvReaderOptions(new[] { Environment.NewLine });
CsvStringArrayMapping csvMapper = new CsvStringArrayMapping();
CsvParser <string[]> csvParser = new CsvParser <string[]>(csvParserOptions, csvMapper);
var stringBuilder = new StringBuilder()
.AppendLine("Philipp;Wagner;1986/05/12")
.AppendLine("Max;Mustermann;2014/01/01");
var result = csvParser
.ReadFromString(csvReaderOptions, stringBuilder.ToString())
.ToList();
Assert.AreEqual(2, result.Count);
Assert.IsTrue(result.All(x => x.IsValid));
Assert.AreEqual("Philipp", result[0].Result[0]);
Assert.AreEqual("Wagner", result[0].Result[1]);
Assert.AreEqual("1986/05/12", result[0].Result[2]);
Assert.AreEqual("Max", result[1].Result[0]);
Assert.AreEqual("Mustermann", result[1].Result[1]);
Assert.AreEqual("2014/01/01", result[1].Result[2]);
}
private static DataTable GetCSVData()
{
CsvParserOptions csvParserOptions = new CsvParserOptions(false, ',');
CsvPersonMapping csvMapper = new CsvPersonMapping();
CsvParser <Account> csvParser = new CsvParser <Account>(csvParserOptions, csvMapper);
var csvResult = csvParser
.ReadFromFile(GetFilePath(), Encoding.UTF8)
.ToList();
DataTable dt = null;
if (csvResult.Count > 0)
{
dt = new DataTable();
dt.Columns.Add("Name");
dt.Columns.Add("PrimaryContactId");
dt.Columns.Add("Telephone1");
for (int locIndexLine = 0; locIndexLine < csvResult.Count; locIndexLine++)
{
dt.Rows.Add();
dt.Rows[locIndexLine]["Name"] = csvResult[locIndexLine].Result.Name;
dt.Rows[locIndexLine]["PrimaryContactId"] = csvResult[locIndexLine].Result.PrimaryContactId;
dt.Rows[locIndexLine]["Telephone1"] = csvResult[locIndexLine].Result.Telephone1;
}
}
return(dt);
}
public void CommentLineTest()
{
CsvParserOptions csvParserOptions = new CsvParserOptions(true, "#", new StringSplitTokenizer(new [] { ';' }, false));
CsvReaderOptions csvReaderOptions = new CsvReaderOptions(new[] { Environment.NewLine });
CsvPersonMapping csvMapper = new CsvPersonMapping();
CsvParser <Person> csvParser = new CsvParser <Person>(csvParserOptions, csvMapper);
var stringBuilder = new StringBuilder()
.AppendLine("FirstName;LastName;BirthDate")
.AppendLine("#Philipp;Wagner;1986/05/12")
.AppendLine("Max;Mustermann;2014/01/01");
var result = csvParser
.ReadFromString(csvReaderOptions, stringBuilder.ToString())
.Where(x => x.IsValid)
.ToList();
Assert.AreEqual(1, result.Count);
Assert.AreEqual("Max", result[0].Result.FirstName);
Assert.AreEqual("Mustermann", result[0].Result.LastName);
Assert.AreEqual(2014, result[0].Result.BirthDate.Year);
Assert.AreEqual(1, result[0].Result.BirthDate.Month);
Assert.AreEqual(1, result[0].Result.BirthDate.Day);
}
public void CustomCsvParserReadFromFile()
{
CsvParserOptions options = new CsvParserOptions(true, ';');
CustomCsvParser customCsvParser = new CustomCsvParser(options);
var stringBuilder = new StringBuilder()
.AppendLine("FirstName;LastName;BirthDate")
.AppendLine(" Philipp;Wagner;1986/05/12 ")
.AppendLine("Max;Mustermann;2014/01/01");
#if NETCOREAPP1_1
var basePath = AppContext.BaseDirectory;
#else
var basePath = AppDomain.CurrentDomain.BaseDirectory;
#endif
var filePath = Path.Combine(basePath, "test_file.txt");
File.WriteAllText(filePath, stringBuilder.ToString(), Encoding.UTF8);
var result = customCsvParser
.ReadFromFile(filePath, Encoding.UTF8)
.ToList();
Assert.AreEqual(2, result.Count);
Assert.AreEqual("Philipp", result[0].Tokens[0]);
Assert.AreEqual("Wagner", result[0].Tokens[1]);
Assert.AreEqual("Max", result[1].Tokens[0]);
Assert.AreEqual("Mustermann", result[1].Tokens[1]);
}
public List <CompanyInformation> getListOfCompanies()
{
try
{
string filename = FileDownloader.downloadFile(listOfCompaniesInNSE);
if (filename == null)
{
Console.WriteLine("Unable to download file {0}", listOfCompaniesInNSE);
return(null);
}
// Parse CSV file
CsvParserOptions csvParserOptions = new CsvParserOptions(true, ',');
CsvCompanyInformationMapping csvMapper = new CsvCompanyInformationMapping();
CsvParser <CompanyInformation> csvParser = new CsvParser <CompanyInformation>(csvParserOptions, csvMapper);
// Parse the CSV file
var result = csvParser.ReadFromFile(filename, Encoding.ASCII)
.Select(x => x.Result)
.ToList();
var mapping = getIndustryList();
result.ForEach(x => x.industry = mapping.TryGetValue(x.isinNumber, out string industry) ? industry : ConstValues.defaultIndustry);
return(result);
}
catch (Exception ex)
{
Console.WriteLine("Exception: {0}", ex.Message);
Environment.Exit(1);
}
return(null);
}
private static List <CreWithSSA> GetCommandsFromFile(string filePath)
{
try
{
//recuperation du fichier sans header avec separateur ";"
CsvParserOptions csvParserOptions = new CsvParserOptions(false, ';');
var csvParser = new CsvParser <CsvRecordLigne>(csvParserOptions, new CsvRecordLigneMapping());
var records = csvParser.ReadFromFile(filePath, Encoding.UTF8).ToList();
//constitue la liste des Flux du fichier
var listeCommandes = new List <CreWithSSA>();
foreach (var record in records)
{
if (record.Result.SEG.ToUpper() == "SSA")
{
continue;
}
var creWithSsa = new CreWithSSA()
{
cre = Mapper.Map <Cre>(record.Result),
ListSSA = records.Where(r => r.Result.SEG.ToUpper() == "SSA" && r.Result.Col26 == record.Result.NUM_SEG)
.Select(r => Mapper.Map <Ssa>(r.Result)).ToList()
};
listeCommandes.Add(creWithSsa);
}
return(listeCommandes);
}
catch
{
return(new List <CreWithSSA>());
}
}
public List <CreAds> GetCommandsFromFile(string filePath)
{
try
{
//recuperation du fichier sans header avec separateur ";"
CsvParserOptions csvParserOptions = new CsvParserOptions(false, ';');
var csvParser = new CsvParser <CsvRecordLigne>(csvParserOptions, new CsvRecordLigneMapping());
var records = csvParser.ReadFromFile(filePath, Encoding.UTF8).ToList();
//constitue la liste des Flux du fichier
var listeCommandes = new List <CreAds>();
foreach (var record in records)
{
if (record.Result.SEG.ToUpper() == "SSA")
{
continue;
}
var creWithSsa = Mapper.Map <CreAds>(record.Result);
creWithSsa.ListSsa = records.Where(r => r.Result.SEG.ToUpper() == "SSA" && r.Result.Col26 == record.Result.NUM_SEG)
.Select(r => Mapper.Map <SsaAds>(r.Result)).ToList();
listeCommandes.Add(creWithSsa);
}
return(listeCommandes);
}
catch (Exception ex)
{
Console.WriteLine(ex.InnerException.Message.ToString());
return(new List <CreAds>());
}
}
public void Issue60_TrailingComma_Test()
{
var csvParserOptions = new CsvParserOptions(false, '|');
var csvReaderOptions = new CsvReaderOptions(new[] { Environment.NewLine });
var csvMapper = new TeacherEntityMapping();
var csvParser = new CsvParser <TeacherEntity>(csvParserOptions, csvMapper);
var stringBuilder = new StringBuilder()
.AppendLine(@"Johnson|Anne|110236|697125|1.00|Teacher|[email protected]");
var result = csvParser
.ReadFromString(csvReaderOptions, stringBuilder.ToString())
.ToList();
Assert.AreEqual(1, result.Count);
Assert.IsTrue(result.All(x => x.IsValid));
Assert.AreEqual("Johnson", result.First().Result.Col0);
Assert.AreEqual("Anne", result.First().Result.Col1);
Assert.AreEqual(110236, result.First().Result.Col2);
Assert.AreEqual(697125, result.First().Result.Col3);
Assert.AreEqual(1.00f, result.First().Result.Col4, 1e-3);
Assert.AreEqual("Teacher", result.First().Result.Col5);
Assert.AreEqual("*****@*****.**", result.First().Result.Col6);
}
public CSVParseManager(string csv)
{
this.CSVInputFile = csv;
this.csvParseOptions = new CsvParserOptions(true, ',');
this.CSVFileHeaders = File.ReadLines(CSVInputFile).First().Split(',').ToList();
}
public async Task <RegistryResponse> GetRegistryByID(int id)
{
CsvParserOptions csvParserOptions = new CsvParserOptions(false, ',');
CsvReaderOptions csvReaderOptions = new CsvReaderOptions(new[] { Environment.NewLine });
RegistryMapping csvMapper = new RegistryMapping();
CsvParser <RegistryServices> csvParser =
new CsvParser <RegistryServices>(csvParserOptions, csvMapper);
RegistryResponse resultList = null;
var list = new List <RegistryResponse>();
try
{
string fileName = $"Doc//RegistryServices.csv";
var result = csvParser
.ReadFromFile(fileName, Encoding.UTF8).Skip(1)
.ToList();
result.ForEach(x =>
{
list.Add(new RegistryResponse
{
Id = Convert.ToInt32(x.Result.IdAgreement.ToString()),
NombreEmpresa = x.Result.NameEnterprise.ToString(),
EndpointUrl = new Uri($"http://{x.Result.EndpointUrl}"),
Formato = x.Result.FormatTransformation.ToString()
});
});
}
catch (Exception ex)
{
var error = ex.ToString();
}
return(list.Where(x => x.Id.Equals(id)).FirstOrDefault());
}
