internal Tuple <List <SensorHistoryData>, int> GetSensorHistoryInternal(SensorHistoryParameters parameters)
{
var raw = ObjectEngine.GetObjectsRaw <SensorHistoryData>(parameters, ResponseParser.ValidateSensorHistoryResponse);
var data = ResponseParser.ParseSensorHistoryResponse(raw.Items, parameters.SensorId);
return(Tuple.Create(data, raw.TotalCount));
}
internal Tuple <List <SensorHistoryData>, int> GetSensorHistoryInternal(SensorHistoryParameters parameters)
{
var raw = ObjectEngine.GetObjectsRaw <SensorHistoryData>(parameters, responseParser: m => ResponseParser.GetSensorHistoryResponse(m, LogLevel, RequestEngine.IsDirty));
var data = ResponseParser.ParseSensorHistoryResponse(raw.Items, parameters.SensorId);
return(Tuple.Create(data, raw.TotalCount));
}
public void SensorHistoryParameters_GetsProperties()
{
var start = DateTime.Now;
var parameters = new SensorHistoryParameters(1001, 600, null, null, null);
Assert.AreEqual(parameters.StartDate.ToString(), start.ToString());
Assert.AreEqual(parameters.EndDate.ToString(), start.AddHours(-1).ToString());
Assert.AreEqual(parameters.Average, 600);
}
/// <summary>
/// Performs enhanced record-by-record processing functionality for the cmdlet.
/// </summary>
protected override void ProcessRecordEx()
{
if (ParameterSetName == ParameterSet.Default)
{
Id = Sensor.Id;
}
IEnumerable <PSObject> records;
var average = Average;
if (average == null)
{
//Sensor is implicitly not null because Downtime is part of the Default parameter set
average = Downtime ? Convert.ToInt32(Sensor.Interval.TotalSeconds) : 0;
}
else
{
if (Downtime && average == 0)
{
throw new InvalidOperationException($"Cannot retrieve downtime with an {nameof(Average)} of 0");
}
}
var parameters = new SensorHistoryParameters(Id, average.Value, StartDate, EndDate, Count);
if (EndDate == null)
{
StreamProvider.StreamResults = false;
}
if (EndDate != null)
{
StreamProvider.ForceStream = true;
records = StreamProvider.StreamResultsWithProgress(parameters, Count, () => GetFormattedRecords(parameters));
if (Count != null)
{
records = records.Take(Count.Value);
}
}
else if (ProgressManager.GetRecordsWithVariableProgress)
{
records = GetResultsWithVariableProgress(() => GetFormattedRecords(parameters));
}
else if (ProgressManager.GetResultsWithProgress)
{
records = GetResultsWithProgress(() => GetFormattedRecords(parameters));
}
else
{
records = GetFormattedRecords(parameters);
}
WriteList(records);
}
internal int GetSensorHistoryTotals(SensorHistoryParameters parameters)
{
parameters.Count = 0;
var data = ObjectEngine.GetObjectsRaw <SensorHistoryData>(parameters, responseParser: m => ResponseParser.GetSensorHistoryResponse(m, LogLevel, RequestEngine.IsDirty));
parameters.GetParameters().Remove(Parameter.Count);
return(Convert.ToInt32(data.TotalCount));
}
private IEnumerable <SensorHistoryData> StreamSensorHistoryInternal(SensorHistoryParameters parameters, bool serial)
{
return(ObjectEngine.StreamObjects(
parameters,
serial,
() => GetSensorHistoryTotals(parameters),
p => GetSensorHistoryInternalAsync(p, CancellationToken.None),
GetSensorHistoryInternal
));
}
internal int GetSensorHistoryTotals(SensorHistoryParameters parameters)
{
parameters.Count = 0;
var data = ObjectEngine.GetObjectsRaw <SensorHistoryData>(parameters, ResponseParser.ValidateSensorHistoryResponse);
parameters.GetParameters().Remove(Parameter.Count);
return(Convert.ToInt32(data.TotalCount));
}
private IEnumerable <PSObject> GetFormattedRecords(SensorHistoryParameters parameters)
{
IEnumerable <SensorHistoryRecord> records;
if (EndDate == null)
{
records = client.GetSensorHistoryInternal(parameters).Item1;
}
else
{
records = StreamProvider.StreamRecords <SensorHistoryRecord>(parameters, null);
}
var formatter = new SensorHistoryFormatter(this);
return(formatter.Format(records, EndDate != null, Count));
}
private void AdjustCountPeriod(SensorHistoryParameters parameters, int average)
{
//A count was specified without specifying an EndDate. We want to ensure the Start/End date range that
//is specified is capable of meeting the specified amount.
var sensor = Sensor;
if (ParameterSetName == ParameterSet.Manual && average == 0)
{
sensor = client.GetSensor(Id);
}
//If we're using the default average, get the total TimeSpan (in seconds) we need records for
var requiredSeconds = (average == 0 ? sensor.Interval.TotalSeconds : average) * Count.Value;
//An additional hour for good measure. Sometimes we can't scan according to our specified interval
var requiredTimeSpan = TimeSpan.FromSeconds(requiredSeconds + 3600);
var requiredEnd = parameters.StartDate - requiredTimeSpan;
parameters.StartDate = parameters.StartDate;
parameters.EndDate = requiredEnd;
}
internal async Task <List <SensorHistoryData> > GetSensorHistoryInternalAsync(SensorHistoryParameters parameters, CancellationToken token)
{
var items = await ObjectEngine.GetObjectsAsync <SensorHistoryData>(parameters, responseParser : m => ResponseParser.GetSensorHistoryResponseAsync(m, LogLevel, RequestEngine.IsDirty), token : token).ConfigureAwait(false);
return(ResponseParser.ParseSensorHistoryResponse(items, parameters.SensorId));
}
int IStreamableCmdlet <GetSensorHistory, SensorHistoryRecord, SensorHistoryParameters> .GetStreamTotalObjects(SensorHistoryParameters parameters) => client.GetSensorHistoryTotals(parameters);
async Task <List <SensorHistoryRecord> > IStreamableCmdlet <GetSensorHistory, SensorHistoryRecord, SensorHistoryParameters> .GetStreamObjectsAsync(SensorHistoryParameters parameters) => await client.GetSensorHistoryInternalAsync(parameters, CancellationToken.None).ConfigureAwait(false);
Tuple <List <SensorHistoryRecord>, int> IStreamableCmdlet <GetSensorHistory, SensorHistoryRecord, SensorHistoryParameters> .GetStreamObjects(SensorHistoryParameters parameters) => client.GetSensorHistoryInternal(parameters);
async Task <List <SensorHistoryData> > IStreamableCmdlet <GetSensorHistory, SensorHistoryData, SensorHistoryParameters> .GetStreamObjectsAsync(SensorHistoryParameters parameters) => await client.GetSensorHistoryAsyncInternal(parameters).ConfigureAwait(false);
List <SensorHistoryData> IStreamableCmdlet <GetSensorHistory, SensorHistoryData, SensorHistoryParameters> .GetStreamObjects(SensorHistoryParameters parameters) => client.GetSensorHistoryInternal(parameters);
internal async Task <List <SensorHistoryData> > GetSensorHistoryInternalAsync(SensorHistoryParameters parameters, CancellationToken token)
{
var items = await ObjectEngine.GetObjectsAsync <SensorHistoryData>(parameters, ResponseParser.ValidateSensorHistoryResponse, token : token).ConfigureAwait(false);
return(ResponseParser.ParseSensorHistoryResponse(items, parameters.SensorId));
}
