/// <summary> /// Receives generating data type and index to be casted into CsvProduct class which is then used to fill up the csvOutput. /// /// Writes summary in the cnosole for each callback. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="data"></param> /// <param name="index"></param> /// <returns></returns> public async override Task <Task> ParseAsync <T>(T data, int index) { CsvProduct product = (CsvProduct)Convert.ChangeType(data, typeof(CsvProduct)); CsvOutput output = new CsvOutput { Filename = GetFileReader().GetFilename(), Id = product.Id, Quantity = product.Quantity, Price = product.Price }; await SemaphoreSlim.WaitAsync(); try { if (AsyncFileWriter) { CsvOutputSerializer csv = new CsvOutputSerializer(output); await GetStreamWriter().WriteLineAsync(csv.ToCsvString()); } else { await AppendOutput(output); } Console.WriteLine("[CSV PARSER ] Processing line: {0} of file: {1}", index + 1, GetFileReader().GetFilename()); } finally { SemaphoreSlim.Release(); } return(Task.CompletedTask); }
/// <summary> /// Writes the curve settings in a CSV format to an appendable. /// </summary> /// <param name="underlying"> the underlying appendable destination </param> /// <param name="group"> the curve group </param> public static void writeCurveSettings(Appendable underlying, RatesCurveGroup group) { CsvOutput csv = CsvOutput.standard(underlying); // header csv.writeLine(HEADERS_SETTINGS); // rows IDictionary <Currency, Curve> discountingCurves = group.DiscountCurves; ISet <CurveName> names = new HashSet <CurveName>(); foreach (KeyValuePair <Currency, Curve> entry in discountingCurves.SetOfKeyValuePairs()) { Curve curve = entry.Value; csv.writeLine(curveSettings(curve)); names.Add(curve.Name); } IDictionary <Index, Curve> forwardCurves = group.ForwardCurves; foreach (KeyValuePair <Index, Curve> entry in forwardCurves.SetOfKeyValuePairs()) { Curve curve = entry.Value; if (!names.Contains(curve.Name)) { csv.writeLine(curveSettings(curve)); names.Add(curve.Name); } } }
// write a single group to CSV private static void writeCurveGroup(CsvOutput csv, RatesCurveGroup group) { string groupName = group.Name.Name; IDictionary <Currency, Curve> discountingCurves = group.DiscountCurves; foreach (KeyValuePair <Currency, Curve> entry in discountingCurves.SetOfKeyValuePairs()) { IList <string> line = new List <string>(4); line.Add(groupName); line.Add(DISCOUNT); line.Add(entry.Key.ToString()); line.Add(entry.Value.Name.Name); csv.writeLine(line); } IDictionary <Index, Curve> forwardCurves = group.ForwardCurves; foreach (KeyValuePair <Index, Curve> entry in forwardCurves.SetOfKeyValuePairs()) { IList <string> line = new List <string>(4); line.Add(groupName); line.Add(FORWARD); line.Add(entry.Key.ToString()); line.Add(entry.Value.Name.Name); csv.writeLine(line); } }
/// <summary> /// Writes the curve nodes in a CSV format to an appendable. /// </summary> /// <param name="underlying"> the underlying appendable destination </param> /// <param name="valuationDate"> the valuation date </param> /// <param name="group"> the curve group </param> public static void writeCurveNodes(Appendable underlying, LocalDate valuationDate, RatesCurveGroup group) { CsvOutput csv = CsvOutput.standard(underlying); // header csv.writeLine(HEADERS_NODES); // rows string valuationDateStr = valuationDate.ToString(); IDictionary <Currency, Curve> discountingCurves = group.DiscountCurves; ISet <CurveName> names = new HashSet <CurveName>(); foreach (KeyValuePair <Currency, Curve> entry in discountingCurves.SetOfKeyValuePairs()) { Curve curve = entry.Value; nodeLines(valuationDateStr, curve, csv); names.Add(curve.Name); } IDictionary <Index, Curve> forwardCurves = group.ForwardCurves; foreach (KeyValuePair <Index, Curve> entry in forwardCurves.SetOfKeyValuePairs()) { Curve curve = entry.Value; if (!names.Contains(curve.Name)) { nodeLines(valuationDateStr, curve, csv); names.Add(curve.Name); } } }
public void TestExpectingFileOutputToBeEmptyWhenCalledWithEmptyIDictionary() { CsvOutput mockOutput = new CsvOutput("Random_file_path"); mockOutput.WriteOutput(new List <List <string> >()); Assert.True(mockOutput.FileOutput.Count == 0); }
public void TestExpectingFileOutputToBeEmptyWhenCalledWithEmptyTwoDimensionalIEnumerableOfAnalysedData() { CsvOutput mockOutput = new CsvOutput("output.csv"); mockOutput.WriteOutput(new List <List <string> >()); Assert.True(mockOutput.FileOutput.Count == 0); }
public void TestExpectingFileOutputToBeEmptyWhenCalledWithEmptyIDictionary() { CsvOutput mockOutput = new CsvOutput(@"D:\a\review-case-s21b4\review-case-s21b4\ReceiverTests\EmptyOutput.csv"); mockOutput.WriteOutput(new List <List <string> >()); Assert.True(mockOutput.FileOutput.Count == 0); }
//------------------------------------------------------------------------- /// <summary> /// Write sensitivities to an appendable in the standard sensitivities format. /// <para> /// The output is written in standard format, with no identifier columns. /// The parameter metadata must contain tenors. /// /// </para> /// </summary> /// <param name="curveSens"> the curve sensitivities to write </param> /// <param name="output"> the appendable to write to </param> /// <exception cref="IllegalArgumentException"> if the metadata does not contain tenors </exception> /// <exception cref="UncheckedIOException"> if an IO error occurs </exception> public void write(CurveSensitivities curveSens, Appendable output) { CsvOutput csv = CsvOutput.standard(output, "\n"); IList <string> additionalHeaders = supplier.headers(curveSens); // check for dates if (curveSens.TypedSensitivities.values().stream().flatMap(allParamSens => allParamSens.Sensitivities.stream()).flatMap(paramSens => paramSens.ParameterMetadata.stream()).anyMatch(pmd => !(pmd is TenoredParameterMetadata))) { throw new System.ArgumentException("Parameter metadata must contain tenors"); } bool containsDates = curveSens.TypedSensitivities.values().stream().flatMap(allParamSens => allParamSens.Sensitivities.stream()).flatMap(paramSens => paramSens.ParameterMetadata.stream()).anyMatch(pmd => pmd is DatedParameterMetadata); // headers csv.writeCell(SensitivityCsvLoader.REFERENCE_HEADER); csv.writeCell(SensitivityCsvLoader.TYPE_HEADER); csv.writeCell(SensitivityCsvLoader.TENOR_HEADER); if (containsDates) { csv.writeCell(SensitivityCsvLoader.DATE_HEADER); } csv.writeCell(SensitivityCsvLoader.CURRENCY_HEADER); csv.writeCell(SensitivityCsvLoader.VALUE_HEADER); csv.writeLine(additionalHeaders); // content, grouped by reference, then type MapStream.of(curveSens.TypedSensitivities).flatMapValues(sens => sens.Sensitivities.stream()).mapKeys((type, sens) => Pair.of(sens.MarketDataName.Name, type)).sortedKeys().forEach((pair, paramSens) => write(pair.First, pair.Second, curveSens, paramSens, additionalHeaders, containsDates, csv)); }
/// <summary> /// This methods is async since it runs a in async mode so we'll fill up csvOutput concurrently. /// </summary> /// <param name="item"></param> /// <returns></returns> public async Task AppendOutput(CsvOutput item) { await Task.Run(() => { CsvOutput.Add(item); }); }
public void TestExpectingNoExceptionWhenFileFormatIsValid() { CsvOutput object1 = new CsvOutput("output.csv"); Assert.False(object1.OutputStatus); object1 = new CsvOutput("output.xlsx"); Assert.False(object1.OutputStatus); }
public void Setup() { _configuration = Substitute.For <IConfiguration>(); _summaryRecord = Substitute.For <ISummaryRecord>(); _configuration.GetValue <string>("OutputFilesDirectory") .Returns("D:\\WTWDIP\\ClaimsReserving\\ClaimsReserving\\OutputFiles"); _target = new CsvOutput(_configuration, _summaryRecord); }
//------------------------------------------------------------------------- /// <summary> /// Outputs the report table in CSV format. /// </summary> /// <param name="report"> the report </param> /// <param name="out"> the output stream to write to </param> //JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @SuppressWarnings("resource") public void writeCsv(R report, java.io.OutputStream out) public virtual void writeCsv(R report, Stream @out) { StreamWriter outputWriter = new StreamWriter(@out, Encoding.UTF8); CsvOutput csvOut = CsvOutput.safe(outputWriter); csvOut.writeLine(report.ColumnHeaders); IntStream.range(0, report.RowCount).mapToObj(rowIdx => formatRow(report, rowIdx, ReportOutputFormat.CSV)).forEach(csvOut.writeLine); Unchecked.wrap(outputWriter.flush); }
public void TestExpectingAppropriateReadInputMethodToBeCalled() { MockConsoleInput mockConsoleInput = new MockConsoleInput("3", "3"); string filepath = "same_random_path"; CsvOutput output = new CsvOutput(filepath); Controller controller = new Controller(mockConsoleInput, output); var outputRead = (List <List <string> >)controller.ReadInput(); Assert.Equal("sample00", outputRead[0][0]); }
/// <summary> /// Writes the curve group in a CSV format to an appendable. /// </summary> /// <param name="underlying"> the underlying appendable destination </param> /// <param name="groups"> the curve groups </param> public static void writeCurveGroup(Appendable underlying, params RatesCurveGroup[] groups) { CsvOutput csv = CsvOutput.standard(underlying); csv.writeLine(HEADERS); foreach (RatesCurveGroup group in groups) { writeCurveGroup(csv, group); } }
public void Setup() { _configuration = Substitute.For <IConfiguration>(); _configurationSection = Substitute.For <IConfigurationSection>(); _configurationSection.Value = "D:\\WTWDIP\\ClaimsReserving\\ClaimsReserving\\OutputFiles"; _configuration.GetSection(Arg.Any <string>()) .Returns(_configurationSection); _summaryRecord = Substitute.For <ISummaryRecord>(); _target = new CsvOutput(_configuration, _summaryRecord); }
public void TestExpectingCorrectAssignmentToControllersDataMembersWhenCalledWithValidObjects() { MockConsoleInput mockConsoleInput = new MockConsoleInput("3", "3"); string filepath = @"D:\a\review-case-s21b4\review-case-s21b4\ReceiverTests\output.csv"; CsvOutput csvOutput = new CsvOutput(filepath); Controller controller = new Controller(mockConsoleInput, csvOutput); Assert.Equal(mockConsoleInput, controller.InputInterface); Assert.Equal(csvOutput, controller.OutputInterface); }
public void TestExpectingAppropriateReadInputMethodToBeCalled() { MockConsoleInput mockConsoleInput = new MockConsoleInput("3", "3"); string filepath = @"D:\a\review-case-s21b4\review-case-s21b4\ReceiverTests\output.csv"; CsvOutput output = new CsvOutput(filepath); Controller controller = new Controller(mockConsoleInput, output); var outputRead = (List <List <string> >)controller.ReadInput(); Assert.Equal("sample00", outputRead[0][0]); }
public void TestExpectingStatusOfFileWrittenAsTrueWhenCalledWithDictionaryOfWordFrequency() { CsvOutput csvOutput = new CsvOutput("Random_file_path"); List <List <string> > testInput = new List <List <string> > { new List <string> { "sample1", "1" }, new List <string> { "sample2", "1" } }; csvOutput.WriteOutput(testInput); Assert.True(csvOutput.OutputStatus); }
public void TestExpectingStatusOfFileWrittenAsTrueWhenCalledWithTwoDimensionalIEnumerableOfAnalysedData() { CsvOutput csvOutput = new CsvOutput("output.csv"); List <List <string> > testInput = new List <List <string> > { new List <string> { "sample1", "1" }, new List <string> { "sample2", "1" } }; csvOutput.WriteOutput(testInput); Assert.True(csvOutput.OutputStatus); }
public void TestExpectingValidMockFileOutputWhenCalledWithTwoDimensionalIEnumerableOfAnalysedData() { CsvOutput mockOutput = new CsvOutput("output.csv"); List <List <string> > testInput = new List <List <string> > { new List <string> { "sample1", "1" }, new List <string> { "sample2", "2" } }; mockOutput.WriteOutput(testInput); Assert.Equal("sample1,1", mockOutput.FileOutput[0]); }
public void TestExpectingValidMockFileOutputWhenCalledWithDictionaryOfWordFrequency() { CsvOutput mockOutput = new CsvOutput("Random_file_path"); List <List <string> > testInput = new List <List <string> > { new List <string> { "sample1", "1" }, new List <string> { "sample2", "2" } }; mockOutput.WriteOutput(testInput); Assert.Equal("sample1,1", mockOutput.FileOutput[0]); }
public void TestExpectingValidMockFileOutputWhenCalledWithDictionaryOfWordFrequency() { CsvOutput mockOutput = new CsvOutput(@"D:\a\review-case-s21b4\review-case-s21b4\ReceiverTests\WordCountOutput.csv"); List <List <string> > testInput = new List <List <string> > { new List <string> { "sample1", "1" }, new List <string> { "sample2", "2" } }; mockOutput.WriteOutput(testInput); Assert.Equal("sample1,1", mockOutput.FileOutput[0]); }
public void TestExpectingStatusOfFileWrittenAsTrueWhenCalledWithDictionaryOfWordFrequency() { CsvOutput csvOutput = new CsvOutput(@"D:\a\review-case-s21b4\review-case-s21b4\ReceiverTests\StatusOutput.csv"); List <List <string> > testInput = new List <List <string> > { new List <string> { "sample1", "1" }, new List <string> { "sample2", "1" } }; csvOutput.WriteOutput(testInput); Assert.True(csvOutput.OutputStatus); }
public void Setup() { // We'll be using ; as a delimiter to generate a CSV output (single line). Delimiter = ";"; // CsvOutput with values to be used in this test context Output = new CsvOutput() { Filename = "test.csv", Id = "ABCDEF", Quantity = 1000, Price = 7.62 }; CsvSerializer = new CsvOutputSerializer(Output, Delimiter); }
// write a single group definition to CSV private static void writeCurveGroupDefinition(CsvOutput csv, RatesCurveGroupDefinition group) { string groupName = group.Name.Name; foreach (RatesCurveGroupEntry entry in group.Entries) { foreach (Currency currency in entry.DiscountCurrencies) { csv.writeLine(ImmutableList.of(groupName, DISCOUNT, currency.ToString(), entry.CurveName.Name)); } foreach (Index index in entry.Indices) { csv.writeLine(ImmutableList.of(groupName, FORWARD, index.ToString(), entry.CurveName.Name)); } } }
/// <summary> /// Receives genereric data with an index and converts it into a JSON serialized object of class JsonProduct by converting the generic data into a string. /// /// Prints summary in the console and fills the csvOutput later used to generate final output file. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="data"></param> /// <param name="index"></param> /// <returns></returns> public async override Task <Task> ParseAsync <T>(T data, int index) { try { string json = (string)Convert.ChangeType(data, typeof(string)); var product = JsonConvert.DeserializeObject <JsonProduct>(json); CsvOutput output = new CsvOutput { Filename = GetFileReader().GetFilename(), Id = product.Id, Quantity = product.Quantity, Price = product.Price }; await SemaphoreSlim.WaitAsync(); try { if (AsyncFileWriter) { CsvOutputSerializer csv = new CsvOutputSerializer(output); await GetStreamWriter().WriteLineAsync(csv.ToCsvString()); } else { await AppendOutput(output); } Console.WriteLine("[JSON PARSER] Processing line: {0} of file: {1}", index, GetFileReader().GetFilename()); } finally { SemaphoreSlim.Release(); } } catch (Exception) { Console.WriteLine("[JSON PARSER] ERROR: Unable to parse JSON object on line {0} of file: {1}", index, GetFileReader().GetFilename()); } return(Task.CompletedTask); }
// add each node to the csv file private static void nodeLines(string valuationDateStr, Curve curve, CsvOutput csv) { ArgChecker.isTrue(curve is InterpolatedNodalCurve, "interpolated"); InterpolatedNodalCurve interpolatedCurve = (InterpolatedNodalCurve)curve; int nbPoints = interpolatedCurve.XValues.size(); for (int i = 0; i < nbPoints; i++) { ArgChecker.isTrue(interpolatedCurve.getParameterMetadata(i) is DatedParameterMetadata, "Curve metadata must contain a date, but was " + interpolatedCurve.getParameterMetadata(i).GetType().Name); DatedParameterMetadata metadata = (DatedParameterMetadata)interpolatedCurve.getParameterMetadata(i); IList <string> line = new List <string>(); line.Add(valuationDateStr); line.Add(curve.Name.Name.ToString()); line.Add(metadata.Date.ToString()); line.Add(decimal.valueOf(interpolatedCurve.YValues.get(i)).toPlainString()); line.Add(metadata.Label); csv.writeLine(line); } }
public void TestExpectingAppropriateWriteOutputMethodToBeCalledWhenCalledWithValidIDictionary() { MockConsoleInput mockInput = new MockConsoleInput("3", "3"); string filepath = "same_random_path"; CsvOutput output = new CsvOutput(filepath); Controller controller = new Controller(mockInput, output); List <List <string> > testInput = new List <List <string> > { new List <string> { "sample1", "2" }, new List <string> { "sample2", "5" } }; controller.WriteOutput(testInput); Assert.True(output.OutputStatus); Assert.Equal("sample1,2", output.FileOutput[0]); }
public CsvOutputSerializer(CsvOutput output, string delimiter = ";") { Output = output; Delimiter = delimiter; }
// writes the rows for a single CurrencyParameterSensitivity private void write(string reference, CurveSensitivitiesType type, CurveSensitivities curveSens, CurrencyParameterSensitivity paramSens, IList <string> additionalHeaders, bool containsDates, CsvOutput csv) { IList <string> additionalCells = supplier.values(additionalHeaders, curveSens, paramSens); for (int i = 0; i < paramSens.ParameterCount; i++) { ParameterMetadata pmd = paramSens.getParameterMetadata(i); Tenor tenor = ((TenoredParameterMetadata)pmd).Tenor; double value = paramSens.Sensitivity.get(i); csv.writeCell(reference); csv.writeCell(type.Name); csv.writeCell(tenor.ToString()); if (containsDates) { csv.writeCell(pmd is DatedParameterMetadata ? ((DatedParameterMetadata)pmd).Date.ToString() : ""); } csv.writeCell(paramSens.Currency.Code); csv.writeCell(decimal.valueOf(value).toPlainString()); csv.writeLine(additionalCells); } }