public async Task <ActionResult> Measurements(MeasurementQueryModel query)
{
var sessionQuery = Session[querySessionKey] as MeasurementQueryModel;
if (!ModelState.IsValid)
{
if (null == sessionQuery)
{
return(View("Index", query));
}
query = sessionQuery;
}
Repository r = new Repository();
try
{
var modelTask = r.GetMeasurementsAsync(query);
var sensorsTask = r.GetSensorsAsync(query.Key);
ViewBag.Sensors = await sensorsTask;
Session[querySessionKey] = query;
return(View(await modelTask));
}
catch (KeyNotFoundException kex)
{
return(HttpNotFound(kex.Message));
}
catch (UnauthorizedAccessException uex)
{
return(new HttpUnauthorizedResult(uex.Message));
}
}
public async Task <ActionResult> Details(long id)
{
Repository r = new Repository();
MeasurementQueryModel queryModel = Session[querySessionKey] as MeasurementQueryModel;
try
{
string key = null;
List <string> sensors = null;
if (null != queryModel)
{
key = queryModel.Key;
sensors = queryModel.DataTags();
}
var model = await r.GetMeasurementAsync(key, id, sensors);
return(View(model));
}
catch (KeyNotFoundException kex)
{
return(HttpNotFound(kex.Message));
}
catch (UnauthorizedAccessException uex)
{
return(new HttpUnauthorizedResult(uex.Message));
}
}
public async Task ReadMeasurementsAsync()
{
using (Repository r = new Repository())
{
var query = new MeasurementQueryModel()
{
Key = readKey,
From = new DateTimeOffset(2015, 10, 25, 0, 0, 0, TimeSpan.FromHours(3)),
To = new DateTimeOffset(2015, 10, 26, 0, 0, 0, TimeSpan.FromHours(2)),
Take = null
};
Stopwatch sw = Stopwatch.StartNew();
var result = await r.GetMeasurementsAsync(query);
sw.Stop();
int expected = 79365;
Trace.WriteLine(string.Format("Got {0} results in {1}.", result.Count, sw.Elapsed));
var f = result.First();
var l = result.Last();
Trace.WriteLine(string.Format("First {0} and last {1}.", f.Timestamp, l.Timestamp));
Assert.IsNotNull(result);
Assert.AreEqual <int>(expected, result.Count);
Assert.AreEqual <string>("25.10.2015 23:59:59 +02:00", f.Timestamp.ToString());
Assert.AreEqual <string>("25.10.2015 0:00:01 +03:00", l.Timestamp.ToString());
}
}
// GET: api/Measurement/my-key?obj=some-object&tag=some-tag
//public IHttpActionResult Get(MeasurementQueryModel query)
public async Task <IHttpActionResult> Get(string key, string sensors, string obj, string tag, string take, string from, string to)
{
MeasurementQueryModel query = new MeasurementQueryModel()
{
Key = key,
Obj = obj,
Tag = tag,
Sensors = sensors,
Take = take.QueryParamToInt(),
From = from.QueryParamToDateTimeOffset(),
To = to.QueryParamToDateTimeOffset()
};
Repository r = new Repository();
try
{
var model = await r.GetMeasurementsAsync(query, true);
if (null == model)
{
return(NotFound());
}
return(Ok(model));
}
catch (KeyNotFoundException)
{
return(NotFound());
}
catch (UnauthorizedAccessException)
{
return(Unauthorized());
}
}
public ActionResult Index()
{
MeasurementQueryModel model = Session[querySessionKey] as MeasurementQueryModel;
if (null == model)
{
model = new MeasurementQueryModel();
}
return(View(model));
}
public void WCFReadMeasurementsTop100()
{
MeasurementQueryModel q = new MeasurementQueryModel()
{
Key = TestHelper.TestKey,
Take = 100
};
this.WCFReadMeasurements(q, 100);
}
public void WCFReadMeasurementsFromTo()
{
MeasurementQueryModel q = new MeasurementQueryModel()
{
Key = TestHelper.TestKey,
From = new DateTimeOffset(2014, 11, 26, 0, 0, 0, TimeSpan.FromHours(2)),
To = new DateTimeOffset(2014, 11, 27, 0, 0, 0, TimeSpan.FromHours(2))
};
this.WCFReadMeasurements(q, 13451);
}
public async Task WCFReadMeasurementsFromToAsync()
{
MeasurementQueryModel q = new MeasurementQueryModel()
{
Key = TestHelper.TestKey,
From = new DateTimeOffset(2014, 11, 26, 0, 0, 0, TimeSpan.FromHours(2)),
To = new DateTimeOffset(2014, 11, 27, 0, 0, 0, TimeSpan.FromHours(2))
};
await this.WCFReadMeasurementsAsync(q, 13451);
}
public async Task <ActionResult> SaveQuery(MeasurementQueryModel query)
{
string c = "";
if (string.IsNullOrEmpty(query?.Name))
{
ModelState.AddModelError("Name", "Name field is required!");
c = " <div class='alert alert-warning fade in'><a class='close' data-dismiss='alert' aria-label='close'>×</a>Name field is required</div>";
return(Content(c));
}
Helpers.LoginHelper lh = new Helpers.LoginHelper();
query.Key = lh.GetAuthenticationKey(this.HttpContext);
if (query.Key != null)
{
ModelState.Remove("key");
ModelState.Add("Key", new ModelState());
ModelState.SetModelValue("Key", new ValueProviderResult(query.Key, query.Key, System.Globalization.CultureInfo.CurrentCulture));
}
c = " <div class='alert alert-danger fade in'><a class='close' data-dismiss='alert' aria-label='close'>×</a><span class='text-info'><span class='text-success'>Query: " + query.Name + " was <strong>NOT</strong> Saved successfully!</span></span></div>";
if (!ModelState.IsValid)
{
return(Content(c));
}
Repository r = new Repository();
int result = 0;
SavedQueryModel savedQuery = new SavedQueryModel();
try
{
result = await r.SaveQueryAsync(query);
if (result > 0)
{
query.ID = result;
savedQuery = new SavedQueryModel(query);
}
else if (result == -1)
{
c = " <div class='alert alert-danger fade in'><a class='close' data-dismiss='alert' aria-label='close'>×</a><span class='text-info'><span class='text-success'>Queries cannot be saved with Master key!</span></span></div>";
return(Content(c));
}
else
{
return(Content(c));
}
}
catch (Exception ex)
{
Savonia.Web.ErrorReporter.ErrorReporterModule.HandleException(ex, System.Web.HttpContext.Current.Request);
return(Content(c));
}
return(Json(savedQuery));
}
private async Task WCFReadMeasurementsAsync(MeasurementQueryModel q, int expectedCount)
{
MeasurementsServiceClient client = new MeasurementsServiceClient();
Stopwatch sw = Stopwatch.StartNew();
var result = await client.GetMeasurementsAsync(q);
sw.Stop();
client.Close();
Trace.WriteLine(string.Format("GetMeasurements with query {0} took {1} ms and returned {2} results.", GetQueryString(q), sw.ElapsedMilliseconds, result.Length));
Assert.IsNotNull(result);
Assert.AreEqual(expectedCount, result.Length);
}
///Gets at most last 200 measurements or measurements defined by queryParams from and to (ISO 8601)
public async Task <IActionResult> Get(
[FromRoute(Name = "deviceId")] string deviceId,
[FromQuery] MeasurementQueryModel queryModel)
{
var watch = Stopwatch.StartNew();
_logger.LogDebug(String.Format("Getting Measurements for serial number: {0}", deviceId));
var measurements = await _measurementService.GetMeasurements(deviceId, queryModel.FromDate, queryModel.ToDate);
watch.Stop();
_logger.LogInformation(string.Format("Found {0} Measurements for serial number {1} in {2}ms", measurements.Count, deviceId, watch.ElapsedMilliseconds));
return(Ok(measurements));
}
public static Query ToQuery(this MeasurementQueryModel model, AccessKeyModel access)
{
return(new Query()
{
Key = access.Key.Hash(access.ProviderID.ToString()),
ProviderID = access.ProviderID,
Object = model.Obj,
Tag = model.Tag,
Take = model.Take,
From = model.From,
To = model.To,
Sensors = model.Sensors,
Name = model.Name,
ID = model.ID
});
}
public async Task <List <MeasurementModel> > RestGetMeasurementsAsync(string key, string sensors, string obj, string tag, string take, string from, string to, string inclusiveFrom, string inclusiveTo)
{
MeasurementQueryModel query = new MeasurementQueryModel()
{
Key = key,
Obj = obj,
Tag = tag,
Sensors = sensors,
Take = take.QueryParamToInt(),
From = from.QueryParamToDateTimeOffset(),
To = to.QueryParamToDateTimeOffset(),
InclusiveFrom = inclusiveFrom.QueryParamToBoolean(true),
InclusiveTo = inclusiveTo.QueryParamToBoolean(true)
};
return(await this.GetMeasurementsAsync(query));
}
public async Task GetAndSetSensors()
{
try
{
MeasurementQueryModel q = new MeasurementQueryModel();
q.Key = "SK104-savoniatest";
Repository r = new Repository();
var sensors = r.GetSensorsAsync(q.Key);
await AddProviderDataList(1, "MeasurementSensors", await sensors);
}
catch (Exception)
{
}
}
public async Task <ActionResult> Login(MeasurementQueryModel query)
{
if (!ModelState.IsValid)
{
return(View("Login", query));
}
Repository r = new Repository();
try
{
var queries = r.GetQueries(query.Key);
List <SavedQueryModel> savedQueries = new List <SavedQueryModel>();
if (null != queries)
{
foreach (var q in queries)
{
savedQueries.Add(new SavedQueryModel(q));
}
}
ViewBag.Queries = savedQueries;
var objects = await r.GetDistinctObjectsAsync(query.Key);
ViewBag.Objects = objects;
var sensorsTask = r.GetSensorsAsync(query.Key);
ObservableCollection <SensorModel> sensors = new ObservableCollection <SensorModel>(await sensorsTask);
ViewBag.Sensors = sensors;
Helpers.LoginHelper lh = new Helpers.LoginHelper();
lh.CreateLoginCredentials(this.HttpContext, query.Key);
}
catch (KeyNotFoundException kex)
{
Savonia.Web.ErrorReporter.ErrorReporterModule.HandleException(kex, System.Web.HttpContext.Current.Request);
ModelState.AddModelError("Key", kex.Message);
return(View());
}
catch (UnauthorizedAccessException uex)
{
Savonia.Web.ErrorReporter.ErrorReporterModule.HandleException(uex, System.Web.HttpContext.Current.Request);
ModelState.AddModelError("Key", uex.Message);
return(View());
}
return(View("Get"));
}
public async Task <List <MeasurementModel> > GetMeasurementsAsync(MeasurementQueryModel query)
{
Repository r = new Repository();
try
{
var data = await r.GetMeasurementsAsync(query, true);
return(data);
}
catch (KeyNotFoundException kex)
{
throw new FaultException(kex.Message);
}
catch (UnauthorizedAccessException uex)
{
throw new FaultException(uex.Message);
}
}
public async Task <ActionResult> ConfirmDelete(long id)
{
Repository r = new Repository();
MeasurementQueryModel queryModel = Session[querySessionKey] as MeasurementQueryModel;
try
{
await r.DeleteMeasurementAsync(null != queryModel?queryModel.Key : null, id);
return(RedirectToAction("Measurements"));
}
catch (KeyNotFoundException kex)
{
return(HttpNotFound(kex.Message));
}
catch (UnauthorizedAccessException uex)
{
return(new HttpUnauthorizedResult(uex.Message));
}
}
public async Task <ActionResult> Delete(long id)
{
Repository r = new Repository();
MeasurementQueryModel queryModel = Session[querySessionKey] as MeasurementQueryModel;
try
{
var model = await r.GetMeasurementAsync(null != queryModel?queryModel.Key : null, id, null);
return(View(model));
}
catch (KeyNotFoundException kex)
{
return(HttpNotFound(kex.Message));
}
catch (UnauthorizedAccessException uex)
{
return(new HttpUnauthorizedResult(uex.Message));
}
}
public ActionResult Login()
{
MeasurementQueryModel model = Session[querySessionKey] as MeasurementQueryModel;
ModelStateDictionary d = Session["modelstate"] as ModelStateDictionary;
if (d != null)
{
foreach (var k in d)
{
if (k.Value.Errors.Count > 0)
{
ModelState.AddModelError(k.Key, k.Value.Errors[0]?.ErrorMessage);
}
}
}
if (null == model)
{
model = new MeasurementQueryModel();
}
return(View(model));
}
public async Task WCFReadMeasurementsTop100Async()
{
int expected = 100;
MeasurementQueryModel q = new MeasurementQueryModel()
{
Key = TestHelper.TestKey,
Take = expected
};
MeasurementsServiceClient client = new MeasurementsServiceClient();
Stopwatch sw = Stopwatch.StartNew();
var result = await client.GetMeasurementsAsync(q);
sw.Stop();
client.Close();
Trace.WriteLine(string.Format("GetMeasurements (async) with query {0} took {1} ms and returned {2} results.", GetQueryString(q), sw.ElapsedMilliseconds, result.Length));
Assert.IsNotNull(result);
Assert.AreEqual(expected, result.Length);
}
public async Task ReadMeasurementsWithDataTake200Async()
{
using (Repository r = new Repository())
{
var query = new MeasurementQueryModel()
{
Key = readKey,
From = new DateTimeOffset(2015, 10, 25, 0, 0, 0, TimeSpan.FromHours(3)),
To = new DateTimeOffset(2015, 10, 26, 0, 0, 0, TimeSpan.FromHours(2)),
Take = 200
};
Stopwatch sw = Stopwatch.StartNew();
var result = await r.GetMeasurementsAsync(query, true);
sw.Stop();
int expected = 200;
Trace.WriteLine(string.Format("Got {0} results with data in {1}.", result.Count, sw.Elapsed));
var f = result.First();
var tenth = result[9];
var l = result.Last();
var fV = f.Data.Single(d => d.Tag == "CU2_F1_PILOT");
var tV = tenth.Data.Single(d => d.Tag == "CU2_T2_PILOT");
var lV = l.Data.Single(d => d.Tag == "L2_T2_PILOT");
Trace.WriteLine(string.Format("First ({0}) {1}, 10th ({2}) {3} and last ({4}) {5}.", f.ID, f.Timestamp, tenth.ID, tenth.Timestamp, l.ID, l.Timestamp));
Trace.WriteLine(string.Format("1st: {0} = {1}, 10th: {2} = {3}, last: {4} = {5}", fV.Tag, fV.Value, tV.Tag, tV.Value, lV.Tag, lV.Value));
Assert.IsNotNull(result);
Assert.AreEqual <int>(expected, result.Count);
Assert.AreEqual <string>("25.10.2015 23:59:59 +02:00", f.Timestamp.ToString());
Assert.AreEqual <string>("25.10.2015 23:56:40 +02:00", l.Timestamp.ToString());
Assert.AreEqual <string>("25.10.2015 23:59:50 +02:00", tenth.Timestamp.ToString());
Assert.AreEqual <double>(4.118750095367, fV.Value.Value);
Assert.AreEqual <double>(17.1015625, tV.Value.Value);
Assert.AreEqual <double>(16.29296875, lV.Value.Value);
Assert.IsNull(fV.XmlValue);
Assert.IsNull(tV.BinaryValue);
Assert.IsNull(lV.TextValue);
}
}
public async Task <ActionResult> DeleteQuery([System.Web.Http.FromBody] MeasurementQueryModel query)
{
Helpers.LoginHelper lh = new Helpers.LoginHelper();
query.Key = lh.GetAuthenticationKey(this.HttpContext);
if (query.Key != null)
{
ModelState.Remove("key");
ModelState.Add("Key", new ModelState());
ModelState.SetModelValue("Key", new ValueProviderResult(query.Key, query.Key, System.Globalization.CultureInfo.CurrentCulture));
}
string c = " <div class='alert alert-danger fade in'><a class='close' data-dismiss='alert' aria-label='close'>×</a><span class='text-info'><span class='text-success'>Query: " + query.Name + " was <strong>NOT</strong> deleted successfully!</span></span></div>";
if (!ModelState.IsValid)
{
return(Content(c));
}
Repository r = new Repository();
int result = 0;
SavedQueryModel savedQuery = new SavedQueryModel();
try
{
result = await r.DeleteQueryAsync(query);
if (result > 0)
{
savedQuery = new SavedQueryModel(query);
}
else
{
return(Content(c));
}
}
catch (Exception ex)
{
Savonia.Web.ErrorReporter.ErrorReporterModule.HandleException(ex, System.Web.HttpContext.Current.Request);
return(Content(c));
}
return(Json(savedQuery));
}
public async Task ReadMeasurementsWithBinaryDataAsync()
{
using (Repository r = new Repository())
{
var query = new MeasurementQueryModel()
{
Key = "Your-Key-here"
};
Stopwatch sw = Stopwatch.StartNew();
var result = await r.GetMeasurementsAsync(query, true);
sw.Stop();
int expected = 20;
Trace.WriteLine(string.Format("Got {0} results with data in {1}.", result.Count, sw.Elapsed));
var f = result.First();
var wanted = result.Single(d => d.ID == 18);
var im = wanted.Data.Single(d => d.Tag == "Image");
var l = result.Last();
Trace.WriteLine(string.Format("First ({0}) {1}, 10th ({2}) {3} and last ({4}) {5}.", f.ID, f.Timestamp, wanted.ID, wanted.Timestamp, l.ID, l.Timestamp));
wanted.Data.ForEach(d =>
{
Trace.WriteLine(string.Format("{0}: Value = {1}, Text = {2}, Has binary = {3}", d.Tag, d.Value, d.TextValue, null != d.BinaryValue));
});
Assert.IsNotNull(result);
Assert.AreEqual <int>(expected, result.Count);
//Assert.AreEqual<string>("25.10.2015 23:59:59 +02:00", f.Timestamp.ToString());
//Assert.AreEqual<string>("25.10.2015 0:00:01 +03:00", l.Timestamp.ToString());
//Assert.AreEqual<string>("25.10.2015 23:59:50 +02:00", tenth.Timestamp.ToString());
Assert.AreEqual <string>("image/jpeg", im.TextValue);
Assert.IsNotNull(im.BinaryValue);
//if (null != im.BinaryValue)
//{
// System.IO.File.WriteAllBytes(@"c:\temp\img.jpg", im.BinaryValue);
//}
}
}
public SavedQueryModel(MeasurementQueryModel model)
{
this.Name = model.Name;
this.Obj = model.Obj;
this.Tag = model.Tag;
this.Take = model.Take;
if (model.From.HasValue)
{
var f = model.From.Value.ToString("u");
var a = f.Split('Z');
var from = a[0];
this.From = from;
}
if (model.To.HasValue)
{
var f = model.To.Value.ToString("u");
var a = f.Split('Z');
var to = a[0];
this.To = to;
}
this.Sensors = model.Sensors;
}
private string GetQueryString(MeasurementQueryModel q)
{
return(string.Format("\"From {0}, To {1}, Take {2}, Obj {3}, Tag {4}\"", q.From, q.To, q.Take, q.Obj, q.Tag));
}
public async Task <ActionResult> Measurements(MeasurementQueryModel query, CancellationToken t)
{
CancellationToken disconnectedToken = Response.ClientDisconnectedToken;
var timeOutToken = Request.TimedOutToken;
var source = CancellationTokenSource.CreateLinkedTokenSource(t, disconnectedToken, timeOutToken);
Helpers.LoginHelper lh = new Helpers.LoginHelper();
query.Key = lh.GetAuthenticationKey(this.HttpContext);
if (query.Key != null)
{
ModelState.Remove("key");
ModelState.Add("Key", new ModelState());
ModelState.SetModelValue("Key", new ValueProviderResult(query.Key, query.Key, System.Globalization.CultureInfo.CurrentCulture));
}
if (!ModelState.IsValid)
{
return(RedirectToAction("RedirectToLogin"));
}
Repository r = new Repository();
try
{
var measurements = await r.GetMeasurementsAsync(query, source.Token, true);
if (measurements?.Count > 0 && !source.IsCancellationRequested)
{
ViewBag.DataCount = measurements[0].Data.Count;
Helpers.DocumentHelper s = new Helpers.DocumentHelper();
string filename = Session.SessionID + ".json";
string directoryPath = Server.MapPath(Common.GlobalSettings.GetJSONPath);
s.SerializeJSONFile <List <MeasurementModel> >(measurements, directoryPath, filename);
ViewBag.DatetimeFormats = Helpers.DatetimeFormatHelper.GetPossibleDatetimeFormats();
ViewBag.ExportModel = new Models.ExportModel();
ViewBag.MeasurementCount = measurements.Count;
}
else
{
source.Dispose();
return(Content("<span class='text-danger'>0 measurements found with given parameters.</span>"));
}
if (measurements.Count > 3000)
{
var m = measurements.Take(3000);
measurements = m.ToList();
}
return(PartialView("~/Views/Export/Export.cshtml", measurements));
}
catch (KeyNotFoundException kex)
{
Savonia.Web.ErrorReporter.ErrorReporterModule.HandleException(kex, System.Web.HttpContext.Current.Request);
return(RedirectToAction("RedirectToLogin"));
}
catch (UnauthorizedAccessException uex)
{
Savonia.Web.ErrorReporter.ErrorReporterModule.HandleException(uex, System.Web.HttpContext.Current.Request);
return(RedirectToAction("RedirectToLogin"));
}
catch (OperationCanceledException canceled)
{
Savonia.Web.ErrorReporter.ErrorReporterModule.HandleException(canceled, System.Web.HttpContext.Current.Request);
source.Dispose();
return(Content("<span class='text-danger'>Request cancelled.</span>"));
}
catch (Exception ex)
{
Savonia.Web.ErrorReporter.ErrorReporterModule.HandleException(ex, System.Web.HttpContext.Current.Request);
return(RedirectToAction("RedirectToLogin"));
}
}
