private void AddDefaultEmptyValues(FluxTable table, CsvReader defaultEmptyValues)
{
Arguments.CheckNotNull(table, "table");
Arguments.CheckNotNull(defaultEmptyValues, "defaultEmptyValues");
for (var ii = 0; ii < table.Columns.Count; ii++)
{
var fluxColumn = GetFluxColumn(ii, table);
fluxColumn.DefaultValue = defaultEmptyValues[ii + 1];
}
}
private void AddGroups(FluxTable table, string[] groups)
{
Arguments.CheckNotNull(table, "table");
Arguments.CheckNotNull(groups, "groups");
for (var ii = 0; ii < table.Columns.Count; ii++)
{
var fluxColumn = GetFluxColumn(ii, table);
fluxColumn.Group = Convert.ToBoolean(groups[ii + 1]);
}
}
private void AddColumnNamesAndTags(FluxTable table, CsvReader columnNames)
{
Arguments.CheckNotNull(table, "table");
Arguments.CheckNotNull(columnNames, "columnNames");
var size = table.Columns.Count;
for (var ii = 0; ii < size; ii++)
{
var fluxColumn = GetFluxColumn(ii, table);
fluxColumn.Label = columnNames[ii + 1];
}
}
private FluxRecord ParseRecord(int tableIndex, FluxTable table, CsvReader csv)
{
var record = new FluxRecord(tableIndex);
foreach (var fluxColumn in table.Columns)
{
var columnName = fluxColumn.Label;
var strValue = csv[fluxColumn.Index + 1];
record.Values.Add(columnName, ToValue(strValue, fluxColumn));
}
return(record);
}
private void AddDataTypes(FluxTable table, CsvReader dataTypes)
{
Arguments.CheckNotNull(table, "table");
Arguments.CheckNotNull(dataTypes, "dataTypes");
for (var index = 1; index < dataTypes.Context.Record.Length; index++)
{
var dataType = dataTypes[index];
if (string.IsNullOrEmpty(dataType))
{
continue;
}
var columnDef = new FluxColumn
{
DataType = dataType,
Index = index - 1
};
table.Columns.Add(columnDef);
}
}
public void Accept(int index, ICancellable cancellable, FluxTable table)
{
AcceptTable(table);
}
/// <summary>
/// Parse Flux CSV response to <see cref="IFluxResponseConsumer"/>.
/// </summary>
/// <param name="source">CSV Data source</param>
/// <param name="cancellable">to cancel parsing</param>
/// <param name="consumer">to accept <see cref="FluxTable"/> or <see cref="FluxRecord"/></param>
public void ParseFluxResponse(Stream source, ICancellable cancellable, IFluxResponseConsumer consumer)
{
Arguments.CheckNotNull(source, "source");
var parsingState = ParsingState.Normal;
var tableIndex = 0;
var tableId = -1;
var startNewTable = false;
FluxTable table = null;
using (var csv = new CsvReader(new StreamReader(source)))
{
while (csv.Read())
{
if (cancellable != null && cancellable.IsCancelled())
{
return;
}
//
// Response has HTTP status ok, but response is error.
//
if ("error".Equals(csv[1]) && "reference".Equals(csv[2]))
{
parsingState = ParsingState.InError;
continue;
}
//
// Throw InfluxException with error response
//
if (ParsingState.InError.Equals(parsingState))
{
var error = csv[1];
var referenceValue = csv[2];
var reference = 0;
if (referenceValue != null && !String.IsNullOrEmpty(referenceValue))
{
reference = Convert.ToInt32(referenceValue);
}
throw new FluxQueryException(error, reference);
}
var token = csv[0];
//// start new table
if ("#datatype".Equals(token))
{
startNewTable = true;
table = new FluxTable();
consumer.Accept(tableIndex, cancellable, table);
tableIndex++;
tableId = -1;
}
else if (table == null)
{
throw new FluxCsvParserException(
"Unable to parse CSV response. FluxTable definition was not found.");
}
//#datatype,string,long,dateTime:RFC3339,dateTime:RFC3339,dateTime:RFC3339,double,string,string,string
if ("#datatype".Equals(token))
{
AddDataTypes(table, csv);
}
else if ("#group".Equals(token))
{
AddGroups(table, csv);
}
else if ("#default".Equals(token))
{
AddDefaultEmptyValues(table, csv);
}
else
{
// parse column names
if (startNewTable)
{
AddColumnNamesAndTags(table, csv);
startNewTable = false;
continue;
}
int currentId;
try
{
currentId = Convert.ToInt32(csv[1 + 1]);
}
catch (Exception)
{
throw new FluxCsvParserException("Unable to parse CSV response.");
}
if (tableId == -1)
{
tableId = currentId;
}
if (tableId != currentId)
{
//create new table with previous column headers settings
var fluxColumns = table.Columns;
table = new FluxTable();
table.Columns.AddRange(fluxColumns);
consumer.Accept(tableIndex, cancellable, table);
tableIndex++;
tableId = currentId;
}
var fluxRecord = ParseRecord(tableIndex - 1, table, csv);
consumer.Accept(tableIndex - 1, cancellable, fluxRecord);
}
}
}
}
public void Accept(int index, ICancellable cancellable, FluxTable table)
{
Tables.Insert(index, table);
}
private FluxColumn GetFluxColumn(int columnIndex, FluxTable table)
{
Arguments.CheckNotNull(table, "table");
return(table.Columns[columnIndex]);
}
private void InsertMQQTSensorData(Equipment ex, Sensor sx, DateTime dt, Alarm al, String value)
{
try
{
List <decimal> allVal = new List <decimal>();
List <SensorData> dr = new List <SensorData>();
double v = 0;
Double.TryParse(value, out v);
SensorData sxx = new SensorData();
sxx.Related_Equipment = ex.Record_ID.ToString();
sxx.Related_Sensor = sx.Record_ID.ToString();
sxx.TimeStamp = dt.ToString("s") + "Z";
sxx.TimeStampDt = DateTime.SpecifyKind(dt, DateTimeKind.Utc);
sxx.Sensor_Name_Lookup = sx.Tag.ToLower().Replace("/", "_");
sxx.Value = Math.Round(v, 4).ToString();
sxx.DecValue = Math.Round(v, 4);
sxx.Site = ex.Site_Name_Lookup;
sxx.SiteId = ex.Related_Site;
sxx.EquipmentName = ex.Equipment_Name;
allVal.Add((decimal)sxx.DecValue);
dr.Add(sxx);
//Write to Influx
InfluxConnector conn = new InfluxConnector(envconfiguration.GetSection("InfluxServer").Value,
envconfiguration.GetSection("InfluxToken").Value,
envconfiguration.GetSection("InfluxBucket").Value,
envconfiguration.GetSection("InfluxOrg").Value);
conn.WriteData(dr);
String measure = sx.Tag.Replace("/", "_");
// Get data for current day from influx
List <FluxTable> tab = conn.ReadData(ex.Record_ID.ToString(), dt, measure).Result;
//Get data for current day from QB
if (tab != null)
{
if (tab.Count > 0)
{
FluxTable ft = tab[0];
if (ft.Records.Count > 0)
{
foreach (var rec in ft.Records)
{
String cx = rec.GetValue().ToString();
decimal dxm = 0;
if (Decimal.TryParse(cx, out dxm))
{
allVal.Add(dxm);
}
}
}
}
}
DateTime start = new DateTime(dt.Year, dt.Month, dt.Day);
SensorData s = new SensorData();
s.Related_Equipment = ex.Record_ID.ToString();
s.Related_Sensor = sx.Record_ID.ToString();
s.TimeStamp = start.ToString("s") + "Z";
s.TimeStampDt = DateTime.SpecifyKind(start, DateTimeKind.Utc);
s.Sensor_Name_Lookup = sx.Tag.ToLower().Replace("/", "_");
decimal sensorValue = 0;
if (sx.Sensor_Category.Equals("Efficiency"))
{
sensorValue = allVal.Average();
}
else
{
sensorValue = allVal.Sum();
}
s.Value = sensorValue.ToString();
List <SensorData> sensorData = GetData <SensorData>("SensorData", SensorData.fieldIds, "{15.EX.'" + ex.Record_ID + "'}AND{8.EX." +
sx.Record_ID + "}AND{11.OBF.'" + dt.ToString("yyyy-MM-dd") + "'}AND{11.AF.'" + dt.AddDays(-2).ToString("yyyy-MM-dd") + "'}");
var ext = sensorData.Where(u => u.TimeStamp.Equals(dt.ToString("MM/dd/yyyy") + " 12:00:00 AM")).FirstOrDefault();
if (ext != null)
{
s.Record_ID = ext.Record_ID;
}
List <SensorData> dx = UpsertData <SensorData>("SensorData", s, SensorData.fieldIds);
if (dx.Count > 0)
{
// Alarm
if (al != null)
{
bool isAlarm = false;
decimal alVal = Decimal.Parse(al.Formula_Value);
if (al.Formula_Operator.Equals(">"))
{
if (sensorValue > alVal)
{
isAlarm = true;
}
}
else if (al.Formula_Operator.Equals("<"))
{
if (sensorValue < alVal)
{
isAlarm = true;
}
}
else if (al.Formula_Operator.Equals(">="))
{
if (sensorValue >= alVal)
{
isAlarm = true;
}
}
else if (al.Formula_Operator.Equals("<="))
{
if (sensorValue <= alVal)
{
isAlarm = true;
}
}
else if (al.Formula_Operator.Equals("=="))
{
if (sensorValue == alVal)
{
isAlarm = true;
}
}
if (isAlarm)
{
AlarmLog a = new AlarmLog();
a.Alarm_Text = al.Alarm_Name + " Raised - " + al.Priority + " for " + ex.Site_Name_Lookup + "-" + ex.Equipment_Name;
a.Related_Equipment = ex.Record_ID.ToString();
a.Related_Sensor_Datum = dx[0].Record_ID.ToString();
a.Related_Alarm = al.Record_ID.ToString();
List <AlarmLog> da = UpsertData <AlarmLog>("AlarmLog", a, AlarmLog.fieldIds);
}
}
}
}
catch (Exception exx)
{ }
}
