public void InitializeDiscretePointItem(DiscretePointItem pointItem, List <Property> props, ModelCode type, EnumDescs enumDescs)
{
InitializeScadaModelPointItem(pointItem as ScadaModelPointItem, props, type, enumDescs);
foreach (var item in props)
{
switch (item.Id)
{
case ModelCode.DISCRETE_CURRENTOPEN:
pointItem.CurrentValue = (ushort)((item.AsBool() == true) ? 1 : 0);
break;
case ModelCode.DISCRETE_MAXVALUE:
pointItem.MaxValue = (ushort)item.AsInt();
break;
case ModelCode.DISCRETE_MINVALUE:
pointItem.MinValue = (ushort)item.AsInt();
break;
case ModelCode.DISCRETE_NORMALVALUE:
pointItem.NormalValue = (ushort)item.AsInt();
break;
case ModelCode.DISCRETE_MEASUREMENTTYPE:
pointItem.DiscreteType = (DiscreteMeasurementType)(enumDescs.GetEnumValueFromString(ModelCode.ANALOG_SIGNALTYPE, item.AsEnum().ToString()));
break;
default:
break;
}
}
pointItem.Initialized = true;
}
private IScadaModelPointItem CreatePointItemFromResource(ResourceDescription resource)
{
long gid = resource.Id;
ModelCode type = modelResourceDesc.GetModelCodeFromId(gid);
IScadaModelPointItem pointItem;
if (type == ModelCode.ANALOG)
{
pointItem = new AnalogPointItem(AlarmConfigDataHelper.GetAlarmConfigData());
pointItemHelper.InitializeAnalogPointItem(pointItem as AnalogPointItem, resource.Properties, type, enumDescs);
}
else if (type == ModelCode.DISCRETE)
{
pointItem = new DiscretePointItem(AlarmConfigDataHelper.GetAlarmConfigData());
pointItemHelper.InitializeDiscretePointItem(pointItem as DiscretePointItem, resource.Properties, type, enumDescs);
}
else
{
string errMessage = $"{baseLogString} CreatePointItemFromResource => ResourceDescription type is neither analog nor digital. Type: {type}.";
Logger.LogWarning(errMessage);
pointItem = null;
}
return(pointItem);
}
private async Task <bool> ImportDiscrete()
{
bool success;
int numberOfResources = 1000;
List <ModelCode> props = modelResourceDesc.GetAllPropertyIds(ModelCode.DISCRETE);
try
{
var nmsGdaClient = NetworkModelGdaClient.CreateClient();
int iteratorId = await nmsGdaClient.GetExtentValues(ModelCode.DISCRETE, props);
int resourcesLeft = await nmsGdaClient.IteratorResourcesLeft(iteratorId);
while (resourcesLeft > 0)
{
List <ResourceDescription> rds = await nmsGdaClient.IteratorNext(numberOfResources, iteratorId);
for (int i = 0; i < rds.Count; i++)
{
if (rds[i] == null)
{
continue;
}
long gid = rds[i].Id;
ModelCode type = modelResourceDesc.GetModelCodeFromId(gid);
DiscretePointItem discretePoint = new DiscretePointItem(AlarmConfigDataHelper.GetAlarmConfigData());
string debugMessage = $"{baseLogString} ImportDiscrete => Before Initialization => Gid: 0x{discretePoint.Gid:X16}, Address: {discretePoint.Address}, CurrentValue: {discretePoint.CurrentValue}, Alarm: {discretePoint.Alarm}, AbnormalValue: {discretePoint.AbnormalValue}, DiscreteType: {discretePoint.DiscreteType}, MinValue: {discretePoint.MinValue}, MaxValue: {discretePoint.MaxValue}, NormalValue: {discretePoint.NormalValue}, RegisterType: {discretePoint.RegisterType}, Name: {discretePoint.Name}, Initialized: {discretePoint.Initialized}";
Logger.LogDebug(debugMessage);
pointItemHelper.InitializeDiscretePointItem(discretePoint, rds[i].Properties, ModelCode.DISCRETE, enumDescs);
debugMessage = $"{baseLogString} ImportDiscrete => After Initialization => Gid: 0x{discretePoint.Gid:X16}, Address: {discretePoint.Address}, CurrentValue: {discretePoint.CurrentValue}, Alarm: {discretePoint.Alarm}, AbnormalValue: {discretePoint.AbnormalValue}, DiscreteType: {discretePoint.DiscreteType}, MinValue: {discretePoint.MinValue}, MaxValue: {discretePoint.MaxValue}, NormalValue: {discretePoint.NormalValue}, RegisterType: {discretePoint.RegisterType}, Name: {discretePoint.Name}, Initialized: {discretePoint.Initialized}";
Logger.LogDebug(debugMessage);
if (await GidToPointItemMap.ContainsKeyAsync(gid))
{
string errorMessage = $"{baseLogString} ImportDiscrete => SCADA model is invalid => Gid: 0x{gid:X16} belongs to more than one entity.";
Logger.LogError(errorMessage);
throw new InternalSCADAServiceException(errorMessage);
}
await GidToPointItemMap.SetAsync(gid, discretePoint);
#if DEBUG
var pointItemResult = await GidToPointItemMap.TryGetValueAsync(gid);
if (pointItemResult.HasValue)
{
DiscretePointItem controlPointItem = pointItemResult.Value as DiscretePointItem;
debugMessage = $"{baseLogString} ImportDiscrete => Control after CurrentGidToPointItemMap.SetAsync => Gid: 0x{controlPointItem.Gid:X16}, Address: {controlPointItem.Address}, CurrentValue: {controlPointItem.CurrentValue}, Alarm: {controlPointItem.Alarm}, AbnormalValue: {controlPointItem.AbnormalValue}, DiscreteType: {controlPointItem.DiscreteType}, MinValue: {controlPointItem.MinValue}, MaxValue: {controlPointItem.MaxValue}, NormalValue: {controlPointItem.NormalValue}, RegisterType: {controlPointItem.RegisterType}, Name: {controlPointItem.Name}, Initialized: {controlPointItem.Initialized}";
Logger.LogDebug(debugMessage);
}
else
{
string warningMessage = $"{baseLogString} ImportDiscrete => Control after CurrentGidToPointItemMap.SetAsync => Gid: 0x{gid:X16} was not found in reliable collection '{ReliableDictionaryNames.GidToPointItemMap}' after the value was supposedly set.";
Logger.LogWarning(warningMessage);
}
#endif
short registerType = (short)discretePoint.RegisterType;
if (!(await AddressToGidMap.ContainsKeyAsync(registerType)))
{
await AddressToGidMap.SetAsync(registerType, new Dictionary <ushort, long>());
}
var addressToGidDictionaryResult = await AddressToGidMap.TryGetValueAsync(registerType);
if (!addressToGidDictionaryResult.HasValue)
{
string message = $"{baseLogString} ImportDiscrete => reliable collection '{ReliableDictionaryNames.AddressToGidMap}' is not initialized properly.";
Logger.LogError(message);
throw new InternalSCADAServiceException(message);
}
var addressToGidDictionary = addressToGidDictionaryResult.Value;
if (addressToGidDictionary.ContainsKey(discretePoint.Address))
{
string errorMessage = $"{baseLogString} ImportDiscrete => SCADA model is invalid => Address: {discretePoint.Address} (RegType: {registerType}) belongs to more than one entity.";
Logger.LogError(errorMessage);
throw new InternalSCADAServiceException(errorMessage);
}
addressToGidDictionary.Add(discretePoint.Address, rds[i].Id);
await AddressToGidMap.SetAsync(registerType, addressToGidDictionary);
debugMessage = $"{baseLogString} ImportDiscrete => ANALOG measurement added to SCADA model [Gid: 0x{gid:X16}, Address: {discretePoint.Address}]";
Logger.LogDebug(debugMessage);
}
resourcesLeft = await nmsGdaClient.IteratorResourcesLeft(iteratorId);
}
await nmsGdaClient.IteratorClose(iteratorId);
success = true;
}
catch (Exception ex)
{
success = false;
string errorMessage = $"{baseLogString} ImportDiscrete => failed with error: {ex.Message}";
Console.WriteLine(errorMessage);
Logger.LogError(errorMessage, ex);
}
return(success);
}