Lucio Maranta
313 lines
12 KiB
C#
313 lines
12 KiB
C#
using Step.Model.ConfigModels;
|
|
using Step.Utils;
|
|
using System;
|
|
using System.Globalization;
|
|
using System.Linq;
|
|
using System.Xml.Linq;
|
|
using System.Xml.Schema;
|
|
using static Step.Config.ServerConfig;
|
|
using static Step.Model.Constants;
|
|
using static Step.Utils.SupportFunctions;
|
|
|
|
namespace Step.Config
|
|
{
|
|
public static class ServerConfigController
|
|
{
|
|
public static void ReadStartupConfig()
|
|
{
|
|
try
|
|
{
|
|
ReadServerConfig();
|
|
ReadAreaConfig();
|
|
ReadMaintenancesConfig();
|
|
ReadNcSoftKeys();
|
|
ReadUserSoftKeysConfig();
|
|
ReadAlarmsConfig();
|
|
ReadHeadsConfig();
|
|
}
|
|
catch (System.Xml.XmlException ex)
|
|
{
|
|
ExceptionManager.Manage(ERROR_LEVEL.FATAL,
|
|
"Error while reading file: " + ex.SourceUri +
|
|
"\n Error: " + ex.Message
|
|
);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
ExceptionManager.Manage(ERROR_LEVEL.FATAL, ex.Message);
|
|
}
|
|
}
|
|
|
|
private static XDocument GetXmlHandlerWithValidator(string configSchemaFilePath, string configFilePath)
|
|
{
|
|
// Create new instance
|
|
XmlSchemaSet readerSettings = new XmlSchemaSet();
|
|
// Add Schema
|
|
readerSettings.Add(null, BASE_PATH + "\\" + configSchemaFilePath);
|
|
|
|
// Open file reader
|
|
XDocument xmlConfigFile = XDocument.Load(BASE_PATH + "\\" + configFilePath);
|
|
// Validate file
|
|
xmlConfigFile.Validate(readerSettings, ValidationHandler);
|
|
|
|
return xmlConfigFile;
|
|
}
|
|
|
|
private static void SetAreaValueByName(XElement element)
|
|
{
|
|
// Choose which area to be set
|
|
switch (element.Name.ToString())
|
|
{
|
|
case AREAS.PRODUCTION_KEY:
|
|
SetAreaValue(ref ProductionConfig, element);
|
|
break;
|
|
|
|
case AREAS.TOOLING_KEY:
|
|
SetAreaValue(ref ToolingConfig, element);
|
|
break;
|
|
|
|
case AREAS.REPORT_KEY:
|
|
SetAreaValue(ref ReportConfig, element);
|
|
break;
|
|
|
|
case AREAS.ALARMS_KEY:
|
|
SetAreaValue(ref AlarmsConfig, element);
|
|
break;
|
|
|
|
case AREAS.MAINTENANCE_KEY:
|
|
SetAreaValue(ref MaintenanceConfig, element);
|
|
break;
|
|
|
|
case AREAS.UTILITIES_KEY:
|
|
SetAreaValue(ref UtilitiesConfig, element);
|
|
break;
|
|
|
|
case AREAS.SCADA_KEY:
|
|
SetAreaValue(ref ScadaConfig, element);
|
|
break;
|
|
}
|
|
}
|
|
|
|
private static void SetAreaValue(ref AreasConfigModel areasConfig, XElement element)
|
|
{
|
|
// Set area model with xml data
|
|
areasConfig = new AreasConfigModel()
|
|
{
|
|
Name = element.Name.ToString(),
|
|
Enabled = Convert.ToBoolean(element.Element("enabled").Value),
|
|
AllowExternalBrowser = Convert.ToBoolean(element.Element("allowExternalBrowser").Value),
|
|
NcNeeded = Convert.ToBoolean(element.Element("ncNeeded").Value)
|
|
};
|
|
}
|
|
|
|
private static void ValidationHandler(object sender, ValidationEventArgs e)
|
|
{
|
|
if (e.Severity == XmlSeverityType.Warning)
|
|
{
|
|
ExceptionManager.Manage(ERROR_LEVEL.WARNING, e.Message);
|
|
}
|
|
else if (e.Severity == XmlSeverityType.Error)
|
|
{
|
|
ExceptionManager.Manage(ERROR_LEVEL.FATAL, e.Message);
|
|
}
|
|
}
|
|
|
|
public static bool CheckAreaStatus(string areaName)
|
|
{ // Get Area status ( enabled field) by name
|
|
switch (areaName)
|
|
{
|
|
case AREAS.PRODUCTION_KEY:
|
|
return ProductionConfig.Enabled;
|
|
|
|
case AREAS.TOOLING_KEY:
|
|
return ToolingConfig.Enabled;
|
|
|
|
case AREAS.REPORT_KEY:
|
|
return ProductionConfig.Enabled;
|
|
|
|
case AREAS.ALARMS_KEY:
|
|
return AlarmsConfig.Enabled;
|
|
|
|
case AREAS.MAINTENANCE_KEY:
|
|
return MaintenanceConfig.Enabled;
|
|
|
|
case AREAS.UTILITIES_KEY:
|
|
return UtilitiesConfig.Enabled;
|
|
|
|
case AREAS.SCADA_KEY:
|
|
return ScadaConfig.Enabled;
|
|
|
|
case AREAS.GENERAL_KEY:
|
|
case AREAS.UNDER_HOOD:
|
|
return true;
|
|
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
#region Read config from file from configuration
|
|
|
|
public static void ReadServerConfig()
|
|
{
|
|
// Get server file handler
|
|
XDocument xmlConfigFile = GetXmlHandlerWithValidator(SERVER_CONFIG_SCHEMA_PATH, SERVER_CONFIG_PATH);
|
|
|
|
// Read nc Config with LINQ
|
|
NcConfig = xmlConfigFile
|
|
.Root
|
|
.Descendants(NC_CONFIG_KEY)
|
|
.Select(x => new NcConfigModel()
|
|
{
|
|
NcVendor = x.Element("ncVendor").Value,
|
|
showNcHMI = Convert.ToBoolean(x.Element("showNcHMI").Value),
|
|
NcIpAddress = x.Element("ncIpAddress").Value,
|
|
NcPort = Convert.ToUInt16(x.Element("ncPort").Value),
|
|
NcName = x.Element("machineModel").Value
|
|
}).FirstOrDefault();
|
|
|
|
// Read server config with LINQ and save into static config
|
|
ServerStartupConfig = xmlConfigFile
|
|
.Root
|
|
.Descendants(SERVER_CONFIG_KEY)
|
|
.Select(x => new ServerConfigModel()
|
|
{ // Set server config model data
|
|
Language = CultureInfo.CreateSpecificCulture(x.Element("language").Value),
|
|
ServerAddress = x.Element("serverAddress").Value,
|
|
ServerPort = Convert.ToInt32(x.Element("serverPort").Value),
|
|
EnableDirectoryBrowsing = Convert.ToBoolean(x.Element("enableDirectoryBrowsing").Value),
|
|
DatabaseAddress = x.Element("databaseAddress").Value
|
|
}).FirstOrDefault();
|
|
}
|
|
|
|
private static void ReadAreaConfig()
|
|
{
|
|
// Get Areas file handler
|
|
XDocument xmlConfigFile = GetXmlHandlerWithValidator(AREAS_CONFIG_SCHEMA_PATH, AREAS_CONFIG_PATH);
|
|
|
|
// Read areas config with LINQ
|
|
xmlConfigFile
|
|
.Root // Get areas config node
|
|
.Elements()
|
|
.ToList()
|
|
.ForEach(x => SetAreaValueByName(x)); // Loop through elements
|
|
}
|
|
|
|
public static void ReadMaintenancesConfig()
|
|
{
|
|
// Get Maintenances file handler
|
|
XDocument xmlConfigFile = GetXmlHandlerWithValidator(MAINTENANCES_CONFIG_SCHEMA_PATH, MAINTENANCES_CONFIG_PATH);
|
|
|
|
MaintenancesConfig = xmlConfigFile
|
|
.Root
|
|
.Elements()
|
|
.ToList()
|
|
.Select(x =>
|
|
new MaintenanceConfigModel()
|
|
{
|
|
Id = Convert.ToInt32(x.Element("id").Value),
|
|
LocalizedName = x.Element("localizedName").Elements().ToDictionary( // Read localized names
|
|
y => y.Attribute("langKey").Value, y => y.Value
|
|
),
|
|
Intervall = TimeSpan.FromMinutes(Convert.ToDouble(x.Element("interval").Value)),
|
|
Deadline = DateTime.Parse(x.Element("deadline").Value),
|
|
Type = x.Element("type").Value,
|
|
CouterId = Convert.ToInt32(x.Element("counterId").Value),
|
|
LocalizedDescription = x.Element("localizedDescription").Elements().ToDictionary( // Read localization of description
|
|
y => y.Attribute("langKey").Value, y => y.Value
|
|
),
|
|
UnitOfMeasure = x.Element("unitOfMeasure").Value
|
|
})
|
|
.ToList();
|
|
}
|
|
|
|
private static void ReadNcSoftKeys()
|
|
{
|
|
XDocument xmlConfigFile = GetXmlHandlerWithValidator(NC_SOFTKEYS_CONFIG_SCHEMA_PATH, NC_SOFTKEYS_CONFIG_PATH);
|
|
// Read Nc softkey configuration from XML
|
|
NcSoftKeysConfig = xmlConfigFile
|
|
.Root
|
|
.Elements()
|
|
.Where(x => Convert.ToBoolean(x.Element("enabled").Value) == true) // Filter for active softkey
|
|
.Select(x => new NcSoftKeysModel()
|
|
{
|
|
Id = GetPlcIdFromNcSoftKey(x.Name.ToString()),
|
|
Name = x.Name.ToString(),
|
|
VisualizedName = x.Element("visualizedName").Value,
|
|
IsActive = Convert.ToBoolean(x.Element("enabled").Value),
|
|
IsReadOnly = Convert.ToBoolean(x.Element("readOnly").Value)
|
|
})
|
|
.ToList();
|
|
}
|
|
|
|
private static void ReadUserSoftKeysConfig()
|
|
{
|
|
// Get softkey file content
|
|
XDocument xmlConfigFile = GetXmlHandlerWithValidator(USER_SOFTKEYS_CONFIG_SCHEMA_PATH, USER_SOFTKEYS_CONFIG_PATH);
|
|
int id = 1;
|
|
// Read softkey configuration from XML with LINQ
|
|
SoftKeysConfig = xmlConfigFile
|
|
.Root
|
|
.Elements()
|
|
.Where(x => Convert.ToBoolean(x.Element("active").Value) == true) // Filter for active softkey
|
|
.Select(x => new UserSoftKeyConfigModel()
|
|
{
|
|
Id = id++, // autoincrement Id
|
|
PlcId = Convert.ToInt32(x.Element("plcId")?.Value), // If exists
|
|
IsActive = Convert.ToBoolean(x.Element("active").Value),
|
|
Category = Convert.ToInt32(x.Element("category").Value),
|
|
LocalizedNames = x.Element("localizedNames").Elements().ToDictionary( // Read localized names and convert into a dictionary
|
|
y => y.Attribute("langKey").Value, y => y.Value
|
|
),
|
|
|
|
SubKeys = x.Element("subKeys")?.Elements().Select(y => new SubKeysModel() // Populate subkeys if exist
|
|
{
|
|
Id = id++,
|
|
PlcId = Convert.ToInt32(y.Attribute("plcId").Value),
|
|
Text = y.Value
|
|
}).ToList(),
|
|
Type = GetSoftKeyType(x.Name.ToString()),
|
|
OperatorConfirmationNeeded = Convert.ToBoolean(x.Element("operatorConfirmationNeeded").Value)
|
|
})
|
|
.ToList();
|
|
}
|
|
|
|
private static void ReadAlarmsConfig()
|
|
{
|
|
XDocument xmlConfigFile = GetXmlHandlerWithValidator(ALARMS_CONFIG_SCHEMA_PATH, ALARMS_CONFIG_PATH);
|
|
// Read alarms config from XML file
|
|
InitialAlarmsConfig = xmlConfigFile
|
|
.Root
|
|
.Elements()
|
|
.Select(x => new AlarmsConfigModel()
|
|
{
|
|
AlarmId = Convert.ToInt32(x.Element("alarmId").Value),
|
|
PlcId = Convert.ToInt32(x.Element("plcId").Value),
|
|
RestoreIsActive = Convert.ToBoolean(x.Element("restoreIsActive").Value)
|
|
})
|
|
.ToList();
|
|
}
|
|
|
|
private static void ReadHeadsConfig()
|
|
{
|
|
XDocument xmlConfigFile = GetXmlHandlerWithValidator(HEADS_CONFIG_SCHEMA_PATH, HEADS_CONFIG_PATH);
|
|
|
|
int i = 1;
|
|
// Read head config from XML file
|
|
HeadsConfig = xmlConfigFile
|
|
.Root
|
|
.Elements()
|
|
.Select(x => new HeadsConfigModel()
|
|
{
|
|
Id = i++, // Autoincrement Id
|
|
Name = x.Element("name").Value,
|
|
Type = GetHeadType(x.Element("type").Value),
|
|
WarningLimit = Convert.ToInt16(x.Element("warningLimit").Value),
|
|
AlarmLimit = Convert.ToInt16(x.Element("alarmLimit").Value),
|
|
})
|
|
.ToList();
|
|
}
|
|
|
|
#endregion Read config from file from configuration
|
|
}
|
|
} |