/// <summary>Execute a comparison. Normally done implicitly</summary>
public void RunComparison()
{
// Load both time series if needed
_result.Clear();
_expected.Load();
_actual.Load();
if (_expected.Measurements.Count + _actual.Measurements.Count == 0)
{
return;
}
var actualDictionary = DictionaryFrom(_actual.Measurements, "actual");
var metaDataExpected = new TimeSeriesMetadata <Measurement>(_expected.Measurements, point => point.Value);
var metaDataActual = new TimeSeriesMetadata <Measurement>(_actual.Measurements, point => point.Value);
_compareType = metaDataExpected.DataType ?? metaDataActual.DataType;
// These comparisons ignore NaN values unless they are both NaN
_minValue = Min(metaDataExpected.MinValue, metaDataActual.MinValue);
_maxValue = Max(metaDataExpected.MaxValue, metaDataActual.MaxValue);
// range is 0 if the extremes are NaN
_tolerance.DataRange = metaDataExpected.Range;
SetTimeSpanSeconds();
CompareExpectedToActuals(actualDictionary);
MarkUncoveredActualsAsSurplus(actualDictionary);
}
public IActionResult GetTimeSeriesDataById(string timeseriesId, string from = "", string to = "", string step = "", int pageSize = 20, int offset = 0)
{
TimeSeriesMetadata timeseriesMetadata = _timeSeriesMetadataService.GetTimeSeriesMetadata(timeseriesId);
InfluxResult <DynamicInfluxRow> measurementsResult = _timeSeriesService.ReadMeasurementById(timeseriesMetadata.InfluxId.ToString(), from, to, step).Result;
return(MakePageFromMeasurements(measurementsResult, pageSize, offset));
}
/// <summary>
/// constructs from the object which this model represents
/// </summary>
/// <param name="timeSeriesMetadata"></param>
public TimeSeriesMetadataModel(TimeSeriesMetadata timeSeriesMetadata)
{
Id = timeSeriesMetadata.Id.ToString();
Name = timeSeriesMetadata.Name;
Description = timeSeriesMetadata.Description;
DateCreated = timeSeriesMetadata.DateCreated.ToString();
DateModified = timeSeriesMetadata.DateModified.ToString();
UserId = timeSeriesMetadata.UserId.ToString();
InfluxId = timeSeriesMetadata.InfluxId.ToString();
}
/// <summary>
/// Creates new time-series metadata entity owned by user given by userId
/// </summary>
/// <param name="name"></param>
/// <param name="description"></param>
/// <param name="userId"></param>
/// <returns></returns>
public async Task <TimeSeriesMetadata> AddTimeseriesMetadata(string name, string description, string userId)
{
User user = _userService.GetUser(new Guid(userId));
TimeSeriesMetadata t = TimeSeriesMetadata.Create(name, user, description);
_timeSeriesMetadataRepository.Add(t);
await _timeSeriesMetadataRepository.SaveChangesAsync();
return(t);
}
public IActionResult GetTimeSeriesMetadataById([FromRoute] string timeSeriesMetadataId)
{
TimeSeriesMetadata timeSeriesMetadata = _timeSeriesMetadataService.GetTimeSeriesMetadata(timeSeriesMetadataId);
if (timeSeriesMetadata == null || !timeSeriesMetadata.UserId.ToString().Equals(UserId))
{
return(NotFound("this user does not have this timeseries"));
}
return(Ok(new TimeSeriesMetadataModel(timeSeriesMetadata)));
}
public IActionResult UpdateTimeSeriesMetadata([FromRoute] string timeSeriesMetadataId, [FromBody] TimeSeriesMetadataModel model)
{
TimeSeriesMetadata timeSeriesMetadata = _timeSeriesMetadataService.GetTimeSeriesMetadata(timeSeriesMetadataId);
if (timeSeriesMetadata == null || !timeSeriesMetadata.UserId.ToString().Equals(UserId))
{
return(NotFound("this user does not have this timeseries"));
}
_timeSeriesMetadataService.UpdateTimeSeriesMetadata(timeSeriesMetadataId, model.Name, model.Description).Wait();
return(Ok("ok"));
}
/// <summary>
/// Deletes time-series metadata object.
/// </summary>
/// <param name="guid"></param>
/// <returns></returns>
public async Task DeleteTimeSeriesMetadata(string guid)
{
TimeSeriesMetadata ts = _timeSeriesMetadataRepository.GetById(new Guid(guid));
if (ts == null)
{
throw new NotFoundException("this time-series is not found");
}
_timeSeriesMetadataRepository.Delete(ts);
await _timeSeriesMetadataRepository.SaveChangesAsync();
}
public async Task <IActionResult> UploadCsvData([FromRoute] string timeSeriesMetadataId, [FromForm] IFormFile formFile)
{
// todo: update rows and columns metadata after extraction
TimeSeriesMetadata timeSeriesMetadata = _timeSeriesMetadataService.GetTimeSeriesMetadata(timeSeriesMetadataId);
if (!(timeSeriesMetadata != null && timeSeriesMetadata.UserId.ToString().Equals(UserId)))
{
return(NotFound("this user does not have timeseries given by this id"));
}
string measurementId = timeSeriesMetadata.InfluxId.ToString();
List <string> fileContent = await ReadAsStringAsync(formFile);
await _timeSeriesService.UploadDataFromCsv(measurementId, fileContent);
return(Ok());
}
public void TimeSeriesDataRangeTest(string testCase, int measurementCount, string lowValue, string highValue, double expectedRange)
{
var timeSeries = new TimeSeries();
for (var i = 0; i < measurementCount; i++)
{
var measurement = new Measurement
{
Value = i < measurementCount / 2 ? lowValue : highValue,
Timestamp = DateTime.Now,
IsGood = true
};
timeSeries.AddMeasurement(measurement);
}
var metadata = new TimeSeriesMetadata <Measurement>(timeSeries.Measurements, p => p.Value);
Assert.AreEqual(expectedRange, metadata.Range, $"Test {testCase}");
}
public void TimeSeriesDataTypeTest(string testCase, int measurementCount, string value1, string value2, string expectedType)
{
var timeSeries = new TimeSeries();
for (var i = 0; i < measurementCount; i++)
{
var measurement = new Measurement
{
Value = i < measurementCount / 2 ? value1 : value2,
Timestamp = DateTime.Now,
IsGood = true
};
timeSeries.AddMeasurement(measurement);
}
var metadata = new TimeSeriesMetadata <Measurement>(timeSeries.Measurements, p => p.Value);
Assert.AreEqual(expectedType, metadata.DataType.ToString(), $"Test {testCase}");
}
public IActionResult DeleteTimeSeriesById([FromRoute] string timeSeriesMetadataId)
{
TimeSeriesMetadata timeSeriesMetadata = _timeSeriesMetadataService.GetTimeSeriesMetadata(timeSeriesMetadataId);
if (timeSeriesMetadata == null || !timeSeriesMetadata.UserId.ToString().Equals(UserId))
{
return(NotFound("user does not have this timeseries"));
}
string timeSeriesId = timeSeriesMetadata.InfluxId.ToString();
InfluxResult result = _timeSeriesService.DeleteMeasurementById(timeSeriesId).Result;
if (!result.Succeeded)
{
return(NotFound());
}
_timeSeriesMetadataService.DeleteTimeSeriesMetadata(timeSeriesMetadataId).Wait();
return(NoContent());
}
/// <summary>
/// Updates time-series metadata with new name and description
/// </summary>
/// <param name="guid"></param>
/// <param name="name"></param>
/// <param name="description"></param>
/// <returns></returns>
public async Task <TimeSeriesMetadata> UpdateTimeSeriesMetadata(string guid, string name, string description)
{
TimeSeriesMetadata t = _timeSeriesMetadataRepository.GetById(new Guid(guid));
if (t == null)
{
throw new NotFoundException("this time-series is not found");
}
if (name == "")
{
name = t.Name;
}
if (description == "")
{
description = t.Description; // maybe default value instead of ""
}
t.Modify(name, description);
await _timeSeriesMetadataRepository.SaveChangesAsync();
return(t);
}
/// <summary>
/// Invoke the processor.
/// </summary>
/// <param name="metadata">The <see cref="TimeSeriesMetadata"/>.</param>
/// <param name="dataPoint"><see cref="DataPoint{T}"/> to process.</param>
/// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
public Task Invoke(TimeSeriesMetadata metadata, object dataPoint)
{
var parameters = Method.GetParameters();
var arguments = new object[parameters.Length];
for (var parameterIndex = 0; parameterIndex < parameters.Length; parameterIndex++)
{
var parameter = parameters[parameterIndex];
if (parameter.ParameterType == typeof(TimeSeriesMetadata))
{
arguments[parameterIndex] = metadata;
}
if (parameter.ParameterType.IsGenericType &&
parameter.ParameterType.GetGenericTypeDefinition() == typeof(DataPoint <>))
{
arguments[parameterIndex] = dataPoint;
}
}
var missingArguments = new List <ParameterInfo>();
for (var parameterIndex = 0; parameterIndex < parameters.Length; parameterIndex++)
{
var parameter = parameters[parameterIndex];
if (arguments[parameterIndex] == null)
{
missingArguments.Add(parameter);
}
}
if (missingArguments.Count > 0)
{
throw new UnfulfilledArgumentsForDataPointProcessor(Processor.GetType(), Method, missingArguments);
}
return(Method.Invoke(Processor, arguments) as Task);
}
