public async Task <IDictionary <string, List <Humidity> > > GetHumidities()
{
var api = _client.GetQueryApi();
var data = await api.QueryAsync <Humidity>("from(bucket:\"humidity\") |> range(start:-7d) |> filter(fn: (r) => r._measurement == \"humidity\") |> filter(fn: (r) => r.device =~ /rtl_433\\/raspberrypi\\/devices\\/Nexus-TH\\/.*/ )", "93a7785d1f9d8493");
return(data.Select(d => { d.Device = deviceRenamerService.GetRenameOrSame(d.Device); return d; }).GroupBy(d => d.Device).ToDictionary(x => x.Key, x => x.ToList()));
}
public Task <List <TelemetryDataDto> > GetTelemetryLatest(Guid deviceId)
{
InfluxDBClient _taos = _taospool.Get();
var query = _taos.GetQueryApi();
var v = query.QueryAsync(@$ "
from(bucket: " "{_bucket}" ")
|> range(start: {_latest})
private static async Task Read(InfluxDBClient influxDBClient)
{
var flux = $"from(bucket:\"{BucketName}\") |> range(start: 0)";
var fluxTables = await influxDBClient.GetQueryApi().QueryAsync(flux, OrgId);
fluxTables.ForEach(fluxTable =>
{
var fluxRecords = fluxTable.Records;
fluxRecords.ForEach(fluxRecord =>
{
var msg = $"{fluxRecord.GetTime()}: {fluxRecord.GetMeasurement()}";
foreach (var(key, value) in fluxRecord.Values)
{
if (!key.StartsWith('_') && key != "result" && key != "table")
{
msg += $" {key}:{value}";
}
}
msg += $" field: {fluxRecord.GetField()}";
Console.WriteLine(msg);
});
});
}
public async Task GzipDisabledQuery()
{
_client.DisableGzip();
MockServer
.Given(Request.Create().UsingPost())
.RespondWith(CreateResponse(""));
var response = await _client.GetQueryApi().QueryAsync("from", "my-org");
Assert.AreEqual(0, response.Count);
var requestEntry = MockServer.LogEntries.Last();
Assert.AreEqual($"{MockServerUrl}/api/v2/query?org=my-org", requestEntry.RequestMessage.Url);
Assert.IsFalse(requestEntry.RequestMessage.Headers.ContainsKey("Content-Encoding"));
Assert.AreEqual("identity", requestEntry.RequestMessage.Headers["Accept-Encoding"].First());
}
public new void SetUp()
{
var options = InfluxDBClientOptions.Builder
.CreateNew()
.Url(MockServerUrl)
.AuthenticateToken("token")
.Org("my-org")
.Build();
_influxDbClient = InfluxDBClientFactory.Create(options);
_influxDbClient.SetLogLevel(LogLevel.Body);
_queryApi = _influxDbClient.GetQueryApi();
}
public static async Task Example(InfluxDBClient influxDbClient)
{
//
// Write Data
//
var writeApiAsync = influxDbClient.GetWriteApiAsync();
//
//
// Write by LineProtocol
//
await writeApiAsync.WriteRecordAsync("my-bucket", "my-org", WritePrecision.Ns,
"temperature,location=north value=60.0");
//
//
// Write by Data Point
//
var point = PointData.Measurement("temperature")
.Tag("location", "west")
.Field("value", 55D)
.Timestamp(DateTime.UtcNow.AddSeconds(-10), WritePrecision.Ns);
await writeApiAsync.WritePointAsync("my-bucket", "my-org", point);
//
// Write by POCO
//
var temperature = new Temperature {
Location = "south", Value = 62D, Time = DateTime.UtcNow
};
await writeApiAsync.WriteMeasurementAsync("my-bucket", "my-org", WritePrecision.Ns, temperature);
//
// Check written data
//
var tables = await influxDbClient.GetQueryApi()
.QueryAsync("from(bucket:\"my-bucket\") |> range(start: 0)", "my-org");
tables.ForEach(table =>
{
var fluxRecords = table.Records;
fluxRecords.ForEach(record =>
{
Console.WriteLine($"{record.GetTime()}: {record.GetValue()}");
});
});
influxDbClient.Dispose();
}
static public async Task <List <FluxTable> > ExcuteInflux(InfluxDBClient client, string query)
{
#if DEBUG
Console.WriteLine($"[INFLUX] >> {query}");
#endif
List <FluxTable> fluxTable = await client.GetQueryApi().QueryAsync(query, "org_id");
#if DEBUG
Console.WriteLine($"result count is : {fluxTable.Count} * {fluxTable.FirstOrDefault()?.Records.Count}");
#endif
client.Dispose();
return(fluxTable);
}
public async Task <List <FluxTable> > ReadData(String eqpId, DateTime dx, String measure)
{
DateTime start = new DateTime(dx.Year, dx.Month, dx.Day);
String st = start.ToString("s") + "Z";
String en = start.AddDays(1).AddMinutes(-1).ToString("s") + "Z";
var query = $"from(bucket: \"{ bucket}\") " +
" |> range(start: " + st + " , stop: " + en + ")" +
"|> filter(fn: (r) => r._measurement == \"influxData\" and r.equipmentId == \"" + eqpId + "\" ) " +
" |> filter(fn: (r) => r[\"_field\"] == \"" + measure + "\")";
;
var tables = client.GetQueryApi().QueryAsync(query, org).Result;
return(tables);
}
public async void Query(string bucket, string org)
{
string flux = $"from(bucket:\"{bucket}\") |> range(start: 0)";
var queryApi = client.GetQueryApi();
await queryApi.QueryAsync(flux, org, (cancellable, record) =>
{
QueryComplete?.Invoke(this, new QueryCompleteEventArgs(record));
},
exception =>
{
QueryException?.Invoke(this, new QueryExceptionEventArgs(exception));
},
() =>
{
QuerySuccess?.Invoke(this, new QuerySuccessEventArgs());
});
}
public async Task <SensorDataModel> Get(string guid)
{
var flux = "from(bucket: \"Sensors\")" +
"|> range(start: -1d)" +
"|> filter(fn: (r) => r[\"_measurement\"] == \"moisture\")" +
"|> filter(fn: (r) => r[\"_field\"] == \"value\")" +
$"|> filter(fn: (r) => r[\"device\"] == \"{guid}\")" +
"|> last()";
var fluxTables = await _infux.GetQueryApi().QueryAsync(flux, "Droppy");
double lastValue = (double)fluxTables.FirstOrDefault()?.Records.FirstOrDefault()?.GetValue();
return(new SensorDataModel()
{
Device = guid,
Reading = (float)lastValue
});
}
private void InitializeDb()
{
var dbConfig = WorkersManager.GetWorkersManager().Config;
if (dbClient == null && dbConfig.IsDbConfigAvailable())
{
try
{
Log.Info("InitializeDb");
dbClient = InfluxDBClientFactory.Create(dbConfig.Url, dbConfig.AuthToken.ToCharArray());
dbClient.Health();
dbQueryApi = dbClient.GetQueryApi();
}
catch (Exception ex)
{
Log.Error("Db init error", ex);
OnStatusChanged("DB Init Error: " + ex.Message);
}
}
}
public static async Task <List <Point> > GetPointFromInfluxDb(this InfluxDBClient influxDBClient, string startTime,
string endTime, string query, Func <FluxRecord, Point> mapFunc = null, string bucket = null)
{
mapFunc ??= fluxRecord => new Point()
{
Time = fluxRecord.GetTime().Value.ToDateTimeUtc(),
Data1 = float.Parse(fluxRecord.GetValue().ToString())
};
var actualEndTime =
TimeHelper.ToRFC3339Time(TimeHelper.FromRFC3339Time(endTime).Floor(TimeSpan.FromMinutes(1)));
var fluxQuery = $@"from(bucket: ""{bucket ?? Bucket.Value}"")
|> range(start: {startTime},stop: {actualEndTime})
{query}
";
var fluxTables =
await influxDBClient.GetQueryApi().QueryAsync(fluxQuery, Organization.Value);
var vusPoints = fluxTables.First().Records.Select(mapFunc).ToList();
return(vusPoints);
}
public static async Task Example(InfluxDBClient influxDB)
{
var organizationClient = influxDB.GetOrganizationsApi();
var medicalGMBH = await organizationClient
.CreateOrganization("Medical Corp " +
DateTime.UtcNow.ToString("yyyy-MM-dd HH:mm:ss.fff",
CultureInfo.InvariantCulture));
//
// Create New Bucket with retention 1h
//
var temperatureBucket = await influxDB.GetBucketsApi().CreateBucket("temperature-sensors", medicalGMBH.Id);
//
// Add Permissions to read and write to the Bucket
//
var resource = new PermissionResource
{
Type = PermissionResource.TypeEnum.Buckets, OrgID = medicalGMBH.Id, Id = temperatureBucket.Id
};
var readBucket = new Permission
{
Resource = resource,
Action = Permission.ActionEnum.Read
};
var writeBucket = new Permission
{
Resource = resource,
Action = Permission.ActionEnum.Write
};
var authorization = await influxDB.GetAuthorizationsApi()
.CreateAuthorization(medicalGMBH, new List <Permission> {
readBucket, writeBucket
});
Console.WriteLine($"The token to write to temperature-sensors bucket is: {authorization.Token}");
influxDB.Dispose();
//
// Create new client with specified authorization token
//
influxDB = InfluxDBClientFactory.Create("http://localhost:9999", authorization.Token.ToCharArray());
var writeOptions = WriteOptions
.CreateNew()
.BatchSize(5000)
.FlushInterval(1000)
.JitterInterval(1000)
.RetryInterval(5000)
.Build();
//
// Write data
//
using (var writeClient = influxDB.GetWriteApi(writeOptions))
{
//
// Write by POCO
//
var temperature = new Temperature {
Location = "south", Value = 62D, Time = DateTime.UtcNow
};
writeClient.WriteMeasurement("temperature-sensors", medicalGMBH.Id, WritePrecision.Ns, temperature);
//
// Write by Point
//
var point = Point.Measurement("temperature")
.Tag("location", "west")
.Field("value", 55D)
.Timestamp(DateTime.UtcNow.AddSeconds(-10), WritePrecision.Ns);
writeClient.WritePoint("temperature-sensors", medicalGMBH.Id, point);
//
// Write by LineProtocol
//
var record = "temperature,location=north value=60.0";
writeClient.WriteRecord("temperature-sensors", medicalGMBH.Id, WritePrecision.Ns, record);
writeClient.Flush();
Thread.Sleep(2000);
}
//
// Read data
//
var fluxTables = await influxDB.GetQueryApi().Query("from(bucket:\"temperature-sensors\") |> range(start: 0)", medicalGMBH.Id);
fluxTables.ForEach(fluxTable =>
{
var fluxRecords = fluxTable.Records;
fluxRecords.ForEach(fluxRecord =>
{
Console.WriteLine($"{fluxRecord.GetTime()}: {fluxRecord.GetValue()}");
});
});
influxDB.Dispose();
}
/// <summary>
/// Lettura telemetrie da database
/// </summary>
/// <param name="machine_id">Identificativo della macchina</param>
/// <param name="field">Field di cui ritornare i valori</param>
/// <param name="period">Intervallo temporale a partire dall'istante corrente a ritroso di cui estrarre le telemetrie</param>
/// <returns></returns>
public async Task <String> ReadData(String machine_id, String field, int period = 0)
{
String json = "";
long elapsedMs = 0;
var res = new QueryResult();
try
{
var query = $"from(bucket:\"{database}\") " +
$"|> range(start: -{period}s) " +
$"|> filter(fn: (r) => r._measurement == \"{machine_id}\" and r._field == \"{field}\")";
//esecuzione query
var watch = System.Diagnostics.Stopwatch.StartNew();
var fluxTables = await client.GetQueryApi().QueryAsync(query);
watch.Stop();
elapsedMs = watch.ElapsedMilliseconds;
//se ci sono risultati ( se count = 0 => non ci sono risultati)
if (fluxTables != null && fluxTables.Count > 0)
{
//Nota: InfluxDB restituisce i risultati come lista di colonne
//numero di colonne dei risultati
int countColumns = fluxTables.Count;
//numero di righe dei risultati
int countRecords = fluxTables[0].Records.Count;
Dictionary <String, Object>[] values = new Dictionary <string, object> [countRecords];
//inizializzazione
for (int i = 0; i < countRecords; i++)
{
values[i] = new Dictionary <string, object>();
}
//aggiungo timestamp ad ogni entry
for (int j = 0; j < countRecords; j++)
{
var timestamp = fluxTables[0].Records[j].GetTime().GetValueOrDefault().ToUnixTimeMilliseconds();
values[j].Add("ts", timestamp);
}
//costruzione delle righe
for (int i = 0; i < countColumns; i++)
{
for (int j = 0; j < countRecords; j++)
{
var temp = fluxTables[i].Records[j];
String key = fluxTables[i].Records[j].GetField();
object value = fluxTables[i].Records[j].GetValue();
values[j].Add(key, value);
}
}
//conversione in stringa json
json = JsonConvert.SerializeObject(values);
}
if (fluxTables == null)
{
res.Result = false;
}
else
{
res.Result = true;
}
}
catch (Exception e)
{
log.ErrorFormat("!ERROR: {0}", e.ToString());
res.Result = false;
}
res.Time = elapsedMs;
res.Payload = json;
res.MachineId = machine_id;
return(JsonConvert.SerializeObject(res));
}
public async Task <Dictionary <string, List <Beacon> > > GetData()
{
var output = new Dictionary <string, List <Beacon> >();
var flux = "from(bucket:\"" + _influxBucket + "\")"
+ " |> range(start: -48h) "
+ " |> group(columns: [\"deviceId\", \"tagId\"])"
+ "|> sort(columns: [\"_time\"], desc: true)"
+ "|> first() "
+ "|> yield(name: \"first\")";
List <InfluxDB.Client.Core.Flux.Domain.FluxTable> tables;
try
{
var queryApi = _influxDBClient.GetQueryApi();
tables = await queryApi.QueryAsync(flux, _influxOrg);
}
catch (Exception ex)
{
Debug.WriteLine("Influx exception: " + ex);
return(null);
}
tables.ForEach(table =>
{
table.Records.ForEach(fluxRecord =>
{
var deviceIdRecord = fluxRecord.GetValueByKey("deviceId");
var deviceNameRecord = fluxRecord.GetValueByKey("deviceName");
var tagIdRecord = fluxRecord.GetValueByKey("tagId");
var strengthRecord = (double)fluxRecord.GetValue();
var lastSeenRecord = ((Instant)fluxRecord.GetTime()).ToDateTimeUtc();
#region device
if (null == deviceIdRecord)
{
Debug.WriteLine("No deviceId found for a row in the InfluxDB, so skipping.");
Debug.WriteLine("Row timestamp = " + fluxRecord.GetTime());
return; //returns from the .foreach not the method
}
var deviceId = deviceIdRecord.ToString();
var deviceName = "unknown";
if (null != deviceNameRecord)
{
deviceName = deviceNameRecord.ToString();
}
#endregion
#region tagId
var tagRecord = fluxRecord.GetValueByKey("tagId");
if (null == deviceIdRecord)
{
Debug.WriteLine("No tagId found for a row in the InfluxDB, so skipping.");
Debug.WriteLine("Row timestamp = " + fluxRecord.GetTime());
return; //returns from the .foreach not the method
}
var tagId = tagRecord.ToString();
#endregion
if (!output.ContainsKey(deviceId))
{
output.Add(deviceId, new List <Beacon>());
}
var beaconName = _tagViewModel.GetTagName(tagId);
if (string.IsNullOrEmpty(beaconName))
{
beaconName = tagId;
}
output[deviceId].Add(new Beacon
{
BeaconId = tagId,
BeaconName = beaconName,
DeviceName = deviceName,
DeviceUuid = deviceId,
LastSeen = lastSeenRecord,
Strength = strengthRecord
});
});
});
return(output);
}
public async Task <List <FluxTable> > Query(string query)
{
return(await _client.GetQueryApi().QueryAsync(query, DB_ORGANIZATION));
}
public async Task <List <FluxTable> > Query()
{
return(await _influxDBClient
.GetQueryApi()
.QueryAsync(_query));
}
