public void SendHourOfWeekLimitTableToCSV(Stream returnStream, int channelID, string searchString, CompatibleCancellationToken cancellationToken, string sortField = "HourOfWeek", bool ascending = true)
{
MetersWithHourlyLimits meter;
ChannelsWithHourlyLimits channel;
List <HourOfWeekLimitView> hourlyLimits = new List <HourOfWeekLimitView>();
using (var connection = new AdoDataConnection("systemSettings"))
{
TableOperations <MetersWithHourlyLimits> meterTable = new TableOperations <MetersWithHourlyLimits>(connection);
TableOperations <ChannelsWithHourlyLimits> channelTable = new TableOperations <ChannelsWithHourlyLimits>(connection);
TableOperations <HourOfWeekLimitView> table = new TableOperations <HourOfWeekLimitView>(connection);
channel = channelTable.QueryRecordWhere("ID = {0}", channelID);
meter = meterTable.QueryRecordWhere("ID = {0}", channel.MeterID);
RecordRestriction searchRestriction = table.GetSearchRestriction(searchString);
RecordRestriction channelRestriction = new RecordRestriction("ChannelID = {0}", channel.ID);
RecordRestriction finalRestriction = searchRestriction + channelRestriction;
string sortExpression = sortField != null ? sortField + (ascending == true ? " ASC" : " DESC") : null;
hourlyLimits = table.QueryRecords(sortExpression, finalRestriction).ToList();
}
string meterInfo = meter.ToCSV();
string channelInfo = channel.ToCSV();
using (StreamWriter writer = new StreamWriter(returnStream))
foreach (HourOfWeekLimitView limit in hourlyLimits)
{
writer.WriteLine(meterInfo + "," + channelInfo + "," + limit.ToCSV());
}
}
public IEnumerable <ChannelsWithNormalLimits> QueryChannelsWithNormalLimits(int meterId, string sortField, bool ascending, int page, int pageSize, string filterText)
{
TableOperations <ChannelsWithNormalLimits> table = DataContext.Table <ChannelsWithNormalLimits>();
RecordRestriction restriction = table.GetSearchRestriction(filterText);
return(table.QueryRecords(sortField, ascending, page, pageSize, new RecordRestriction("MeterID = {0}", meterId) + restriction));
}
public void SendChannelsWithHourlyLimitsToCSV(Stream returnStream, int meterID, string searchString, CompatibleCancellationToken cancellationToken, string sortField = "Name", bool ascending = true)
{
MetersWithHourlyLimits meter;
List <ChannelsWithHourlyLimits> channels;
using (var connection = new AdoDataConnection("systemSettings"))
{
TableOperations <MetersWithHourlyLimits> meterTable = new TableOperations <MetersWithHourlyLimits>(connection);
TableOperations <ChannelsWithHourlyLimits> channelTable = new TableOperations <ChannelsWithHourlyLimits>(connection);
meter = meterTable.QueryRecordWhere("ID = {0}", meterID);
string sortExpression = sortField != null ? sortField + (ascending == true ? " ASC" : " DESC") : null;
RecordRestriction searchRestriction = channelTable.GetSearchRestriction(searchString);
RecordRestriction meterRestriction = new RecordRestriction("MeterID = {0}", meterID);
RecordRestriction finalRestriction = searchRestriction + meterRestriction;
channels = channelTable.QueryRecords(sortExpression, finalRestriction).ToList();
}
foreach (var channel in channels)
{
if (cancellationToken.IsCancelled)
{
return;
}
SendHourOfWeekLimitTableToCSV(returnStream, channel.ID, "", cancellationToken);
}
}
public int QueryChannelsWithNormalLimitsCount(int meterId, string filterText)
{
TableOperations <ChannelsWithNormalLimits> table = DataContext.Table <ChannelsWithNormalLimits>();
RecordRestriction restriction = table.GetSearchRestriction(filterText);
return(table.QueryRecordCount(new RecordRestriction("MeterID = {0}", meterId) + restriction));
}
public IEnumerable <HourOfWeekLimitView> QueryHourOfWeekLimit(int channelId, string sortField, bool ascending, int page, int pageSize, string filterText)
{
TableOperations <HourOfWeekLimitView> table = DataContext.Table <HourOfWeekLimitView>();
RecordRestriction restriction = table.GetSearchRestriction(filterText);
return(table.QueryRecords(sortField, ascending, page, pageSize, new RecordRestriction("ChannelID = {0}", channelId) + restriction));
}
public int QueryHourOfWeekLimitCount(int channelId, string filterText)
{
TableOperations <HourOfWeekLimit> table = DataContext.Table <HourOfWeekLimit>();
RecordRestriction restriction = table.GetSearchRestriction(filterText);
return(table.QueryRecordCount(new RecordRestriction("ChannelID = {0}", channelId) + restriction));
}
public void SendChannelsWithNormalLimitsToCSV(Stream returnStream, int meterID, string searchString, CompatibleCancellationToken cancellationToken, string sortField = "Name", bool ascending = true)
{
MetersWithNormalLimits meter;
IEnumerable <ChannelsWithNormalLimits> channels;
using (var connection = new AdoDataConnection("systemSettings"))
{
TableOperations <MetersWithNormalLimits> meterTable = new TableOperations <MetersWithNormalLimits>(connection);
TableOperations <ChannelsWithNormalLimits> channelTable = new TableOperations <ChannelsWithNormalLimits>(connection);
meter = meterTable.QueryRecordWhere("ID = {0}", meterID);
RecordRestriction searchRestriction = channelTable.GetSearchRestriction(searchString);
string sortExpression = sortField != null ? sortField + (ascending == true ? " ASC" : " DESC") : null;
channels = channelTable.QueryRecords(sortExpression, new RecordRestriction("MeterID = {0}", meterID) + searchRestriction).ToList();
}
string meterInfo = meter.ToCSV();
using (StreamWriter writer = new StreamWriter(returnStream))
foreach (ChannelsWithNormalLimits limit in channels)
{
writer.WriteLine(meterInfo + "," + limit.ToCSV());
}
}
public static Event GetEvent(this TableOperations <Event> eventTable, FileGroup fileGroup, DataGroup dataGroup)
{
int fileGroupID = fileGroup.ID;
int lineID = dataGroup.Line.ID;
DateTime startTime = dataGroup.StartTime;
DateTime endTime = dataGroup.EndTime;
int samples = dataGroup.Samples;
IDbDataParameter startTimeParameter = new SqlParameter()
{
ParameterName = nameof(dataGroup.StartTime),
DbType = DbType.DateTime2,
Value = startTime
};
IDbDataParameter endTimeParameter = new SqlParameter()
{
ParameterName = nameof(dataGroup.EndTime),
DbType = DbType.DateTime2,
Value = endTime
};
RecordRestriction recordRestriction =
new RecordRestriction("FileGroupID = {0}", fileGroupID) &
new RecordRestriction("LineID = {0}", lineID) &
new RecordRestriction("StartTime = {0}", startTimeParameter) &
new RecordRestriction("EndTime = {0}", endTimeParameter) &
new RecordRestriction("Samples = {0}", samples);
return(eventTable.QueryRecord(recordRestriction));
}
private void CreateOrUpdate(ImportedMeasurement measurement)
{
TransactionScopeOption transactionScopeOption = TransactionScopeOption.Required;
TransactionOptions transactionOptions = new TransactionOptions()
{
IsolationLevel = IsolationLevel.ReadCommitted,
Timeout = TransactionManager.MaximumTimeout
};
measurement.NodeID = NodeID;
measurement.Source = Source;
using (TransactionScope transactionScope = new TransactionScope(transactionScopeOption, transactionOptions))
using (AdoDataConnection connection = CreateDbConnection())
{
TableOperations <ImportedMeasurement> importedMeasurementTable = new TableOperations <ImportedMeasurement>(connection);
RecordRestriction recordRestriction =
new RecordRestriction("NodeID = {0}", measurement.NodeID) &
new RecordRestriction("Source = {0}", measurement.Source) &
new RecordRestriction("PointID = {0}", measurement.PointID);
int measurementCount = importedMeasurementTable.UpdateRecord(measurement, recordRestriction);
if (measurementCount == 0)
{
importedMeasurementTable.AddNewRecord(measurement);
}
transactionScope.Complete();
}
}
public void Initialize(AdoDataConnection connection, VICycleDataGroup viCycleDataGroup, double systemFrequency)
{
int samplesPerCycle = Transform.CalculateSamplesPerCycle(viCycleDataGroup.VA.RMS, systemFrequency);
TableOperations <FaultSegment> faultSegmentTable = new TableOperations <FaultSegment>(connection);
RecordRestriction recordRestriction =
new RecordRestriction("EventID = {0}", Fault.EventID) &
new RecordRestriction("StartTime = {0}", ToDateTime2(connection, Fault.Inception)) &
new RecordRestriction("(SELECT Name FROM SegmentType WHERE ID = SegmentTypeID) = 'Fault'");
FaultSegment faultSegment = faultSegmentTable.QueryRecord(recordRestriction);
if ((object)faultSegment == null)
{
throw new InvalidOperationException($"Unable to find fault segment that matches fault summary for event {Fault.EventID}.");
}
StartSample = faultSegment.StartSample;
EndSample = faultSegment.EndSample - samplesPerCycle + 1;
CycleDataGroup = Rotate(viCycleDataGroup.ToSubSet(StartSample, EndSample));
DistanceCurve.StartIndex = StartSample;
AngleCurve.StartIndex = StartSample;
}
/// <summary>
/// Gets the users for a specific role filtered using primeui autocomplete
/// </summary>
/// <param name="role">Role that you want users from</param>
/// <param name="searchText">primeui search text</param>
/// <param name="limit">number of users to return, -1 is default and returns all</param>
/// <returns>IENumerable of ID Labels used with primeui autocomplete</returns>
public IEnumerable <IDLabel> SearchUsers(string role, string searchText, int limit = -1)
{
RecordRestriction restriction = new RecordRestriction("ID IN (SELECT UserAccountID FROM ApplicationRoleUserAccount WHERE ApplicationRoleUserAccount.ApplicationRoleID IN (SELECT ID FROM ApplicationRole WHERE Name = {0}))", role);
if (limit < 1)
{
return(DataContext
.Table <UserAccount>()
.QueryRecords(restriction: restriction)
.Select(record =>
{
record.Name = UserInfo.SIDToAccountName(record.Name ?? "");
return record;
})
.Where(record => record.Name?.ToLower().Contains(searchText.ToLower()) ?? false)
.Select(record => IDLabel.Create(record.ID.ToString(), record.Name)));
}
return(DataContext
.Table <UserAccount>()
.QueryRecords(restriction: restriction)
.Select(record =>
{
record.Name = UserInfo.SIDToAccountName(record.Name ?? "");
return record;
})
.Where(record => record.Name?.ToLower().Contains(searchText.ToLower()) ?? false)
.Take(limit)
.Select(record => IDLabel.Create(record.ID.ToString(), record.Name)));
}
public IEnumerable <UserAccount> QueryUserAccounts(string sortField, bool ascending, int page, int pageSize, string filterText)
{
TableOperations <UserAccount> tableOperations = DataContext.Table <UserAccount>();
RecordRestriction restriction = tableOperations.GetSearchRestriction(filterText);
return(tableOperations.QueryRecords(sortField, ascending, page, pageSize, restriction));
}
public int QueryUserAccountCount(string filterText)
{
TableOperations <UserAccount> tableOperations = DataContext.Table <UserAccount>();
RecordRestriction restriction = tableOperations.GetSearchRestriction(filterText);
return(tableOperations.QueryRecordCount(restriction));
}
private Meter LoadMeterFromDatabase(MeterDataSet meterDataSet)
{
using (AdoDataConnection connection = meterDataSet.CreateDbConnection())
{
Meter LoadCurrentMeter()
{
TableOperations <Meter> meterTable = new TableOperations <Meter>(connection);
Meter parsedMeter = meterDataSet.Meter;
Meter dbMeter = meterTable.QueryRecordWhere("AssetKey = {0}", parsedMeter.AssetKey);
dbMeter.ConnectionFactory = meterDataSet.CreateDbConnection;
return(dbMeter);
}
Meter LoadHistoricMeter()
{
const string ConfigKey = "openXDA";
TableOperations <MeterConfiguration> meterConfigurationTable = new TableOperations <MeterConfiguration>(connection);
RecordRestriction recordRestriction =
new RecordRestriction("ConfigKey = {0}", ConfigKey) &
new RecordRestriction("{0} IN (SELECT FileGroupID FROM FileGroupMeterConfiguration WHERE MeterConfigurationID = MeterConfiguration.ID)", meterDataSet.FileGroup.ID);
MeterConfiguration meterConfiguration = meterConfigurationTable.QueryRecord("ID DESC", recordRestriction);
if (meterConfiguration == null)
{
// Need to find the oldest configuration record for this meter
Meter dbMeter = LoadCurrentMeter();
int? meterID = dbMeter?.ID;
recordRestriction =
new RecordRestriction("MeterID = {0}", meterID) &
new RecordRestriction("ConfigKey = {0}", ConfigKey) &
new RecordRestriction("ID NOT IN (SELECT DiffID FROM MeterConfiguration WHERE DiffID IS NOT NULL)");
meterConfiguration = meterConfigurationTable.QueryRecord("ID", recordRestriction);
}
if (meterConfiguration == null)
{
return(null);
}
MeterSettingsSheet settingsSheet = new MeterSettingsSheet(meterConfigurationTable, meterConfiguration);
return(settingsSheet.Meter);
}
Log.Info("Locating meter in database...");
if (meterDataSet.LoadHistoricConfiguration)
{
return(LoadHistoricMeter());
}
return(LoadCurrentMeter());
}
}
/// <summary>
/// Generates template based select field based on reflected modeled table field attributes with values derived from ValueList table.
/// </summary>
/// <typeparam name="T">Modeled table for select field.</typeparam>
/// <param name="groupName">Value list group name as defined in ValueListGroup table.</param>
/// <param name="fieldName">Field name for value of select field.</param>
/// <param name="optionLabelFieldName">Field name for label of option data, defaults to "Text"</param>
/// <param name="optionValueFieldName">Field name for ID of option data, defaults to "Key".</param>
/// <param name="optionSortFieldName">Field name for sort order of option data, defaults to "SortOrder"</param>
/// <param name="fieldLabel">Label name for select field, pulls from <see cref="LabelAttribute"/> if defined, otherwise defaults to <paramref name="fieldName"/>.</param>
/// <param name="fieldID">ID to use for select field; defaults to select + <paramref name="fieldName"/>.</param>
/// <param name="groupDataBinding">Data-bind operations to apply to outer form-group div, if any.</param>
/// <param name="labelDataBinding">Data-bind operations to apply to label, if any.</param>
/// <param name="customDataBinding">Extra custom data-binding operations to apply to field, if any.</param>
/// <param name="dependencyFieldName">Defines default "enabled" subordinate data-bindings based a single boolean field, e.g., a check-box.</param>
/// <param name="optionDataBinding">Data-bind operations to apply to each option value, if any.</param>
/// <param name="toolTip">Tool tip text to apply to field, if any.</param>
/// <param name="initialFocus">Use field for initial focus.</param>
/// <returns>Generated HTML for new text field based on modeled table field attributes.</returns>
public string AddValueListSelectField <T>(string fieldName, string groupName, string optionLabelFieldName = "Text", string optionValueFieldName = "Key", string optionSortFieldName = "SortOrder", string fieldLabel = null, string fieldID = null, string groupDataBinding = null, string labelDataBinding = null, string customDataBinding = null, string dependencyFieldName = null, string optionDataBinding = null, string toolTip = null, bool initialFocus = false) where T : class, new()
{
int key = DataContext.Connection.ExecuteScalar <int?>("SELECT ID FROM ValueListGroup WHERE Name={0} AND Enabled <> 0", groupName) ?? 0;
RecordRestriction restriction = new RecordRestriction("GroupID = {0} AND Enabled <> 0 AND Hidden = 0", key);
return(DataContext.AddSelectField <T, ValueList>(fieldName, optionValueFieldName, optionLabelFieldName, optionSortFieldName, fieldLabel, fieldID, groupDataBinding, labelDataBinding, null, customDataBinding, dependencyFieldName, optionDataBinding, toolTip, initialFocus, restriction));
}
public int QueryIncidentEventCycleDataViewCount(string date, string name, string levels, string limits, string timeContext, string filterString)
{
TableOperations <IncidentEventCycleDataView> table = DataContext.Table <IncidentEventCycleDataView>();
RecordRestriction filterRestriction = table.GetSearchRestriction(filterString);
DateTime startDate = DateTime.ParseExact(date, "yyyyMMddHH", CultureInfo.InvariantCulture);
DateTime endDate = (DateTime)typeof(DateTime).GetMethod("Add" + timeContext).Invoke(startDate, new object[] { 1 });
return(table.QueryRecordCount(filterRestriction + new RecordRestriction("StartTime BETWEEN {0} AND {1}", startDate, endDate) + new RecordRestriction(levels + " = {0}", name)));
}
public Task <DataTable> GetDataFiles([FromBody] GetDataFilesPostData postData, CancellationToken cancellationToken)
{
return(Task.Run(() =>
{
using (AdoDataConnection connection = new AdoDataConnection("systemSettings"))
{
const string QueryFormat =
"WITH cte AS " +
"( " +
" SELECT * " +
" FROM DataFile " +
" WHERE {0} " +
") " +
"SELECT DataFile.* " +
"FROM " +
"( " +
" SELECT " +
" ROW_NUMBER() OVER(ORDER BY {2}) AS RowNumber, " +
" DataFile.* " +
" FROM (SELECT DISTINCT FileGroupID ID FROM cte) FileGroup CROSS APPLY " +
" ( " +
" SELECT TOP 1 * " +
" FROM cte DataFile " +
" WHERE DataFile.FileGroupID = FileGroup.ID " +
" ORDER BY FileSize DESC, FilePath " +
" ) DataFile " +
") DataFile " +
"WHERE {1} " +
"ORDER BY RowNumber";
TableOperations <DataFile> dataFileTable = new TableOperations <DataFile>(connection);
RecordRestriction searchRestriction = dataFileTable.GetSearchRestriction(postData.filterString)
?? new RecordRestriction("1=1");
string searchClause = searchRestriction.FilterExpression;
int paramIndex = searchRestriction.Parameters.Length;
string pageClause = $"RowNumber BETWEEN {{{paramIndex}}} AND {{{paramIndex + 1}}}";
string sortOrder = postData.ascending ? "ASC" : "DESC";
string orderByClause = $"{postData.sortField} {sortOrder}";
string query = string.Format(QueryFormat, searchClause, pageClause, orderByClause);
int pageStart = (postData.page - 1) * postData.pageSize + 1;
int pageEnd = pageStart + postData.pageSize - 1;
object[] parameters = searchRestriction.Parameters
.Concat(new object[] { pageStart, pageEnd })
.ToArray();
return connection
.RetrieveData(query, parameters);
}
}, cancellationToken));
}
public IEnumerable <PhasorDetail> QueryPhasors(int deviceID, string sortField, bool ascending, int page, int pageSize, string filterText)
{
TableOperations <PhasorDetail> phasorDetailTable = DataContext.Table <PhasorDetail>();
RecordRestriction restriction = (deviceID > 0 ?
new RecordRestriction("DeviceID = {0}", deviceID) : null) +
phasorDetailTable.GetSearchRestriction(filterText);
return(DataContext.Table <PhasorDetail>().QueryRecords(sortField, ascending, page, pageSize, restriction));
}
public int QueryPhasorCount(int deviceID, string filterText)
{
TableOperations <PhasorDetail> phasorDetailTable = DataContext.Table <PhasorDetail>();
RecordRestriction restriction = (deviceID > 0 ?
new RecordRestriction("DeviceID = {0}", deviceID) : null) +
phasorDetailTable.GetSearchRestriction(filterText);
return(phasorDetailTable.QueryRecordCount(restriction));
}
public IEnumerable <DeviceGroup> QueryDeviceGroups(Guid nodeID, string sortField, bool ascending, int page, int pageSize, string filterText)
{
TableOperations <DeviceGroup> deviceGroupTable = DataContext.Table <DeviceGroup>();
RecordRestriction restriction =
new RecordRestriction("NodeID = {0} AND ProtocolID = {1} AND AccessID = {2}", nodeID, VirtualProtocolID, DeviceGroup.DefaultAccessID) +
deviceGroupTable.GetSearchRestriction(filterText);
return(deviceGroupTable.QueryRecords(sortField, ascending, page, pageSize, restriction));
}
public int QueryDeviceGroupCount(Guid nodeID, string filterText)
{
TableOperations <DeviceGroup> deviceGroupTable = DataContext.Table <DeviceGroup>();
RecordRestriction restriction =
new RecordRestriction("NodeID = {0} AND ProtocolID = {1} AND AccessID = {2}", nodeID, VirtualProtocolID, DeviceGroup.DefaultAccessID) +
deviceGroupTable.GetSearchRestriction(filterText);
return(deviceGroupTable.QueryRecordCount(restriction));
}
public IEnumerable <Device> QueryDevices(Guid nodeID, string sortField, bool ascending, int page, int pageSize, string filterText)
{
TableOperations <Device> deviceTable = DataContext.Table <Device>();
RecordRestriction restriction =
new RecordRestriction("NodeID = {0}", nodeID) +
deviceTable.GetSearchRestriction(filterText);
return(deviceTable.QueryRecords(sortField, ascending, page, pageSize, restriction));
}
private string GetHeaders(DataContext dataContext, IEnumerable <int> pointIDs)
{
object[] parameters = pointIDs.Cast <object>().ToArray();
string parameterizedQueryString = $"PointID IN ({string.Join(",", parameters.Select((parameter, index) => $"{{{index}}}"))})";
RecordRestriction pointIDRestriction = new RecordRestriction(parameterizedQueryString, parameters);
return("\"Timestamp\"," + string.Join(",", dataContext.Table <Measurement>().
QueryRecords(restriction: pointIDRestriction).
Select(measurement => $"\"[{measurement.PointID}] {measurement.PointTag}\"")));
}
public int QueryDeviceCount(Guid nodeID, string filterText)
{
TableOperations <Device> deviceTable = DataContext.Table <Device>();
RecordRestriction restriction =
new RecordRestriction("NodeID = {0}", nodeID) +
deviceTable.GetSearchRestriction(filterText);
return(deviceTable.QueryRecordCount(restriction));
}
public IEnumerable <Device> QueryEnabledDevices(Guid nodeID, int limit, string filterText)
{
TableOperations <Device> deviceTable = DataContext.Table <Device>();
RecordRestriction restriction =
new RecordRestriction("NodeID = {0} AND NOT (ProtocolID = {1} AND AccessID = {2})", nodeID, VirtualProtocolID, DeviceGroup.DefaultAccessID) +
new RecordRestriction("Enabled <> 0") +
deviceTable.GetSearchRestriction(filterText);
return(deviceTable.QueryRecords("Acronym", restriction, limit));
}
public IEnumerable <Device> QueryEnabledDevices(Guid nodeID, int limit, string filterText)
{
TableOperations <Device> deviceTable = DataContext.Table <Device>();
RecordRestriction restriction =
new RecordRestriction("NodeID = {0}", nodeID) +
new RecordRestriction("Enabled <> 0") +
deviceTable.GetSearchRestriction(filterText);
return(deviceTable.QueryRecords("Acronym", restriction, limit));
}
public void DeleteMeasurement(long id)
{
long pointID = id;
using (AdoDataConnection connection = CreateDbConnection())
{
TableOperations <ImportedMeasurement> importedMeasurementTable = new TableOperations <ImportedMeasurement>(connection);
RecordRestriction recordRestriction =
new RecordRestriction("NodeID = {0}", NodeID) &
new RecordRestriction("Source = {0}", Source) &
new RecordRestriction("PointID = {0}", pointID);
importedMeasurementTable.DeleteRecord(recordRestriction);
}
}
private RecordRestriction GetRecordRestriction(int meterID, int phaseID, string type)
{
RecordRestriction recordRestriction = new RecordRestriction("MeasurementTypeID = (SELECT ID FROM MeasurementType WHERE Name = 'Voltage') AND MeterID = {0} AND PhaseID = {1}", meterID, phaseID);
RecordRestriction recordRestriction2 = null;
switch (type)
{
case "Interharmonic": recordRestriction2 = new RecordRestriction("Name LIKE '%Interharmonic%'"); break;
case "HighResolution": recordRestriction2 = new RecordRestriction("Name LIKE '%khz'"); break;
case "LowResolution": recordRestriction2 = new RecordRestriction("Name LIKE '%Bin%'"); break;
default: recordRestriction2 = new RecordRestriction("Name LIKE '% Harmonic%' AND HarmonicGroup != 1"); break;
}
return(recordRestriction + recordRestriction2);
}
private IEnumerable <ImportedMeasurement> QueryImportedMeasurements(RecordRestriction recordRestriction = null)
{
using (AdoDataConnection connection = CreateDbConnection())
{
TableOperations <ImportedMeasurement> importedMeasurementTable = new TableOperations <ImportedMeasurement>(connection);
RecordRestriction queryRestriction =
new RecordRestriction("NodeID = {0}", NodeID) &
new RecordRestriction("Source = {0}", Source);
if ((object)recordRestriction != null)
{
queryRestriction &= recordRestriction;
}
return(importedMeasurementTable.QueryRecords(queryRestriction));
}
}
private static void GenerateEmail(LineEvent lineEvent)
{
using (AdoDataConnection connection = s_connectionFactory())
{
TableOperations <Event> eventTable = new TableOperations <Event>(connection);
object startTime2 = ToDateTime2(connection, lineEvent.TimeRange.Start);
object endTime2 = ToDateTime2(connection, lineEvent.TimeRange.End);
RecordRestriction recordRestriction =
new RecordRestriction("LineID = {0}", lineEvent.LineID) &
new RecordRestriction("StartTime >= {0}", startTime2) &
new RecordRestriction("EndTime <= {0}", endTime2);
Event evt = eventTable.QueryRecord(recordRestriction);
GenerateEmail(connection, evt.ID);
}
}
