private static void WriteOutput(AggregationOptions opts, DateTime currentMinDate, List <List <double> > sums)
{
List <string> fields = new List <string> {
opts.AggregationPeriod.DateText(currentMinDate)
};
fields.AddRange(sums.Select(list => list.Any() ? opts.AggregationFunc(list).ToString("f") : string.Empty));
Console.Write(string.Join(opts.Delimiter ?? "\t", fields) + "\n");
}
public virtual async Task <IHttpActionResult> GetFacets(string facets, string userFilter = null, string query = null)
{
var systemFilter = GetSystemFilter(HasOrganizationFilter(query), _supportsSoftDeletes);
var fo = AggregationOptions.Parse(facets);
var res = await _repository.GetAggregationsAsync(systemFilter, fo, userFilter);
return(Ok(res));
}
/// <summary>
/// Creates a new instance of <see cref="DataSetAggregator"/>.
/// </summary>
/// <param name="protocol">Protocol for wich the aggregation is calculated.</param>
/// <exception cref="ArgumentNullException">
/// If <paramref name="protocol"/> is <see langword="null"/>.
/// </exception>
public DataSetAggregator(ProtocolDescriptor protocol)
{
if (protocol == null)
{
throw new ArgumentNullException(nameof(protocol));
}
_protocol = protocol;
_accumulator = new DataSetValueAccumulator();
Options = new AggregationOptions();
}
public void OptionUpdate(List <string> args, AggregationOptions options)
{
// Single character version
string input = args[1];
if (input.Length == 1)
{
char periodChar = input[0];
AggregationPeriod period = AggregationPeriod.AllPeriods.FirstOrDefault(p => p.Flag == periodChar);
options.AggregationPeriod = period ?? throw new NotImplementedException($"Could not find period corresponding to {periodChar}");
}
else
{
AggregationPeriod period = AggregationPeriod.AllPeriods.FirstOrDefault(p => string.Equals(p.Description, input, StringComparison.OrdinalIgnoreCase));
options.AggregationPeriod = period ?? throw new NotImplementedException($"Could not find period corresponding to {input}");
}
}
public async Task <IHttpActionResult> GetInternal(SystemFilterQuery systemFilter = null, string userFilter = null, string query = null, string sort = null, string offset = null, string mode = null, int page = 1, int limit = 10, string facet = null)
{
page = GetPage(page);
limit = GetLimit(limit);
var skip = GetSkip(page + 1, limit);
if (skip > MAXIMUM_SKIP)
{
return(BadRequest("Cannot get requested page"));
}
if (systemFilter == null)
{
systemFilter = GetSystemFilter(HasOrganizationFilter(query), _supportsSoftDeletes);
}
var fo = AggregationOptions.Parse(facet);
FindResults <TModel> results;
try {
results = await _repository.SearchAsync(systemFilter, userFilter, query, sort, new PagingOptions { Limit = limit, Page = page }, fo);
} catch (ApplicationException ex) {
ex.ToExceptionless().SetProperty("Search Filter", new { SystemFilter = systemFilter, UserFilter = query, Sort = sort, Offset = offset, Page = page, Limit = limit }).AddTags("Search").Submit();
return(BadRequest("An error has occurred. Please check your search filter."));
}
if (!String.IsNullOrEmpty(mode) && String.Equals(mode, "summary", StringComparison.InvariantCultureIgnoreCase))
{
return(OkWithResourceLinks(await MapCollection <TViewModel>(results.Documents, true), results.HasMore, page, results.Total));
}
var mappedModels = await MapCollection <TViewModel>(results.Documents, true);
var hasMore = results.HasMore && !NextPageExceedsSkipLimit(page, limit);
if (facet != null)
{
var wrappedResult = new ResultWithFacets <TViewModel> {
Results = mappedModels, Facets = results.Aggregations
};
return(OkWithResourceLinks(wrappedResult, hasMore, page, results.Total));
}
return(OkWithResourceLinks(mappedModels, hasMore, page, results.Total));
}
public void OptionUpdate(List <string> args, AggregationOptions options) => options.VersionWanted = true;
public void OptionUpdate(List <string> args, AggregationOptions options)
{
options.Delimiter = args.Last();
}
public void OptionUpdate(List <string> args, AggregationOptions options)
{
options.SkipRows = int.Parse(args.Last());
}
static void Main(string[] args)
{
List <IOption> availableOptions = new List <IOption>
{
new AggregationPeriodOption(),
new DelimiterOption(),
new HeaderSkipOption(),
new AggregationFunctionOption(),
new HelpOption(),
new VersionOption(),
};
var argList = args.ToList();
AggregationOptions opts = new AggregationOptions();
for (int i = 0; i < args.Length; i++)
{
string arg = args[i];
var option = availableOptions.FirstOrDefault(o => (("-" + o.ShortName) == arg || ("--" + o.LongName) == arg));
if (option == null)
{
if (i != args.Length - 1)
{
Console.Out.WriteLine($"Unknown option {arg}");
Environment.ExitCode = 2;
return;
}
opts.Filename = args[i];
continue;
}
try
{
option.OptionUpdate(argList.GetRange(i, option.ArgsConsumed), opts);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
return;
}
i += (option.ArgsConsumed - 1);
}
if (opts.HelpWanted)
{
Console.Out.WriteLine("USAGE: agg [options...] file\n\nOptions: Description [Default]");
IEnumerable <string> optionText = availableOptions.Select(option => $" -{option.ShortName} --{ $"{option.LongName} {(option.ArgsConsumed == 2 ? $"<{option.LongName}>" : "")}",-15} {option.HelpText}\n");
Console.Out.Write(string.Join(string.Empty, optionText));
return;
}
if (opts.VersionWanted)
{
Console.Out.WriteLine("Version 0.2.0\nCopyright Mitchell T. Paulus 2019");
return;
}
IEnumerable <string> lines;
if (!Console.IsInputRedirected)
{
//Console.WriteLine("Reading from File...");
string fullFilename = Path.GetFullPath(opts.Filename);
lines = File.ReadLines(fullFilename, Encoding.UTF8).Skip(opts.SkipRows);
}
else
{
//Console.WriteLine("Reading from standard input ...");
List <string> standardInputLines = new List <string>();
string line;
while ((line = Console.In.ReadLine()) != null)
{
standardInputLines.Add(line);
}
lines = standardInputLines.Skip(opts.SkipRows);
}
List <(DateTime dateTime, List <string> rawData)> allData = new List <(DateTime dateTime, List <string> rawData)>();
int lineNumber = 1 + opts.SkipRows;
foreach (string line in lines)
{
var fields = line.Split(opts.Delimiter);
string dateInput = fields[0];
bool success = DateTime.TryParse(dateInput, out DateTime dateTime);
if (!success)
{
Console.WriteLine($"Could not parse the date/time {dateInput} on line {lineNumber}."); Environment.ExitCode = 1; return;
}
List <string> data = fields.ToList().Skip(1).ToList();
allData.Add((dateTime, data));
lineNumber++;
}
// If no lines, then max is set to 0.
if (!allData.Any())
{
return;
}
int maxFields = allData.Max(tuple => tuple.rawData.Count);
DateTime minDate = opts.AggregationPeriod.RoundDown(allData.Min(tuple => tuple.dateTime));
allData.Sort((tuple1, tuple2) => DateTime.Compare(tuple1.dateTime, tuple2.dateTime));
DateTime currentMinDate = minDate;
DateTime currentMaxDate = opts.AggregationPeriod.Next(minDate);
List <List <double> > sums = new List <List <double> >();
for (int i = 0; i < maxFields; i++)
{
sums.Add(new List <double>());
}
foreach ((DateTime dateTime, List <string> data) in allData)
{
if (dateTime >= currentMaxDate)
{
WriteOutput(opts, currentMinDate, sums);
foreach (List <double> doubles in sums)
{
doubles.Clear();
}
currentMinDate = currentMaxDate;
currentMaxDate = opts.AggregationPeriod.Next(currentMaxDate);
}
// In the case of missing data, need to push the current max date until it
// goes ahead of the current datetime.
while (dateTime >= currentMaxDate)
{
WriteOutput(opts, currentMinDate, sums);
currentMinDate = currentMaxDate;
currentMaxDate = opts.AggregationPeriod.Next(currentMaxDate);
}
for (int i = 0; i < data.Count; i++)
{
string dataPoint = data[i];
// Skip fields with whitespace.
if (string.IsNullOrWhiteSpace(dataPoint))
{
continue;
}
bool success = double.TryParse(dataPoint, out double value);
if (!success)
{
Console.WriteLine($"Could not parse the field {dataPoint} in position {i}/{data.Count} on row {lineNumber}.");
Environment.ExitCode = 3;
return;
}
sums[i].Add(value);
}
}
// Need to write the final output.
WriteOutput(opts, currentMinDate, sums);
}
