public void TestParseCsvFile()
{
ICsvFileHandler _csvFileHandler = new CsvFileHandler(new ParsingService(), new ValidationService(), new FileService());
string csvFileContent = File.ReadAllText(HeaderFileName);
CsvTable csvTable = new CsvTable();
string[] lines = csvFileContent.Split(
new[] { "\r\n", "\r", "\n" },
StringSplitOptions.RemoveEmptyEntries
);
for (int i = 0; i < lines.Length; i++)
{
var row = lines[i];
if (i == 0)
{
csvTable.HeaderRow = ParseRow(row);
}
else
{
csvTable.Rows.Add(ParseRow(row));
}
}
CsvHandleResult csvHandleResult = new CsvHandleResult();
csvHandleResult.Success = true;
csvHandleResult.ParsedCsvContent = csvTable;
// todo mock HttpPostedFileBase
// Assert(_csvFileHandler.ParseCsvFile
}
public void UsesFieldNames()
{
var actual = CsvTable.Read(new[] { "A,B", "1,2" }.ToCsv());
Assert.AreEqual("1", actual.Rows[0]["A"]);
Assert.AreEqual("2", actual.Rows[0]["B"]);
}
protected override Task <bool> LoadData()
{
var files = _fileSystem.GetFiles(_loadPath, _extension);
_dataTables.Clear();
foreach (var file in files)
{
using (var stream = _fileSystem.OpenRead(file))
using (var reader = new StreamReader(stream))
{
var csv = new CsvReader(reader);
var table = new CsvTable();
while (csv.Read())
{
var row = table.AddRow();
for (int i = 0; i < csv.FieldsCount; ++i)
{
row.Add(csv[i]);
}
}
_dataTables[Path.GetFileNameWithoutExtension(file)] = table;
}
}
return(Task.FromResult(true));
}
public void CsvComparisonErrorsMissingTest()
{
var expectedCsv = CsvTable.Parse("SimpleExpected.csv");
var actualCsv = CsvTable.Parse("SimpleActualMissing.csv");
var comparison = new CsvComparison(expectedCsv, actualCsv, Tolerance.Parse("2%;0.001"));
var expected = comparison.ExpectedTable;
Assert.AreEqual(2, expected.RowCount, "Expected RowCount");
var actual = comparison.ActualTable;
Assert.AreEqual(1, actual.RowCount, "Actual RowCount");
Assert.AreEqual(4, comparison.ErrorCount(), "Error Count = 2");
var query = comparison.Query();
var errorRow = query[0] as Collection <object>;
Assert.AreEqual("B1", QueryValue(errorRow, "Cell"));
Assert.AreEqual("Missing", QueryValue(errorRow, "Issue"));
errorRow = query[1] as Collection <object>;
Assert.AreEqual("B2", QueryValue(errorRow, "Cell"));
Assert.AreEqual("Missing", QueryValue(errorRow, "Issue"));
errorRow = query[2] as Collection <object>;
Assert.AreEqual("A3", QueryValue(errorRow, "Cell"));
Assert.AreEqual("Missing", QueryValue(errorRow, "Issue"));
errorRow = query[3] as Collection <object>;
Assert.AreEqual("B3", QueryValue(errorRow, "Cell"));
Assert.AreEqual("Missing", QueryValue(errorRow, "Issue"));
}
/// <summary>
/// Accepts a string with the contents of the csv file in it and should return a parsed csv file.
/// </summary>
/// <param name="fileContent"></param>
/// <param name="containsHeader"></param>
/// <returns></returns>
public CsvTable ParseCsv(string fileContent, bool containsHeader)
{
try
{
var table = new CsvTable();
string[] lines = fileContent.Split(
new[] { "\r\n", "\r", "\n" },
StringSplitOptions.RemoveEmptyEntries
);
for (int i = 0; i < lines.Length; i++)
{
var row = lines[i];
if (containsHeader && i == 0)
{
table.HeaderRow = ParseRow(row);
}
else
{
table.Rows.Add(ParseRow(row));
}
}
return(table);
}
catch
{
// Row parsing failures should bubble up to here.
return(null);
}
}
// Use this for initialization
void Start()
{
CsvLoader loader = new CsvLoader();
CsvTable csvTable = loader.LoadCSV("Config/test");
TestDataMap tMap = new TestDataMap();
IDataMap tempMap = tMap as IDataMap;
loader.LoadCSV("Config/test", ref tempMap);
//tMap.Load(ref csvTable);
Dictionary <int, TestData> Dic = tMap.GetMap() as Dictionary <int, TestData>;
//tMap.GetMap(ref Dic);
//tMap.clearMap();
foreach (var t in Dic)
{
Debug.Log("!!!!!!!" + t.Key + "=" + t.Value.Name);
}
//CsvTable csvTable = loader.LoadCSV("Config/" + str);
foreach (CsvRecord record in csvTable.Records)
{
foreach (string header in csvTable.Headers)
{
Debug.Log(header + ":" + record.GetField(header));
text.text = text.text + (header + ":" + record.GetField(header));
}
}
}
public Task <bool> Load()
{
var files = Directory.GetFiles(_loadPath, _searchPattern);
_dataTables = new Dictionary <string, CsvTable>();
foreach (var file in files)
{
using (var stream = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
using (var reader = new StreamReader(stream))
{
var csv = new CsvReader(reader);
var table = new CsvTable();
while (csv.Read())
{
var row = table.AddRow();
for (int i = 0; i < csv.FieldsCount; ++i)
{
row.Add(csv[i]);
}
}
_dataTables[Path.GetFileNameWithoutExtension(file)] = table;
}
}
return(Task.FromResult(true));
}
public void UsesSpecifiedFieldDelimiter()
{
var actual = CsvTable.Read(new[] { "A;B", "1;2" }.ToCsv(), ';');
Assert.AreEqual("1", actual.Rows[0]["A"]);
Assert.AreEqual("2", actual.Rows[0]["B"]);
}
protected override IRawSheetExporterPage CreatePage(string sheetName)
{
var table = new CsvTable();
_dataTables[sheetName] = table;
return(new Page(table));
}
/// <summary>
/// Accepts a string with the contents of the csv file in it and should return a parsed csv file.
/// </summary>
/// <param name="fileContent"></param>
/// <param name="containsHeader"></param>
/// <returns></returns>
public CsvTable ParseCsv(string fileContent, bool containsHeader)
{
//TODO fill in your logic here
//throw new NotImplementedException();
// now parse string fileContent in CsvTable object
var result = new CsvTable();
var rowsArr = ConvertToLines(fileContent);
// header first
var HeaderRow = new CsvRow();
if (containsHeader)
{
HeaderRow = ConvertLinetoRow(rowsArr[0]);
}
result.HeaderRow = HeaderRow;
// table rows
var DataRows = new List <CsvRow>();
if (rowsArr.Length > 0)
{
for (var i = (containsHeader ? 1 : 0); i < rowsArr.Length; i++)
{
DataRows.Add(ConvertLinetoRow(rowsArr[i]));
}
}
result.Rows = DataRows;
return(result);
}
public void CsvTable_AddHeader_ByName_NullHeader()
{
var table = new CsvTable();
string headerName = null;
Assert.Throws <ArgumentNullException>(() => table.AddHeader(headerName));
}
private void OutputToFile(IList <Log> logdata, string filepath)
{
var csv = new CsvTable();
var header = new List <string>();
header.Add("LineId");
header = header.Concat(this.LogFormatHeader).ToList();
header.Remove("Content");
header.Add("Content");
header.Add("EventId");
header.Add("EventTemplate");
header.Add("ParameterList");
csv.AppendLine(header);
foreach (var log in logdata)
{
var line = new List <object>();
var template = this.Model.Lookup(log.LogId);
//template.ApplyToLogData(log);
line.Add(log.LogId);
line = line.Concat(log.FormatLog.Where(x => x.Key != "Content").Select(x => "\"" + x.Value + "\"").ToArray()).ToList();
line.Add("\"" + log.FormatLog["Content"].Replace("\"", "\'") + "\"");
line.Add(template.TemplateId);
line.Add("\"" + template.ToString().Replace("\"", "\'") + "\"");
line.Add("\"" + string.Join(",", template.Match(log)).Replace("\"", "\'") + "\"");
csv.AppendLine(line);
}
csv.SaveFile(filepath);
}
public List <SortedCommandPair> GetCommandMappings()
{
return
(CsvTable.Read(Resources.CommandMappingsStatistic)
.Rows.Select(row => SortedCommandPair.NewSortedPair(row["FirstCommand"], row["SecondCommand"]))
.ToList());
}
public static PrefabBindingInfo LoadPrefabBindingInfo(this CsvTable table)
{
if (table == null)
{
return(null);
}
if (table.Columns.Count < 4)
{
Debug.LogErrorFormat("表列数和需求不一致，请目标表{0}检查是否为绑定信息！", table.name);
return(null);
}
var prefabBindingInfo = new PrefabBindingInfo(table.name);
var count = table.Rows.Count;
for (int i = 0; i < count; i++)
{
var row = table.Rows[i];
var scriptItem = new PrefabBindingInfo.ScriptItem();
scriptItem.path = row[0];
var assemble = Assembly.Load(row[1]);
if (assemble != null)
{
scriptItem.type = assemble.GetType(row[2]);
}
scriptItem.resources = ParamAnalysisTool.ToDictionary(row[3]);
prefabBindingInfo.scriptItems.Add(scriptItem);
}
return(prefabBindingInfo);
}
public CsvTableRenderer(CsvTable csvTable)
{
if (csvTable is null)
{
throw new ArgumentNullException(nameof(csvTable), "There is no table available to render");
}
_csvTable = csvTable;
}
private void Start()
{
CsvHelper.Init();
table = CsvHelper.Create(text.name, text.text);
//numberOfMessages = table.RowCount;
numberOfMessages = 10;
//Debug.Log(table.Read(2,2));
}
public CsvInteractor(CommandLineArg arguments)
{
string[] csvContent = _reader.ReadCsv(arguments.Path);
CsvTable csvTable = _creator.CreateCsvTable(csvContent);
_renderer = new CsvTableRenderer(csvTable);
_calculator = new PageCalculator(csvTable.DataLinesCount, arguments.PageSize);
}
// Token: 0x06000028 RID: 40 RVA: 0x000033A8 File Offset: 0x000015A8
public static LogEvaluator FromCondition(LogCondition condition, CsvTable table)
{
Dictionary <string, LogVariableEvaluator> variables = new Dictionary <string, LogVariableEvaluator>();
LogEvaluator logEvaluator = LogEvaluator.FromCondition(condition, table, variables, 100);
LogEvaluator.CheckOptimization(condition, logEvaluator.searches, table.IndexedFields, 0);
return(logEvaluator);
}
// Token: 0x06000044 RID: 68 RVA: 0x00003BC9 File Offset: 0x00001DC9
public override Type GetValueType(CsvTable table)
{
if (this.Value != null)
{
return(this.Value.GetType());
}
return(typeof(object));
}
public void CsvTable_HasColumn_NullArgument()
{
var table = new CsvTable();
string headerName = "test";
table.AddHeader(headerName);
Assert.False(table.HasColumn(null));
}
public void GetHashCodeOfTwoDifferentTables()
{
var table2ParserMock = new Mock <CellsParserBase>();
table2ParserMock.Setup(p => p.ParseCells(It.IsAny <string>())).Returns(Enumerable.Repeat("AnotherCell", 3).ToArray());
var table2 = new CsvTable(_pathToDefaultTable, table2ParserMock.Object, _defaultRowsReaderMock.Object);
Assert.False(_defaultTable.GetHashCode() == table2.GetHashCode());
}
public void CsvTable_HasColumn_Success()
{
var table = new CsvTable();
string headerName = "test";
table.AddHeader(headerName);
Assert.True(table.HasColumn(headerName));
}
public void CsvTable_HasColumn_HeaderDoesNotExist()
{
var table = new CsvTable();
string headerName = "test";
string nonExistingheaderName = "iDontExist";
table.AddHeader(headerName);
Assert.False(table.HasColumn(nonExistingheaderName));
}
public void EqualsWhenOtherTableIsNull()
{
CsvTable table2 = null;
var result = _defaultTable.Equals(table2);
Assert.False(result);
_defaultParserMock.Verify(p => p.ParseCells(string.Empty), Times.Never);
_defaultRowsReaderMock.Verify(r => r.ReadAllLines(_pathToDefaultTable), Times.Never);
}
static void Main(string[] args)
{
//
//tmp file_path
// tmp --header-first-row=true
string file_path = @"c:\temp\file1.csv";
CsvTable ct = new CsvTable(file_path, true);
ct.ConsolePrint();
}
public CsvTableTests()
{
_defaultParserMock = new Mock <CellsParserBase>();
_defaultParserMock.Setup(p => p.ParseCells(string.Empty)).Returns(Enumerable.Repeat("Cell", 3).ToArray());
_defaultRowsReaderMock = new Mock <ITableRowsReader>();
_defaultRowsReaderMock.Setup(r => r.ReadAllLines(_pathToDefaultTable)).Returns(Enumerable.Repeat(string.Empty, 3).ToArray());
_defaultTable = new CsvTable(_pathToDefaultTable, _defaultParserMock.Object, _defaultRowsReaderMock.Object);
}
public void EqualsForEqualTables()
{
var table2 = new CsvTable(_pathToDefaultTable, _defaultParserMock.Object, _defaultRowsReaderMock.Object);
var result = _defaultTable.Equals(table2);
Assert.True(result);
_defaultParserMock.Verify(p => p.ParseCells(string.Empty), Times.AtLeastOnce);
_defaultRowsReaderMock.Verify(r => r.ReadAllLines(_pathToDefaultTable), Times.AtLeastOnce);
}
// Token: 0x06000094 RID: 148 RVA: 0x00004DE8 File Offset: 0x00002FE8
public LogIndex(string logFilePath, CsvTable table, CsvField columnToIndex, bool isActive)
{
this.logFilePath = logFilePath;
this.table = table;
this.columnToIndex = columnToIndex;
this.columnIdToIndex = table.NameToIndex(columnToIndex.Name);
this.normalizeMethod = columnToIndex.NormalizeMethod;
this.indexFileDirectory = Path.Combine(Path.GetDirectoryName(logFilePath), "index");
this.isActive = isActive;
}
public override string ToString()
{
string result = null;
if (CsvTable != null)
{
result = GetCsvRawData(CsvTable.CreateDataReader(), ColumnList, true);
}
return(result);
}
private UIInfo LoadCsvAndCreateUIInfo()
{
var spriteFolderPath = PreferHelper.defultSpriteFolder;
if (string.IsNullOrEmpty(spriteFolderPath))
{
DialogHelper.ShowDialog("错误提示", "图片加载路径不能为空", "确认");
}
else
{
var configPath = GetConfigFilePath();
CsvTable table = null;
pos_readdoc:
if (File.Exists(configPath))
{
try
{
table = CsvHelper.ReadCSV(configPath, System.Text.Encoding.GetEncoding("GB2312"));
}
catch (Exception e)
{
var reopen = DialogHelper.ShowDialog("提示", e.Message, "重试", "取消");
if (reopen)
{
goto pos_readdoc;
}
}
if (table != null)
{
var canLoad = table.IsUIInfoTable(false);
if (canLoad)
{
var isTitleMatch = table.IsUIInfoTable(true);
if (!isTitleMatch)
{
var forceLoad = DialogHelper.ShowDialog("文档标题不匹配", string.Join(",", UIInfo_TableExtend.uiInfoHead) + "\n继续请按确认！", "确认", "取消");
if (!forceLoad)
{
return(null);
}
}
return(table.LoadUIInfo());
}
else
{
DialogHelper.ShowDialog("配制文档不可用", "请核对后重试！", "确认");
}
}
}
}
return(null);
}
public CsvTable GetFieldInfoFromConfig( string defaultFileName, string culture)
{
var cfg = this;
cfg.SrcFileName = cfg.SrcFileName ?? defaultFileName;
var formatInfo = CultureInfo.GetCultureInfo(culture ?? "");
var csvTable = new CsvTable
{
NoHeader = cfg.NoHeader,
Delimiter = (cfg.Separator ?? ",").Replace(' ', (char)9)[0],
FormatInfo = formatInfo
};
foreach (var field in cfg.Fields)
{
csvTable.Fields.Add(field.Column, new CsvField { Name = field.Name, IsOptional = field.IsOptional });
}
return csvTable;
}
public static IEnumerable<ParsedData> ParseCsvLog(Stream file) {
Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;
var csv = new CsvTable(file, true, true, ',', "windows-1252");
return
csv.Select(
row =>
new ParsedData()
{
Time = DateTime.Parse(row["Date"] + " " + row["Time"]),
Name = row["Name"],
Status = row["Status"],
Currency = row["Currency"],
Gross = double.Parse(row["Gross"]),
Net = double.Parse(row["Net"]),
Email = row["From Email Address"],
TransactionID = row["Transaction ID"],
ItemName = row["Item Title"],
ItemCode = row["Item ID"]
});
}
