/// <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);
}
}
