public async Task <IActionResult> PutMeasurement(
[FromRoute] int id,
[FromBody] MeasurementRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != request.Id)
{
return(BadRequest());
}
var oldMeasurement = await _dataContext.Measurements.FindAsync(request.Id);
if (oldMeasurement == null)
{
return(BadRequest("Measurements doesn't exists."));
}
oldMeasurement.Measure = request.Measure;
oldMeasurement.MeasureDate = request.MeasureDate;
_dataContext.Measurements.Update(oldMeasurement);
await _dataContext.SaveChangesAsync();
return(Ok(true));
}
private static FoundationResponse <string> PushToServer(List <MetricPoint> points, string db, string rp)
{
string str;
FoundationResponse <string> foundationResponse = null;
if ((points == null ? false : points.Count > 0))
{
try
{
string appUri = LocationHelper.Instance.GetAppUri(AppNameEnum.MeasurementApi);
if (string.IsNullOrEmpty(appUri))
{
DebugUtil.Log("MeasurementHost: failed to fetch measurementServerInfo.Uri from location.");
foundationResponse = new FoundationResponse <string>()
{
IsSuccess = false
};
}
else
{
str = (!appUri.EndsWith("/") ? string.Format("{0}/api/measurement/write/", appUri) : string.Format("{0}api/measurement/write/", appUri));
MeasurementRequest measurementRequest = new MeasurementRequest();
measurementRequest.MetricPoints.AddRange(points);
measurementRequest.DBName = db;
measurementRequest.RetentionPolicy = rp;
DebugUtil.Log(string.Format("MeasurementHost: Sending {0} points to db '{1}' via {2}.", points.Count, measurementRequest.DBName, str));
foundationResponse = ProxyBase.Call <FoundationResponse <string>, object>(str, measurementRequest, ApiHttpMethod.POST, 180000, null).Result;
if (foundationResponse == null)
{
foundationResponse = new FoundationResponse <string>();
}
foundationResponse.IsSuccess = true;
}
}
catch (Exception exception1)
{
Exception exception = exception1;
foundationResponse.IsSuccess = false;
foundationResponse.ErrMsg = string.Format("{0}\r\n{1}", exception.Message, exception.StackTrace);
DebugUtil.LogException(exception);
}
}
return(foundationResponse);
}
public async Task <IActionResult> PostMeasurement([FromBody] MeasurementRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
//var up = await _dataContext.UPs.FindAsync(request.UpId);
//if (up == null)
//{
// return BadRequest("Not valid up.");
//}
//var home = await _dataContext.Homes.FindAsync(request.HomeId);
//if (home == null)
//{
// return BadRequest("Not valid Home.");
//}
var flower = await _dataContext.Flowers.FindAsync(request.FlowerId);
if (flower == null)
{
return(BadRequest("Not valid flower."));
}
var measurement = new Measurement
{
Measure = request.Measure,
MeasureDate = request.MeasureDate,
Flower = flower
};
_dataContext.Measurements.Add(measurement);
await _dataContext.SaveChangesAsync();
return(Ok(true));
}
public IActionResult Create([FromBody] MeasurementRequest request)
{
CreateMeasures(request.Measurements);
foreach (var reqMeasurement in request.Measurements)
{
var measurement = new Measurement
{
UserId = CurrentUserId,
MeasureId = reqMeasurement.MeasureId.Value,
Time = request.Time,
Value = reqMeasurement.Value
};
if (reqMeasurement.MeasurementId.HasValue)
{
measurement.Id = reqMeasurement.MeasurementId.Value;
measurementRepository.UpdateMeasurement(measurement);
}
else
{
measurementRepository.CreateMeasurement(measurement);
}
}
return(Ok());
}
public async Task <ActionResult <Measurement> > PostMeasurement(MeasurementRequest request)
{
// get existing module or create new one if it doesn't exist yet
Module module = await _context.Modules.FirstOrDefaultAsync(m => m.Name == request.Logger) ?? new Module
{
Name = request.Logger
};
var currentDate = DateTime.Now;
// add received sensor data to the measurement
foreach (SensorRequest sensorRequest in request.Sensors)
{
Measurement measurement = new Measurement
{
Module = module,
TimeReceived = request.DateTime,
TimeRegistered = currentDate
};
// determine sensor type and set value of the measurement based on that
switch (sensorRequest.GetType())
{
case SensorType.Dendro:
measurement.Value = (double)sensorRequest.Distance;
break;
case SensorType.Humidity:
measurement.Value = (double)sensorRequest.Humidity;
break;
case SensorType.Thermo:
measurement.Value = (double)sensorRequest.Temperature;
break;
default:
throw new Exception("Unknown sensor type");
}
Sensor sensor = await _context.Sensors.FirstOrDefaultAsync(s => s.Name == sensorRequest.Label) ?? new Sensor
{
Name = sensorRequest.Label,
SensorType = sensorRequest.GetType()
};
// find existing spec fot this sensor. If it doesn't exist yet a new default spec will be created
SensorSpec sensorSpec = await _context.SensorSpecs
.Include(ss => ss.Spec)
.FirstOrDefaultAsync(ss => ss.SensorID == sensor.SensorID);
measurement.SensorSpec = sensorSpec ?? new SensorSpec
{
Sensor = sensor,
Spec = new DefaultSpec(sensor.SensorType)
};
_context.Measurements.Add(measurement);
await _context.SaveChangesAsync();
}
return(CreatedAtAction("GetMeasurements", null));
}
public virtual async Task <AsyncServerStreamingCall <MeasurementResponse> > GetMeasurementStream(MeasurementRequest request, CancellationToken cancellationToken)
{
await RefreshAccessToken();
return(machineClient.GetMeasurementStream(request, accessToken, cancellationToken: cancellationToken));
}
