public void Unsubscribe <T>(string channel, string subscriberKey)
{
var channelKey = new ChannelKey(channel, typeof(T));
List <Subscription> subs = GetSubscriptions(channelKey);
subs.RemoveAll(s => s.SusbcriberKey == subscriberKey);
}
public PooledClientChannel(IClientConnectionPool pool, ChannelKey key)
{
Guard.ArgumentNotNull(pool, nameof(pool));
_pool = pool;
_innerChannel = _pool.BorrowChannel(key);
this._key = key;
}
public override int GetHashCode()
{
unchecked
{
return(((ChannelKey != null ? ChannelKey.GetHashCode() : 0) * 397)
^ (Exception != null ? Exception.GetHashCode() : 0));
}
}
public void Subscribe <T>(string channel, string subscriberKey, Action <T> response)
{
var channelKey = new ChannelKey(channel, typeof(T));
List <Subscription> subs = GetSubscriptions(channelKey);
subs.RemoveAll(s => s.SusbcriberKey == subscriberKey);
subs.Add(new Subscription(subscriberKey, response));
Channels[channelKey] = subs;
}
public INiftyClientChannel BorrowChannel(ChannelKey key)
{
var connector = new FramedClientConnector(key.IpEndPoint.Address.ToString(), key.IpEndPoint.Port,
_options.LoggerFactory);
var channel = _thriftClientManager.CreateChannelAsync(connector, TimeSpan.FromMilliseconds(key.ConnectionTimeout),
TimeSpan.FromMilliseconds(key.ReceiveTimeout), TimeSpan.FromMilliseconds(key.ReadTimeout),
TimeSpan.FromMilliseconds(key.WriteTimeout), _options.MaxFrameSize, key.SslConfig, _options.SocketProxy);
return(channel.GetAwaiter().GetResult());
}
public void Publish(string channel)
{
var channelKey = new ChannelKey(channel, null);
List <Subscription> subs = GetSubscriptions(channelKey);
foreach (var sub in subs)
{
if (sub.Reponse.IsAlive)
{
Action subResponse = sub.Reponse.Target as Action;
subResponse?.Invoke();
}
}
}
public void Publish <T>(string channel, T parameter)
{
var channelKey = new ChannelKey(channel, typeof(T));
List <Subscription> subs = GetSubscriptions(channelKey);
foreach (var sub in subs)
{
if (sub.Reponse.IsAlive)
{
Action <T> subResponse = sub.Reponse.Target as Action <T>;
subResponse?.Invoke(parameter);
}
}
}
private Series GetSeriesInfo(Series timeDomainSeries, string channelDesignation, string measurementCharacteristicName)
{
string channelName;
string measurementTypeName;
string phaseName;
string seriesTypeName;
ChannelKey channelKey;
SeriesKey seriesKey;
channelName = string.Concat(timeDomainSeries.Channel.Name, " ", channelDesignation);
measurementTypeName = timeDomainSeries.Channel.MeasurementType.Name;
phaseName = timeDomainSeries.Channel.Phase.Name;
seriesTypeName = timeDomainSeries.SeriesType.Name;
channelKey = new ChannelKey(timeDomainSeries.Channel.LineID, 0, channelName, measurementTypeName, measurementCharacteristicName, phaseName);
seriesKey = new SeriesKey(channelKey, seriesTypeName);
return(GetSeriesInfo(timeDomainSeries.Channel.Meter, channelKey, seriesKey));
}
// Static Methods
private static Series GetSeriesInfo(MeterInfoDataContext meterInfo, Meter meter, DataGroup dataGroup, string measurementTypeName, string phaseName)
{
int lineID;
string measurementCharacteristicName;
string seriesTypeName;
char typeDesignation;
char phaseDesignation;
string channelName;
DataContextLookup<ChannelKey, Channel> channelLookup;
DataContextLookup<SeriesKey, Series> seriesLookup;
DataContextLookup<string, MeasurementType> measurementTypeLookup;
DataContextLookup<string, MeasurementCharacteristic> measurementCharacteristicLookup;
DataContextLookup<string, Phase> phaseLookup;
DataContextLookup<string, SeriesType> seriesTypeLookup;
ChannelKey channelKey;
SeriesKey seriesKey;
lineID = dataGroup.Line.ID;
measurementCharacteristicName = "Instantaneous";
seriesTypeName = "Values";
typeDesignation = (measurementTypeName == "Current") ? 'I' : measurementTypeName[0];
phaseDesignation = (phaseName == "RES") ? 'R' : phaseName[0];
channelName = string.Concat(typeDesignation, phaseDesignation);
channelLookup = new DataContextLookup<ChannelKey, Channel>(meterInfo, channel => new ChannelKey(channel))
.WithFilterExpression(channel => channel.MeterID == meter.ID)
.WithFilterExpression(channel => channel.LineID == dataGroup.Line.ID);
seriesLookup = new DataContextLookup<SeriesKey, Series>(meterInfo, series => new SeriesKey(series))
.WithFilterExpression(series => series.Channel.Meter.ID == meter.ID)
.WithFilterExpression(series => series.Channel.Line.ID == dataGroup.Line.ID);
measurementTypeLookup = new DataContextLookup<string, MeasurementType>(meterInfo, measurementType => measurementType.Name);
measurementCharacteristicLookup = new DataContextLookup<string, MeasurementCharacteristic>(meterInfo, measurementCharacteristic => measurementCharacteristic.Name);
phaseLookup = new DataContextLookup<string, Phase>(meterInfo, phase => phase.Name);
seriesTypeLookup = new DataContextLookup<string, SeriesType>(meterInfo, seriesType => seriesType.Name);
channelKey = new ChannelKey(lineID, 0, channelName, measurementTypeName, measurementCharacteristicName, phaseName);
seriesKey = new SeriesKey(channelKey, seriesTypeName);
return seriesLookup.GetOrAdd(seriesKey, key =>
{
SeriesType seriesType = seriesTypeLookup.GetOrAdd(key.SeriesType, name => new SeriesType() { Name = name, Description = name });
Channel channel = channelLookup.GetOrAdd(channelKey, chKey =>
{
MeasurementType measurementType = measurementTypeLookup.GetOrAdd(chKey.MeasurementType, name => new MeasurementType() { Name = name, Description = name });
MeasurementCharacteristic measurementCharacteristic = measurementCharacteristicLookup.GetOrAdd(chKey.MeasurementCharacteristic, name => new MeasurementCharacteristic() { Name = name, Description = name });
Phase phase = phaseLookup.GetOrAdd(chKey.Phase, name => new Phase() { Name = name, Description = name });
return new Channel()
{
Meter = meter,
Line = dataGroup.Line,
MeasurementType = measurementType,
MeasurementCharacteristic = measurementCharacteristic,
Phase = phase,
Name = chKey.Name,
SamplesPerHour = dataGroup.SamplesPerHour,
PerUnitValue = 0,
HarmonicGroup = 0,
Description = string.Concat(measurementCharacteristic.Name, " ", measurementType.Name, " ", phase.Name),
Enabled = 1
};
});
return new Series()
{
SeriesType = seriesType,
Channel = channel,
SourceIndexes = string.Empty
};
});
}
private List <Subscription> GetSubscriptions(ChannelKey key)
=> Channels.ContainsKey(key)
? Channels[key] ?? new List <Subscription>()
: new List <Subscription>();
public void ClearChannel(ChannelKey key)
{
}
public void ReturnChannel(ChannelKey key, INiftyClientChannel channel)
{
channel.CloseAsync();
}
// Static Methods
private static Series GetSeriesInfo(Meter meter, DataGroup dataGroup, string measurementTypeName, string phaseName, int assetID)
{
string measurementCharacteristicName = "Instantaneous";
string seriesTypeName = "Values";
char typeDesignation = (measurementTypeName == "Current") ? 'I' : measurementTypeName[0];
string phaseDesignation = (phaseName == "RES") ? "R" : phaseName.TrimEnd('N');
string channelName = string.Concat(typeDesignation, phaseDesignation);
ChannelKey channelKey = new ChannelKey(assetID, 0, channelName, measurementTypeName, measurementCharacteristicName, phaseName);
SeriesKey seriesKey = new SeriesKey(channelKey, seriesTypeName);
Series dbSeries = meter.Channels
.SelectMany(channel => channel.Series)
.FirstOrDefault(series => seriesKey.Equals(new SeriesKey(series)));
if ((object)dbSeries == null)
{
Channel dbChannel = meter.Channels
.FirstOrDefault(channel => channelKey.Equals(new ChannelKey(channel)));
//need to get Asset based on the asset of the datagroup or the connected assets
Asset asset = dataGroup.Asset;
if (asset.ID != assetID)
{
List <Asset> connectedAssets = asset.ConnectedAssets.ToList();
asset = connectedAssets.Find(item => item.ID == assetID);
}
if ((object)dbChannel == null)
{
MeasurementType measurementType = new MeasurementType()
{
Name = measurementTypeName
};
MeasurementCharacteristic measurementCharacteristic = new MeasurementCharacteristic()
{
Name = measurementCharacteristicName
};
Phase phase = new Phase()
{
Name = phaseName
};
dbChannel = new Channel()
{
MeterID = meter.ID,
AssetID = assetID,
MeasurementTypeID = measurementType.ID,
MeasurementCharacteristicID = measurementCharacteristic.ID,
PhaseID = phase.ID,
Name = channelKey.Name,
SamplesPerHour = dataGroup.SamplesPerHour,
Description = string.Concat(measurementCharacteristicName, " ", measurementTypeName, " ", phaseName),
Enabled = true,
Meter = meter,
Asset = asset,
MeasurementType = measurementType,
MeasurementCharacteristic = measurementCharacteristic,
Phase = phase,
Series = new List <Series>()
};
meter.Channels.Add(dbChannel);
}
SeriesType seriesType = new SeriesType()
{
Name = seriesTypeName
};
dbSeries = new Series()
{
ChannelID = dbChannel.ID,
SeriesTypeID = seriesType.ID,
SourceIndexes = string.Empty,
Channel = dbChannel,
SeriesType = seriesType
};
dbChannel.Series.Add(dbSeries);
}
return(dbSeries);
}
// Static Methods
private static Series GetSeriesInfo(Meter meter, DataGroup dataGroup, string measurementTypeName, string phaseName)
{
int lineID = dataGroup.Line.ID;
string measurementCharacteristicName = "Instantaneous";
string seriesTypeName = "Values";
char typeDesignation = (measurementTypeName == "Current") ? 'I' : measurementTypeName[0];
string phaseDesignation = (phaseName == "RES") ? "R" : phaseName.TrimEnd('N');
string channelName = string.Concat(typeDesignation, phaseDesignation);
ChannelKey channelKey = new ChannelKey(lineID, 0, channelName, measurementTypeName, measurementCharacteristicName, phaseName);
SeriesKey seriesKey = new SeriesKey(channelKey, seriesTypeName);
Series dbSeries = meter.Channels
.SelectMany(channel => channel.Series)
.FirstOrDefault(series => seriesKey.Equals(new SeriesKey(series)));
if ((object)dbSeries == null)
{
using (AdoDataConnection connection = meter.ConnectionFactory())
{
Channel dbChannel = meter.Channels
.FirstOrDefault(channel => channelKey.Equals(new ChannelKey(channel)));
if ((object)dbChannel == null)
{
TableOperations <Channel> channelTable = new TableOperations <Channel>(connection);
TableOperations <MeasurementType> measurementTypeTable = new TableOperations <MeasurementType>(connection);
TableOperations <MeasurementCharacteristic> measurementCharacteristicTable = new TableOperations <MeasurementCharacteristic>(connection);
TableOperations <Phase> phaseTable = new TableOperations <Phase>(connection);
MeasurementType measurementType = measurementTypeTable.GetOrAdd(measurementTypeName);
MeasurementCharacteristic measurementCharacteristic = measurementCharacteristicTable.GetOrAdd(measurementCharacteristicName);
Phase phase = phaseTable.GetOrAdd(phaseName);
dbChannel = new Channel()
{
MeterID = meter.ID,
LineID = lineID,
MeasurementTypeID = measurementType.ID,
MeasurementCharacteristicID = measurementCharacteristic.ID,
PhaseID = phase.ID,
Name = channelKey.Name,
SamplesPerHour = dataGroup.SamplesPerHour,
Description = string.Concat(measurementCharacteristicName, " ", measurementTypeName, " ", phaseName),
Enabled = true
};
channelTable.AddNewRecord(dbChannel);
dbChannel.ID = connection.ExecuteScalar <int>("SELECT @@IDENTITY");
meter.Channels = null;
}
TableOperations <Series> seriesTable = new TableOperations <Series>(connection);
TableOperations <SeriesType> seriesTypeTable = new TableOperations <SeriesType>(connection);
SeriesType seriesType = seriesTypeTable.GetOrAdd(seriesTypeName);
dbSeries = new Series()
{
ChannelID = dbChannel.ID,
SeriesTypeID = seriesType.ID,
SourceIndexes = string.Empty
};
seriesTable.AddNewRecord(dbSeries);
dbSeries.ID = connection.ExecuteScalar <int>("SELECT @@IDENTITY");
dbChannel.Series = null;
dbSeries = meter.Channels
.SelectMany(channel => channel.Series)
.First(series => seriesKey.Equals(new SeriesKey(series)));
}
}
return(dbSeries);
}
// Static Methods
private static Series GetSeriesInfo(MeterInfoDataContext meterInfo, Meter meter, DataGroup dataGroup, string measurementTypeName, string phaseName)
{
int lineID;
string measurementCharacteristicName;
string seriesTypeName;
char typeDesignation;
char phaseDesignation;
string channelName;
DataContextLookup <ChannelKey, Channel> channelLookup;
DataContextLookup <SeriesKey, Series> seriesLookup;
DataContextLookup <string, MeasurementType> measurementTypeLookup;
DataContextLookup <string, MeasurementCharacteristic> measurementCharacteristicLookup;
DataContextLookup <string, Phase> phaseLookup;
DataContextLookup <string, SeriesType> seriesTypeLookup;
ChannelKey channelKey;
SeriesKey seriesKey;
lineID = dataGroup.Line.ID;
measurementCharacteristicName = "Instantaneous";
seriesTypeName = "Values";
typeDesignation = (measurementTypeName == "Current") ? 'I' : measurementTypeName[0];
phaseDesignation = (phaseName == "RES") ? 'R' : phaseName[0];
channelName = string.Concat(typeDesignation, phaseDesignation);
channelLookup = new DataContextLookup <ChannelKey, Channel>(meterInfo, channel => new ChannelKey(channel))
.WithFilterExpression(channel => channel.MeterID == meter.ID)
.WithFilterExpression(channel => channel.LineID == dataGroup.Line.ID)
.WithFilterExpression(channel => channel.MeasurementType.Name == measurementTypeName)
.WithFilterExpression(channel => channel.MeasurementCharacteristic.Name == measurementCharacteristicName)
.WithFilterExpression(channel => channel.Phase.Name == phaseName);
seriesLookup = new DataContextLookup <SeriesKey, Series>(meterInfo, series => new SeriesKey(series))
.WithFilterExpression(series => series.Channel.Meter.ID == meter.ID)
.WithFilterExpression(series => series.Channel.Line.ID == dataGroup.Line.ID)
.WithFilterExpression(series => series.Channel.MeasurementType.Name == measurementTypeName)
.WithFilterExpression(series => series.Channel.MeasurementCharacteristic.Name == measurementCharacteristicName)
.WithFilterExpression(series => series.Channel.Phase.Name == phaseName)
.WithFilterExpression(series => series.SeriesType.Name == seriesTypeName);
measurementTypeLookup = new DataContextLookup <string, MeasurementType>(meterInfo, measurementType => measurementType.Name);
measurementCharacteristicLookup = new DataContextLookup <string, MeasurementCharacteristic>(meterInfo, measurementCharacteristic => measurementCharacteristic.Name);
phaseLookup = new DataContextLookup <string, Phase>(meterInfo, phase => phase.Name);
seriesTypeLookup = new DataContextLookup <string, SeriesType>(meterInfo, seriesType => seriesType.Name);
channelKey = new ChannelKey(lineID, 0, channelName, measurementTypeName, measurementCharacteristicName, phaseName);
seriesKey = new SeriesKey(channelKey, seriesTypeName);
return(seriesLookup.GetOrAdd(seriesKey, key =>
{
SeriesType seriesType = seriesTypeLookup.GetOrAdd(key.SeriesType, name => new SeriesType()
{
Name = name, Description = name
});
Channel channel = channelLookup.GetOrAdd(channelKey, chKey =>
{
MeasurementType measurementType = measurementTypeLookup.GetOrAdd(chKey.MeasurementType, name => new MeasurementType()
{
Name = name, Description = name
});
MeasurementCharacteristic measurementCharacteristic = measurementCharacteristicLookup.GetOrAdd(chKey.MeasurementCharacteristic, name => new MeasurementCharacteristic()
{
Name = name, Description = name
});
Phase phase = phaseLookup.GetOrAdd(chKey.Phase, name => new Phase()
{
Name = name, Description = name
});
return new Channel()
{
Meter = meter,
Line = dataGroup.Line,
MeasurementType = measurementType,
MeasurementCharacteristic = measurementCharacteristic,
Phase = phase,
Name = chKey.Name,
SamplesPerHour = dataGroup.SamplesPerHour,
PerUnitValue = 0,
HarmonicGroup = 0,
Description = string.Concat(measurementCharacteristic.Name, " ", measurementType.Name, " ", phase.Name),
Enabled = 1
};
});
return new Series()
{
SeriesType = seriesType,
Channel = channel,
SourceIndexes = string.Empty
};
}));
}
private void AddUndefinedChannels(MeterDataSet meterDataSet)
{
List <DataSeries> undefinedDataSeries = meterDataSet.DataSeries
.Concat(meterDataSet.Digitals)
.Where(dataSeries => (object)dataSeries.SeriesInfo.Channel.Line == null)
.ToList();
if (undefinedDataSeries.Count <= 0)
{
return;
}
Meter meter = meterDataSet.Meter;
if (meter.MeterLines.Count == 0)
{
Log.Warn($"Unable to automatically add channels to meter {meterDataSet.Meter.Name} because there are no lines associated with that meter.");
return;
}
if (meter.MeterLines.Count > 1)
{
Log.Warn($"Unable to automatically add channels to meter {meterDataSet.Meter.Name} because there are too many lines associated with that meter.");
return;
}
Line line = meter.MeterLines
.Select(meterLine => meterLine.Line)
.Single();
foreach (DataSeries series in undefinedDataSeries)
{
series.SeriesInfo.Channel.LineID = line.ID;
}
using (AdoDataConnection connection = meterDataSet.CreateDbConnection())
{
TableOperations <MeasurementType> measurementTypeTable = new TableOperations <MeasurementType>(connection);
TableOperations <MeasurementCharacteristic> measurementCharacteristicTable = new TableOperations <MeasurementCharacteristic>(connection);
TableOperations <Phase> phaseTable = new TableOperations <Phase>(connection);
TableOperations <SeriesType> seriesTypeTable = new TableOperations <SeriesType>(connection);
Dictionary <string, MeasurementType> measurementTypeLookup = undefinedDataSeries
.Select(dataSeries => dataSeries.SeriesInfo.Channel.MeasurementType)
.DistinctBy(measurementType => measurementType.Name)
.Select(measurementType => measurementTypeTable.GetOrAdd(measurementType.Name, measurementType.Description))
.ToDictionary(measurementType => measurementType.Name);
Dictionary <string, MeasurementCharacteristic> measurementCharacteristicLookup = undefinedDataSeries
.Select(dataSeries => dataSeries.SeriesInfo.Channel.MeasurementCharacteristic)
.DistinctBy(measurementCharacteristic => measurementCharacteristic.Name)
.Select(measurementCharacteristic => measurementCharacteristicTable.GetOrAdd(measurementCharacteristic.Name, measurementCharacteristic.Description))
.ToDictionary(measurementCharacteristic => measurementCharacteristic.Name);
Dictionary <string, Phase> phaseLookup = undefinedDataSeries
.Select(dataSeries => dataSeries.SeriesInfo.Channel.Phase)
.DistinctBy(phase => phase.Name)
.Select(phase => phaseTable.GetOrAdd(phase.Name, phase.Description))
.ToDictionary(phase => phase.Name);
Dictionary <string, SeriesType> seriesTypeLookup = undefinedDataSeries
.Select(dataSeries => dataSeries.SeriesInfo.SeriesType)
.DistinctBy(seriesType => seriesType.Name)
.Select(seriesType => seriesTypeTable.GetOrAdd(seriesType.Name, seriesType.Description))
.ToDictionary(seriesType => seriesType.Name);
Dictionary <ChannelKey, Channel> channelLookup = meter.Channels
.GroupBy(channel => new ChannelKey(channel))
.ToDictionary(grouping =>
{
if (grouping.Count() > 1)
{
Log.Warn($"Detected duplicate channel key: {grouping.First().ID}");
}
return(grouping.Key);
}, grouping => grouping.First());
List <Channel> undefinedChannels = undefinedDataSeries
.Select(dataSeries => dataSeries.SeriesInfo.Channel)
.GroupBy(channel => new ChannelKey(channel))
.Where(grouping => !channelLookup.ContainsKey(grouping.Key))
.Select(grouping => grouping.First())
.ToList();
TableOperations <Channel> channelTable = new TableOperations <Channel>(connection);
// Add all undefined channels to the database
foreach (Channel channel in undefinedChannels)
{
string measurementTypeName = channel.MeasurementType.Name;
string measurementCharacteristicName = channel.MeasurementCharacteristic.Name;
string phaseName = channel.Phase.Name;
channel.MeterID = meter.ID;
channel.LineID = line.ID;
channel.MeasurementTypeID = measurementTypeLookup[measurementTypeName].ID;
channel.MeasurementCharacteristicID = measurementCharacteristicLookup[measurementCharacteristicName].ID;
channel.PhaseID = phaseLookup[phaseName].ID;
channel.Enabled = true;
// If the per-unit value was not specified in the input file,
// we can obtain the per-unit value from the line configuration
// if the channel happens to be an instantaneous or RMS voltage
if (!channel.PerUnitValue.HasValue)
{
if (IsVoltage(channel))
{
if (IsLineToNeutral(channel))
{
channel.PerUnitValue = (line.VoltageKV * 1000.0D) / Sqrt3;
}
else if (IsLineToLine(channel))
{
channel.PerUnitValue = line.VoltageKV * 1000.0D;
}
}
}
channelTable.AddNewRecord(channel);
}
if (undefinedChannels.Count > 0)
{
// Refresh the channel lookup to
// include all the new channels
meter.Channels = null;
channelLookup = meter.Channels
.GroupBy(channel => new ChannelKey(channel))
.ToDictionary(grouping => grouping.Key, grouping => grouping.First());
}
Dictionary <SeriesKey, Series> seriesLookup = meter.Channels
.SelectMany(channel => channel.Series)
.Where(series => series.SourceIndexes == "")
.GroupBy(series => new SeriesKey(series))
.ToDictionary(grouping =>
{
if (grouping.Count() > 1)
{
Log.Warn($"Detected duplicate series key: {grouping.First().ID}");
}
return(grouping.Key);
}, grouping => grouping.First());
List <Series> undefinedSeries = undefinedDataSeries
.SelectMany(dataSeries => dataSeries.SeriesInfo.Channel.Series)
.GroupBy(series => new SeriesKey(series))
.Where(grouping => !seriesLookup.ContainsKey(grouping.Key))
.Select(grouping => grouping.First())
.ToList();
TableOperations <Series> seriesTable = new TableOperations <Series>(connection);
// Add all undefined series objects to the database
foreach (Series series in undefinedSeries)
{
ChannelKey channelKey = new ChannelKey(series.Channel);
string seriesTypeName = series.SeriesType.Name;
series.ChannelID = channelLookup[channelKey].ID;
series.SeriesTypeID = seriesTypeLookup[seriesTypeName].ID;
series.SourceIndexes = "";
seriesTable.AddNewRecord(series);
}
if (undefinedSeries.Count > 0)
{
// Refresh the series lookup to
// include all the new series
foreach (Channel channel in meter.Channels)
{
channel.Series = null;
}
seriesLookup = meter.Channels
.SelectMany(channel => channel.Series)
.GroupBy(series => new SeriesKey(series))
.ToDictionary(grouping => grouping.Key, grouping => grouping.First());
}
// Update all undefined data series to reference the new database objects
foreach (DataSeries dataSeries in undefinedDataSeries)
{
SeriesKey seriesKey = new SeriesKey(dataSeries.SeriesInfo);
Series series = seriesLookup[seriesKey];
dataSeries.SeriesInfo = series;
}
}
}
private Series GetSeriesInfo(Meter meter, ChannelKey channelKey, SeriesKey seriesKey)
{
Series dbSeries = meter.Channels
.SelectMany(channel => channel.Series)
.FirstOrDefault(series => seriesKey.Equals(new SeriesKey(series)));
if ((object)dbSeries == null)
{
using (AdoDataConnection connection = meter.ConnectionFactory())
{
Channel dbChannel = meter.Channels
.FirstOrDefault(channel => channelKey.Equals(new ChannelKey(channel)));
if ((object)dbChannel == null)
{
TableOperations <Channel> channelTable = new TableOperations <Channel>(connection);
TableOperations <MeasurementType> measurementTypeTable = new TableOperations <MeasurementType>(connection);
TableOperations <MeasurementCharacteristic> measurementCharacteristicTable = new TableOperations <MeasurementCharacteristic>(connection);
TableOperations <Phase> phaseTable = new TableOperations <Phase>(connection);
MeasurementType measurementType = measurementTypeTable.GetOrAdd(channelKey.MeasurementType);
MeasurementCharacteristic measurementCharacteristic = measurementCharacteristicTable.GetOrAdd(channelKey.MeasurementCharacteristic);
Phase phase = phaseTable.GetOrAdd(channelKey.Phase);
dbChannel = new Channel()
{
MeterID = meter.ID,
LineID = channelKey.LineID,
MeasurementTypeID = measurementType.ID,
MeasurementCharacteristicID = measurementCharacteristic.ID,
PhaseID = phase.ID,
Name = channelKey.Name,
SamplesPerHour = 0,
Description = string.Concat(channelKey.MeasurementCharacteristic, " ", channelKey.MeasurementType, " ", channelKey.Phase),
Enabled = true
};
channelTable.AddNewRecord(dbChannel);
dbChannel.ID = connection.ExecuteScalar <int>("SELECT @@IDENTITY");
meter.Channels = null;
}
TableOperations <Series> seriesTable = new TableOperations <Series>(connection);
TableOperations <SeriesType> seriesTypeTable = new TableOperations <SeriesType>(connection);
SeriesType seriesType = seriesTypeTable.GetOrAdd(seriesKey.SeriesType);
dbSeries = new Series()
{
ChannelID = dbChannel.ID,
SeriesTypeID = seriesType.ID,
SourceIndexes = string.Empty
};
seriesTable.AddNewRecord(dbSeries);
dbSeries.ID = connection.ExecuteScalar <int>("SELECT @@IDENTITY");
dbChannel.Series = null;
dbSeries = meter.Channels
.SelectMany(channel => channel.Series)
.First(series => seriesKey.Equals(new SeriesKey(series)));
}
}
return(dbSeries);
}
