public void ParseCsvFileTest()
{
string filePath = Path.Combine(this.TestContext.TestDeploymentDir, "Files\\1095_Import_Employees.csv");
ICsvFileParser parser = new CsvFileParser(filePath);
IDictionary <int, IList <string> > fileErrors = new Dictionary <int, IList <string> >();
IObjectValidator validator = new ObjectValidator();
int rowIndex = parser.RowStart;
foreach (dynamic row in parser.ParseFile())
{
List <string> errors = new List <string>();
Employee rowObj = FileIOUtilities.MapObject <Employee>(row, rowIndex, validator, null, ref errors);
//rowObj.MapValues(rowIndex, row, validator, ref errors);
validator.TryValidate(rowObj, ref errors);
if (errors.Count > 0)
{
fileErrors.Add(rowIndex, errors);
}
rowIndex++;
}
Assert.IsTrue(fileErrors.Count >= 2);
}
public static void CsvImport1(string path)
{
Console.WriteLine("Running CsvImport1");
ICsvFileParser parser = new CsvFileParser(path);
IImportFileParameters <Company> insertParameters = new ImportFileParameters <Company>(parser, "dbo.ImportCompanies", "Company_Import_tt");
insertParameters.ProcedureParameterName = "@data";
insertParameters.CustomSqlMapper = Common.MapValues;
insertParameters.ErrorColumnName = "ImportErrors";
var repo = new FileDataImportRepository();
using (SqlConnection conn = new SqlConnection(ConfigurationManager.ConnectionStrings["TestDB"].ConnectionString))
{
conn.Open();
using (SqlTransaction tran = conn.BeginTransaction())
{
repo.ImportFile <Company>(tran, insertParameters);
tran.Commit();
}
}
}
private static ParseResult <TransactionFileRecordModel> ParseFile(Stream stream)
{
var parser = new CsvFileParser <TransactionFileRecordModel, TransactionFileRecordMap> {
Delimiter = ";"
};
using (stream)
{
return(parser.Parse(stream));
}
}
private void PrepareInitialDataProvider()
{
CsvFileParser csvParser = new CsvFileParser();
ParsingResultValidator validator = new ParsingResultValidator();
InitialDataFilePathProvider filePathProviderMock = new InitialDataFilePathProvider {
FilePath = _initialDataFilePath
};
FileValidationOperationResultLogger resultLogger = new FileValidationOperationResultLogger(new FileOperations());
_initialDataProvider = new CsvDataProvider(csvParser, validator, filePathProviderMock, resultLogger);
}
public ActionResult ImportorEditor()
{
HttpFileCollection files = System.Web.HttpContext.Current.Request.Files;
string outmsg = string.Empty;
bool success = false;
if (files.Count > 0)
{
for (int i = 0; i < files.Count; i++)
{
HttpPostedFile file1 = files[i];
Stream stream = file1.InputStream;
DataTable dt = new DataTable();
string fileName = System.IO.Path.GetFileNameWithoutExtension(file1.FileName);
string fileType = System.IO.Path.GetExtension(file1.FileName).ToLower();
switch (fileType)
{
case ".csv":
CsvFileParser cfp = new CsvFileParser();
dt = cfp.TryParse(stream, out outmsg);
break;
case ".xls":
case ".xlsx":
success = false;
//outmsg = "文件：" + fileName + "的文件格式接口待开发！<br />";
IExcel excel = ExcelFactory.CreateDefault();
DataSet ds = excel.Read(stream);
dt = ds.Tables[0];
break;
default:
success = false;
outmsg += "文件：" + fileName + "格式不支持！<br />";
break;
}
success = new Manager.PayManager().ImportInsurance(dt, fileName, ref outmsg);
}
}
else
{
outmsg += "未获取到文件，请重试！<br />";
}
if (success)
{
outmsg = "上传成功！<br />" + outmsg;
}
else
{
outmsg = "上传失败！<br />" + outmsg;
}
return(Json(outmsg));
}
public IntoConstraints <TLine, TResultSet> Into(Expression <Func <TLine, TMember> > intoMember)
{
if (_columnName.IsEmpty())
{
CsvFileParser.AddColumn(_columnIndex, intoMember, _inThisWay, _validator);
}
else
{
CsvFileParser.AddColumn(_columnName, intoMember, _inThisWay, _validator);
}
return(new IntoConstraints <TLine, TResultSet>(CsvFileParser, ResultSet));
}
private CsvFileParser <TLine> GetParser <TLine>()
where TLine : new()
{
var parser = new CsvFileParser <TLine>(CsvParameters.Source,
CsvParameters.DataSplitter, CsvParameters.CultureInfo)
{
ColumnDelimiter = CsvParameters.ColumnDelimiter,
LineDelimiter = CsvParameters.EndLineDelimiter,
HeadersAsCaseInsensitive = CsvParameters.HeaderCaseInsensitive,
};
if (CsvParameters.FirstLineHasHeader)
{
parser.DeclareFirstLineHasHeader();
}
return(parser);
}
private static CsvFileParser Initialize()
{
CsvFileParser parser = null;
while (parser == null)
{
ShowStartupMenu();
var choice = Console.ReadKey().KeyChar.ToString();
Console.WriteLine(Environment.NewLine);
try
{
switch (choice)
{
case "1":
SetPathsMenu();
SetFileExtensionForTr1();
parser = BuildTr1FileParser();
break;
case "2":
SetPathsMenu();
SetFileExtensionForTr2();
parser = BuildTr2FileParser();
break;
case "3":
Environment.Exit(0);
break;
default:
Console.WriteLine($"Prosze wybrac Poprawna opcje! {Environment.NewLine}");
continue;
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
Console.WriteLine(Environment.NewLine);
}
}
return(parser);
}
private static void Main(string[] args)
{
fileParser = Initialize();
try
{
fileParser.Parse();
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
finally
{
fileParser.Cleanup();
}
Console.WriteLine($"{Environment.NewLine}Program zakonczyl dzialanie. Nacisnij dowolny przycisk by zamknac okno...");
Console.ReadKey();
}
public void RunTest_TabularItem()
{
var csvStringBuilder = new StringBuilder();
csvStringBuilder.AppendLine("12, 9,7,6,4");
csvStringBuilder.AppendLine("12,11,8,7,5");
csvStringBuilder.AppendLine("13,10,9,6,3");
csvStringBuilder.Append("12,8,6,4,2");
var csvString = csvStringBuilder.ToString();
var csvStringReader = new StringReader(csvString);
var parser = new IntegerParser <string>();
var csvParser = new CsvFileParser <ITabularItem, int, string, string>(
"new_line",
"comma",
(i, j) => parser);
csvParser.AddIgnoreType("space");
csvParser.AddIgnoreType("carriage_return");
var csvSymbolReader = new StringSymbolReader(csvStringReader, true, false);
var adder = new TabularItemAdder <int>();
var tabularItem = new TabularListsItem();
csvParser.Parse(csvSymbolReader, tabularItem, adder);
var integerDomain = new IntegerDomain();
var numberTdecomposition = new IntegerMinWeightTdecomposition <int>(
Comparer <int> .Default,
integerDomain);
var result = numberTdecomposition.Run(18, tabularItem);
var expectedMedians = new List <int>()
{
3, 5, 5, 5
};
Assert.AreEqual(17, result.Cost);
CollectionAssert.AreEquivalent(expectedMedians, result.Medians.ToList());
}
public static IList <Company> ReadCsvFile1()
{
Console.WriteLine("Running ReadCsvFile1");
var parser = new CsvFileParser(Common.CsvDataPath);
var fileErrors = new Dictionary <int, IList <string> >();
var validator = new ObjectValidator();
//parser.Delimiters // can adjust the delimiters
//parser.FixedWidths // can parse fixed widths
var rowIndex = parser.RowStart;
var companies = new List <Company>();
foreach (dynamic row in parser.ParseFile())
{
var errors = new List <string>();
var rowObj = FileIOUtilities.MapObject <Company>(row, rowIndex, validator, null, ref errors);
validator.TryValidate(rowObj, ref errors);
companies.Add(rowObj);
if (errors.Count > 0)
{
fileErrors.Add(rowIndex, errors);
}
rowIndex++;
}
foreach (var errs in fileErrors)
{
foreach (var err in errs.Value)
{
Console.WriteLine("Line:{0}, Error: {1}", errs.Key, err);
}
}
return(companies);
}
static void Main(string[] args)
{
var entries = CsvFileParser.ParseFile(@"D:\temp\temperatures.csv").ToList();
Console.WriteLine($"Total number of entries: {entries.Count}");
var analyzer = new TemperatureAnalyzer(entries);
var firstEntryBelowZero = analyzer.FirstEntryBelowZero();
var coldest = analyzer.ColdestEntry();
var warmest = analyzer.WarmestEntry();
Console.WriteLine($"First entry below zero: {firstEntryBelowZero}");
Console.WriteLine($"Coldest: {coldest}");
Console.WriteLine($"Warmest: {warmest}");
var averages = analyzer.AveragePerDay();
foreach (var averageTemp in averages)
{
Console.WriteLine($"{averageTemp.Date.ToShortDateString()}: {Math.Round(averageTemp.Average, 1)}");
}
}
protected ParserContainer(CsvFileParser <T> parser, TResultSet resultSet)
{
CsvFileParser = parser;
ResultSet = resultSet ?? throw new ArgumentNullException(nameof(resultSet));
}
public ColumnsBuilder(CsvFileParser <TLine> parser, TResultSet resultSet)
{
Put = new ColumnFluentBuilder <TLine, TResultSet>(parser, resultSet);
}
internal ChoiceBetweenAsAndInto(CsvFileParser <TLine> parser, string columnName, TResultSet resultSet, Func <string, Data> validation = null) : base(parser, resultSet)
{
_intoBuilder = new IntoBuilder <TLine, string, TResultSet>(CsvFileParser, columnName, resultSet, validator: validation);
_asBuilder = new AsBuilder <TLine, TResultSet>(CsvFileParser, columnName, resultSet, validation);
_inThisWayBuilder = new InThisWayBuilder <TLine, string, TResultSet>(CsvFileParser, columnName, resultSet, validation);
}
public void UpdateData(IWizardImporterSettings settings)
{
var data = CsvFileParser.ParseFileToDataTable(settings.PathToFile, true);
settings.Data = data;
}
public void UpdatePreview(IWizardImporterSettings settings)
{
var preview = CsvFileParser.ParseFileToDataTable(settings.PathToFile, true, null, null, 10);
settings.Preview = preview;
}
internal IntoConstraints(CsvFileParser <TLine> csvParameters, TResultSet resultSet) : base(csvParameters, resultSet)
{
Put = new ColumnFluentBuilder <TLine, TResultSet>(CsvFileParser, resultSet);
}
public TResultSet GetAll()
{
return(CsvFileParser.Parse(ResultSet));
}
internal AsBuilder(CsvFileParser <TLine> parser, string columnName, TResultSet resultSet, Func <string, Data> dataValidation = null) : base(parser, resultSet)
{
_columnName = columnName;
_dataValidation = dataValidation;
}
internal AsBuilder(CsvFileParser <TLine> parser, int columnIndex, TResultSet resultSet, Func <string, Data> dataValidation = null) : base(parser, resultSet)
{
_columnIndex = columnIndex;
_dataValidation = dataValidation;
}
internal AsMethods(CsvFileParser <TLine> parser, string columnName, TResultSet resultSet, Func <string, Data> dataValidator = null) : base(parser, resultSet)
{
_inThisWayBuilder = new InThisWayBuilder <TLine, TMember, TResultSet>(CsvFileParser, columnName, resultSet, dataValidator);
_intoBuilder = new IntoBuilder <TLine, TMember, TResultSet>(CsvFileParser, columnName, resultSet, validator: dataValidator);
}
internal ChooseWithValidation(CsvFileParser <TLine> parser, int columnIndex, TResultSet resultSet) : base(parser, columnIndex, resultSet)
{
_parser = parser;
_columnIndex = columnIndex;
_resultSet = resultSet;
}
internal ChooseWithValidation(CsvFileParser <TLine> parser, string columnName, TResultSet resultSet) : base(parser, columnName, resultSet)
{
_parser = parser;
_columnName = columnName;
_resultSet = resultSet;
}
public void SetUp()
{
_csvFileParser = new CsvFileParser();
}
public ColumnFluentBuilder(CsvFileParser <TLine> parser, TResultSet resultSet) : base(parser, resultSet)
{
}
internal InThisWayBuilder(CsvFileParser <TLine> csvParameters, string columnName, TResultSet resultSet, Func <string, Data> dataValidation = null) : base(csvParameters, resultSet)
{
_columnName = columnName;
_dataValidation = dataValidation;
}
public CsvFileParserTests()
{
_csvFileParser = new CsvFileParser();
}
/// <summary>
/// Searches for WaterOneFlow service info in a DataTable, and adds info about those services to the data grid view
/// </summary>
/// <param name="pathToFile">Path to CSV file</param>
/// <param name="e">Parameters from the BackgroundWorker</param>
/// <returns>Parameters (task type, output message, rows to add to view) to be processed by a BackgroundWorker event handler</returns>
private object[] AddServicesFromDataTable(string pathToFile, DoWorkEventArgs e)
{
// Build parameters to pass to the background worker
object[] parameters = new object[3];
parameters[0] = BackgroundWorkerTasks.AddServicesFromFile;
parameters[1] = "Operation cancelled";
// Read the CSV file into a DataTable
bgwMain.ReportProgress(0, "Opening file, please wait...");
DataTable dataTable = null;
try
{
dataTable = CsvFileParser.ParseFileToDataTable(pathToFile, true);
}
catch (Exception ex)
{
throw new Exception("Could not read file. " + ex.Message);
}
// Get the columns from the table
int colTitle = dataTable.Columns.IndexOf("Title");
int colUrl = dataTable.Columns.IndexOf("URL");
int colCode = dataTable.Columns.IndexOf("Code");
int colCitation = dataTable.Columns.IndexOf("Citation");
int colAbstract = dataTable.Columns.IndexOf("Abstract");
int colWebsite = dataTable.Columns.IndexOf("Website");
int colName = dataTable.Columns.IndexOf("Contact");
int colEmail = dataTable.Columns.IndexOf("Email");
if (colUrl == -1)
{
throw new Exception("URL column not found in CSV file");
}
// Find items with an element providing the URL to a WaterOneFlow service
int totalSteps = dataTable.Rows.Count;
int currentStep = 0;
List <string[]> rowsToAdd = new List <string[]> ();
foreach (DataRow dataRow in dataTable.Rows)
{
// Update progress
if (bgwMain.CancellationPending)
{
e.Cancel = true;
return(parameters);
}
currentStep++;
bgwMain.ReportProgress(100 * currentStep / totalSteps, "Searching for WaterOneFlow service info: " + currentStep + " of " + totalSteps + "...");
// Build service info from the row
string title = "";
if (colTitle != -1)
{
title = dataRow[colTitle].ToString();
}
string url = "";
if (colUrl != -1)
{
url = dataRow[colUrl].ToString();
try
{
url = WebOperations.GetCanonicalUri(url, true);
}
catch
{
url = "";
}
}
string code = "";
if (colCode != -1)
{
code = dataRow[colCode].ToString();
}
string citation = "";
if (colCitation != -1)
{
citation = dataRow[colCitation].ToString();
}
string serviceAbstract = "";
if (colAbstract != -1)
{
serviceAbstract = dataRow[colAbstract].ToString();
}
string website = "";
if (colWebsite != -1)
{
website = dataRow[colWebsite].ToString();
}
string name = "";
if (colName != -1)
{
name = dataRow[colName].ToString();
}
string email = "";
if (colEmail != -1)
{
email = dataRow[colEmail].ToString();
}
// Create an item to add to the data grid view
if (url != String.Empty)
{
string[] row = { title, url, code, citation, serviceAbstract, website, name, email };
rowsToAdd.Add(row);
}
}
// Prepare a message to the user
string message = "";
int servicesAdded = rowsToAdd.Count;
if (servicesAdded == 0)
{
message = "No services found in file";
}
else if (servicesAdded == 1)
{
message = "1 service found in file";
}
else
{
message = servicesAdded.ToString() + " services found in file";
}
parameters[1] = message;
parameters[2] = rowsToAdd;
return(parameters);
}
internal IntoBuilder(CsvFileParser <TLine> parser, string columnName, TResultSet resultSet, Func <string, TMember> inThisWay = null, Func <string, Data> validator = null) : base(parser, resultSet)
{
_columnName = columnName;
_inThisWay = inThisWay;
_validator = validator;
}
