public List <MeasurementResponse> GetMeasurement(string module)
{
var measurementGroups = _context.Measurements
.Include(m => m.Module)
.Where(m => m.Module.Name == module)
.Include(m => m.SensorSpec).ThenInclude(ss => ss.Sensor)
.GroupBy(m => m.TimeReceived);
List <MeasurementResponse> measurements = new List <MeasurementResponse>();
// iterate over each group (measurementGroups is an array of arrays, grouped by TimeReceived)
foreach (var measurementGroup in measurementGroups)
{
// create singe object, which will contain all sensor data
MeasurementResponse measurementResponse = new MeasurementResponse
{
Module = measurementGroup.ElementAt(0).Module,
TimeReceived = measurementGroup.ElementAt(0).TimeReceived,
TimeRegistered = measurementGroup.ElementAt(0).TimeRegistered,
Sensors = measurementGroup.Select(m =>
{
SensorResponse s = new SensorResponse(m.SensorSpec.Sensor)
{
Value = m.Value
};
return(s);
}).ToList()
};
measurements.Add(measurementResponse);
}
return(measurements);
}
public static void AddInfoSensors(SensorResponse response)
{
battery = response.battery;
weight = response.weight;
temperature = response.temperature;
humidity = response.humidity;
illumination = response.illumination;
gate = response.gate;
Lock = response.Lock;
fold = response.fold;
}
public override Task <SensorResponse> GetSensorData(SensorRequest request, ServerCallContext context)
{
foreach (var entry in context.RequestHeaders)
{
Console.WriteLine(entry);
}
SensorResponse sensor = new SensorResponse();
sensor.Sensor = Sensores.sensores.Find(s => s.Id == request.SensorId);
return(Task.FromResult(sensor));
}
public async Task <ActionResult> Post([FromBody] SensorResponse response)
{
try
{
var existingData = await _Context.SensorData
.Where(w => w.Device_Id == response.DeviceId && w.DataEntryTime == response.dateTime)
.ToListAsync();
if (existingData.Count > 0)
{
return(BadRequest("Data already present with this date and time for this device"));
}
foreach (var paramData in response.DataSet)
{
SensorData sensorData = new SensorData
{
DataEntryTime = response.dateTime,
Device_Id = response.DeviceId,
Input_Value = paramData.Value,
Param_Id = paramData.ParameterID
};
_Context.SensorData.Add(sensorData);
}
var deviceInfo = await _Context.Device_info.FindAsync(response.DeviceId);
deviceInfo.lastupdatedon = response.dateTime;
deviceInfo.GUID = Guid.NewGuid().ToString();
_Context.Device_info.Update(deviceInfo);
await _Context.SaveChangesAsync();
SensorReply sensorReply = new SensorReply
{
deviceID = response.DeviceId,
NewGuid = deviceInfo.GUID,
Interval = 30,
ThresHoldSets = await _Context.ParameterBenchmark.ToListAsync()
};
return(Ok(sensorReply));
}
catch (Exception ex)
{
_Logger.LogError($"Error in data {ex.Message}");
return(BadRequest($"Error in data{ex.Message}"));
}
}
public void PrtgClient_RetriesWhileStreaming()
{
var response = new SensorResponse(Enumerable.Repeat(new SensorItem(), 1001).ToArray());
var client = new PrtgClient("prtg.example.com", "username", "passhash", AuthMode.PassHash, new MockRetryWebClient(response, false));
var retriesToMake = 3;
var retriesMade = 0;
client.RetryCount = retriesToMake;
client.RetryRequest += (sender, args) =>
{
retriesMade++;
};
AssertEx.Throws <WebException>(() => client.StreamSensors().ToList(), string.Empty);
Assert.AreEqual(retriesToMake * 2, retriesMade, "An incorrect number of retries were made.");
}
public void PrtgClient_RetriesNormally()
{
prtgClientRetriesNormally = 0;
var response = new SensorResponse(Enumerable.Repeat(new SensorItem(), 1001).ToArray());
var client = new PrtgClient("prtg.example.com", "username", "passhash", AuthMode.PassHash, new MockRetryWebClient(response, true));
var retriesToMake = 3;
client.RetryCount = retriesToMake;
client.RetryRequest += OnClientOnRetryRequest;
AssertEx.Throws <WebException>(() => client.GetSensors().ToList(), string.Empty);
Assert.AreEqual(retriesToMake, prtgClientRetriesNormally, "An incorrect number of retries were made.");
client.RetryRequest -= OnClientOnRetryRequest;
AssertEx.Throws <WebException>(() => client.GetSensors().ToList(), string.Empty);
Assert.AreEqual(retriesToMake, prtgClientRetriesNormally, "Retry handler was called after it was removed");
}
static async Task <IList <SensorResponse> > CreateSensorsAsync(IList <DeviceResponse> deviceResponses, IList <SensorModelResponse> sensorModelResponses)
{
int createThisMany = 5000;
IList <SensorResponse> responses = new List <SensorResponse>(createThisMany);
IList <SensorRequest> requests = _generator.GetSensorRequests
(
createThisMany,
deviceResponses.Select(r => r.Id),
sensorModelResponses.Select(r => r.Id)
);
foreach (SensorRequest request in requests)
{
HttpResponseMessage httpResponseMessage = await _apiClient.PostResourceAsync(request);
SensorResponse response = await _apiClient.GetResourceFromHttpResponseAsync <SensorResponse>(httpResponseMessage);
responses.Add(response);
}
return(responses);
}
public void PrtgClient_StreamsSerial_WhenRequestingOver20000Items()
{
var count = 20001;
var response = new SensorResponse(Enumerable.Repeat(new SensorItem(), count).ToArray());
var client = new PrtgClient("prtg.example.com", "username", "passhash", AuthMode.PassHash, new MockRetryWebClient(response, false));
var messageFound = false;
client.LogVerbose += (e, o) =>
{
if (o.Message == "Switching to serial stream mode as over 20000 objects were detected")
{
messageFound = true;
}
};
var sensors = client.StreamSensors().ToList();
Assert.IsTrue(messageFound, "Request did not stream serially");
Assert.AreEqual(count, sensors.Count);
}
