private List <SetChannelPropertyGrouping> GroupChannelsForMultipleSensorsAndChannels(ChannelParameter[] channelParameters, List <IGrouping <int, Channel> > groupedByChannel)
{
//4c, 4cf, 5cf
var list = new List <SetChannelPropertyGrouping>();
//Multiple channels across multiple sensors. For small numbers of channels it's concievable it would be better to group per-sensor
//however generally we will be cutting across multiple sensors using the same channel ID
foreach (var channelGroup in groupedByChannel)
{
foreach (var task in GetSetChannelPropertyTasks(channelGroup.DistinctBy(c => new { c.Id, c.SensorId }).ToList(), channelParameters))
{
//Let's see whether we'll need any factors
var tempParameters = new SetChannelPropertyParameters(task.Channels.Select(c => c.SensorId).Distinct().ToArray(), channelGroup.Key, task.Parameters);
//5cf
if (NeedFactors(tempParameters, task.Parameters))
{
//4cf
list.AddRange(GetFactorParameters(tempParameters, task.Channels));
}
else
{
//4c
list.Add(new SetChannelPropertyGrouping(tempParameters, task.Channels.ToReadOnly()));
}
}
}
return(list);
}
private bool NeedFactors(SetChannelPropertyParameters parameters, ChannelParameter[] channelParameters)
{
if (parameters.FactorParameters.Count > 0)
{
var factorProperties = parameters.FactorParameters.Select(p => p.Item1).OfType <ChannelProperty>().ToList();
//We are inclined to say we need channels. However, if all of the factor parameters found were explicitly
//specified, and all have a null or empty value, we don't need to include channels
if (factorProperties.All(p =>
{
var parameter = channelParameters.FirstOrDefault(pa => pa.Property == p);
//The parameter was specified and its value was null or empty. Don't need channels for that!
if (parameter != null && string.IsNullOrEmpty(parameter.Value?.ToString()))
{
return(true);
}
//Either the parameter wasn't explicitly specified (meaning it's someones dependent property) or
//its value wasn't null or empty; we'll need to retrieve channels to specify the factor value
return(false);
}))
{
return(false);
}
return(true);
}
return(false);
}
private List <SetChannelPropertyGrouping> GroupChannelsForOneSensorAndChannel(ChannelParameter[] channelParameters, IGrouping <int, Channel> sensorsChannels, IGrouping <int, Channel> channelGroup)
{
//1c, 1cf, 5cf
//At this point, regardless of whether or not all factor properties are null or not (if we even need factors at all) we're going to be executing a single request
var list = new List <SetChannelPropertyGrouping>();
foreach (var task in GetSetChannelPropertyTasks(channelGroup.DistinctBy(c => new { c.Id, c.SensorId }).ToList(), channelParameters))
{
var parameters = new SetChannelPropertyParameters(new[] { sensorsChannels.Key }, channelGroup.Key, task.Parameters);
//5cf. If we don't need factors, we're equal to 1c
if (NeedFactors(parameters, task.Parameters))
{
//Apply the factors to the parameters
//We could have the same sensor twice with multiple factors; only accept the first one
var factor = task.Channels.GroupBy(c => c.Factor).First();
AddFactorProperties(parameters, parameters, factor);
}
//One channel on one sensor
list.Add(new SetChannelPropertyGrouping(parameters, sensorsChannels.ToReadOnly()));
}
return(list);
}
private List <SetChannelPropertyGrouping> GroupChannelsForMultipleSensorsAndOneChannel(ChannelParameter[] channelParameters, IGrouping <int, Channel> channelGroup)
{
//3c, 3cf, 5cf
var list = new List <SetChannelPropertyGrouping>();
foreach (var task in GetSetChannelPropertyTasks(channelGroup.DistinctBy(c => new { c.Id, c.SensorId }).ToList(), channelParameters))
{
var sensorIds = task.Channels.Select(c => c.SensorId).ToArray();
var tempParameters = new SetChannelPropertyParameters(sensorIds, channelGroup.Key, task.Parameters);
//5cf
if (NeedFactors(tempParameters, task.Parameters))
{
//3cf
list.AddRange(GetFactorParameters(tempParameters, task.Channels));
}
else
{
//3c
list.Add(new SetChannelPropertyGrouping(tempParameters, task.Channels));
}
}
return(list);
}
internal async Task SetChannelPropertyAsync(int[] sensorIds, int channelId, ChannelParameter[] @params, CancellationToken token)
{
var parameters = new SetChannelPropertyParameters(sensorIds, channelId, @params);
if (NeedChannels(parameters, @params))
{
var channels = await GetChannelsAsync(null, sensorIds, channelId, token).ConfigureAwait(false);
await SetChannelPropertyAsync(channels, @params, token).ConfigureAwait(false);
}
else
{
await client.SetObjectPropertyAsync(parameters, parameters.SensorIds.Length, token).ConfigureAwait(false);
}
}
//######################################
// SetChannelProperty
//######################################
internal void SetChannelProperty(int[] sensorIds, int channelId, ChannelParameter[] @params, CancellationToken token)
{
var parameters = new SetChannelPropertyParameters(sensorIds, channelId, @params);
if (NeedChannels(parameters, @params))
{
var channels = GetChannels(null, sensorIds, channelId, token);
SetChannelProperty(channels, @params, token);
}
else
{
client.SetObjectProperty(parameters, parameters.SensorIds.Length, token);
}
}
public void IShallowCloneable_SetChannelPropertyParameters_CloneFully()
{
var ids = new[] { 1001, 1002, 1003 };
var @params = new[]
{
new ChannelParameter(ChannelProperty.UpperErrorLimit, 100),
new ChannelParameter(ChannelProperty.SpikeFilterEnabled, true)
};
var parameters = new SetChannelPropertyParameters(ids, 1, @params)
{
Cookie = true
};
Clone(parameters);
}
protected IEnumerable <SetChannelPropertyGrouping> GetFactorParameters(SetChannelPropertyParameters tempParameters, IEnumerable <Channel> channels)
{
//Get the factors for all channels with the given ID
var factors = channels.Select(g => g).DistinctBy(c => new { c.Id, c.SensorId }).GroupBy(c => c.Factor);
foreach (var factor in factors)
{
//4cf
var factorParameters = tempParameters.ShallowClone();
factorParameters.SensorIds = factor.Select(c => c.SensorId).ToArray();
AddFactorProperties(tempParameters, factorParameters, factor);
yield return(new SetChannelPropertyGrouping(factorParameters, factor.ToReadOnly()));
}
}
private List <SetChannelPropertyGrouping> GroupChannelsForOneSensorAndMultipleChannels(ChannelParameter[] channelParameters, IGrouping <int, Channel> sensorsChannels, List <IGrouping <int, Channel> > groupedByChannel)
{
//2c, 2cf, 5cf
//One sensor, multiple channels
SetChannelPropertyParameters masterParameters = null;
foreach (var channelGroup in groupedByChannel)
{
foreach (var task in GetSetChannelPropertyTasks(channelGroup.DistinctBy(c => new { c.Id, c.SensorId }).ToList(), channelParameters))
{
var localParameters = new SetChannelPropertyParameters(new[] { sensorsChannels.Key }, channelGroup.Key, task.Parameters);
//5cf
if (NeedFactors(localParameters, task.Parameters))
{
var factors = task.Channels.GroupBy(c => c.Factor);
foreach (var factor in factors)
{
AddFactorProperties(localParameters, localParameters, factor);
}
}
if (masterParameters == null)
{
masterParameters = localParameters;
}
else
{
masterParameters.CustomParameters.AddRange(localParameters.CustomParameters);
}
}
}
masterParameters.RemoveDuplicateParameters();
return(new List <SetChannelPropertyGrouping>
{
new SetChannelPropertyGrouping(masterParameters, groupedByChannel.SelectMany(c => c).ToReadOnly())
});
}
private void AddFactorProperties(SetChannelPropertyParameters outerParameters, SetChannelPropertyParameters innerParameters, IGrouping <double?, Channel> factor)
{
if (factor.Key == null)
{
return;
}
//For each ChannelProperty that has a factor
foreach (var obj in outerParameters.FactorParameters)
{
var prop = obj.Item2.Property;
//Get the factor property that also needs to be included (e.g. UpperErrorLimitFactor)
var cache = outerParameters.GetPropertyCache(prop);
Debug.Assert(factor.All(g => (double?)cache.Property.GetValue(g) == factor.Key), "Generic and specific Factor were not equal for at least one channel");
//Generate the factor's property name
var name = outerParameters.GetFactorParameterName(prop, cache);
//And add it
innerParameters.CustomParameters.Add(new CustomParameter(name, factor.Key));
}
}
protected virtual bool NeedChannels(SetChannelPropertyParameters parameters, ChannelParameter[] channelParameters)
{
return(NeedFactors(parameters, channelParameters));
}
public SetChannelPropertyGrouping(SetChannelPropertyParameters parameters, ReadOnlyCollection <Channel> channels)
{
Parameters = parameters;
Channels = channels;
}
protected override bool NeedChannels(SetChannelPropertyParameters parameters, ChannelParameter[] channelParameters)
{
return(base.NeedChannels(parameters, channelParameters) || NeedsLimit(channelParameters));
}
