Thermo_SIM
1120 lines
47 KiB
C#
1120 lines
47 KiB
C#
using Newtonsoft.Json;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Globalization;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Reflection;
|
|
using System.Runtime.InteropServices;
|
|
using System.Security.Cryptography;
|
|
using System.Xml;
|
|
using System.Xml.Linq;
|
|
using System.Xml.Schema;
|
|
using System.Xml.Serialization;
|
|
using Thermo.Active.Model.ConfigModels;
|
|
using Thermo.Active.Model.DTOModels.Scada;
|
|
using Thermo.Active.Model.DTOModels.ThWarmers;
|
|
using Thermo.Active.Utils;
|
|
using static Thermo.Active.Config.ServerConfig;
|
|
using static Thermo.Active.Model.Constants;
|
|
using static Thermo.Active.Utils.SupportFunctions;
|
|
|
|
namespace Thermo.Active.Config
|
|
{
|
|
public static class ServerConfigController
|
|
{
|
|
#region Private Fields
|
|
|
|
private static string actualFileName;
|
|
|
|
#endregion Private Fields
|
|
|
|
#region Private Methods
|
|
|
|
private static void ElaborateDataModel(XElement el, string Parent, ref Dictionary<string, string> Paths)
|
|
{
|
|
List<XElement> intEl = el.Elements().ToList();
|
|
foreach (XElement elem in intEl)
|
|
{
|
|
if (elem.Name.LocalName == "Component")
|
|
ElaborateDataModel(elem, Parent + ":" + elem.Attribute("Name").Value, ref Paths);
|
|
else if (elem.Name.LocalName == "Property")
|
|
Paths.Add(Parent + ":" + elem.Attribute("SymbolicName").Value, elem.Attribute("Value").Value);
|
|
else
|
|
{
|
|
if (elem.Attribute("SymbolicName") != null && elem.Attribute("SymbolicName").Value == "Condition")
|
|
Paths.Add(Parent + ":" + elem.Attribute("SymbolicName").Value, "");
|
|
else
|
|
Paths.Add(Parent + ":" + elem.Attribute("SymbolicName").Value, "UNAVAILABLE");
|
|
}
|
|
}
|
|
}
|
|
|
|
private static XDocument GetXmlHandler(string configFilePath, bool isFullPath = false)
|
|
{
|
|
// Open file reader
|
|
XDocument xmlConfigFile = XDocument.Load((!isFullPath ? BASE_PATH + "\\" : "") + configFilePath);
|
|
|
|
return xmlConfigFile;
|
|
}
|
|
|
|
private static XDocument GetXmlHandlerWithValidator(string configSchemaFilePath, string configFilePath, bool isFullPath = false)
|
|
{
|
|
// Create new instance
|
|
XmlSchemaSet readerSettings = new XmlSchemaSet();
|
|
|
|
// Add Schema from Assembly
|
|
Assembly myAssembly = Assembly.GetExecutingAssembly();
|
|
using (Stream schemaStream = myAssembly.GetManifestResourceStream(configSchemaFilePath))
|
|
{
|
|
using (XmlReader schemaReader = XmlReader.Create(schemaStream))
|
|
{
|
|
readerSettings.Add(null, schemaReader);
|
|
}
|
|
}
|
|
|
|
actualFileName = configFilePath;
|
|
|
|
// Open file reader
|
|
XDocument xmlConfigFile = XDocument.Load((!isFullPath ? BASE_PATH + "\\" : "") + configFilePath);
|
|
// Validate file
|
|
xmlConfigFile.Validate(readerSettings, ValidationHandler);
|
|
|
|
return xmlConfigFile;
|
|
}
|
|
|
|
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 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
|
|
}
|
|
|
|
/// <summary>
|
|
/// Axes config setup from file
|
|
/// </summary>
|
|
private static void ReadAxesConfig()
|
|
{
|
|
XDocument xmlConfigFile = GetXmlHandlerWithValidator(AXES_CONFIG_SCHEMA_PATH, AXES_CONFIG_PATH);
|
|
|
|
// Read head config from XML file
|
|
AxesConfig = xmlConfigFile
|
|
.Root
|
|
.Elements()
|
|
.Select(x => new AxesConfigModel()
|
|
{
|
|
Id = Convert.ToInt16(x.Attribute("id").Value),
|
|
Name = x.Attribute("name").Value,
|
|
MasterId = Convert.ToInt16(x.Attribute("master").Value),
|
|
EnabledWord = Convert.ToInt16(x.Attribute("enabledWord").Value),
|
|
Type = GetTActAxes_Type(x.Attribute("type").Value),
|
|
IsVisible = Convert.ToBoolean(x.Attribute("enabled").Value)
|
|
})
|
|
.ToList();
|
|
}
|
|
|
|
private static void ReadCMSConnectConfig()
|
|
{
|
|
String _tempUSR, _tempPSW;
|
|
XDocument xmlConfigFile = GetXmlHandlerWithValidator(CMS_CONNECT_CONFIG_SCHEMA_PATH, CMS_CONNECT_CONFIG_PATH);
|
|
|
|
XElement l = xmlConfigFile
|
|
.Root
|
|
.Descendants("cmsConnectConfig")
|
|
.FirstOrDefault();
|
|
|
|
// Read config from XML file
|
|
CmsConnectConfig = xmlConfigFile
|
|
.Root
|
|
.Descendants("cmsConnectConfig")
|
|
.Select(x => new CmsConnectConfigModel()
|
|
{
|
|
Enabled = Convert.ToBoolean(x.Element("enabled").Value)
|
|
})
|
|
.FirstOrDefault();
|
|
|
|
// Read config from XML file for Gateway
|
|
GatewayConfigModel tempGatewayConfigModel = xmlConfigFile
|
|
.Root
|
|
.Descendants("gateway")
|
|
.Select(x => new GatewayConfigModel()
|
|
{
|
|
Address = x.Element("address").Value,
|
|
Token = x.Element("token").Value
|
|
})
|
|
.FirstOrDefault();
|
|
|
|
if (DecodeCMSConnectGatewayLogin(tempGatewayConfigModel.Token, out _tempUSR, out _tempPSW))
|
|
{
|
|
tempGatewayConfigModel.Username = _tempUSR;
|
|
tempGatewayConfigModel.Password = _tempPSW;
|
|
}
|
|
else
|
|
throw new Exception("Error while reading \"" + CMS_CONNECT_CONFIG_PATH + "\": Gateway Token not valid");
|
|
|
|
CmsConnectConfig.Gateway = tempGatewayConfigModel;
|
|
}
|
|
|
|
private static void ReadDataModel()
|
|
{
|
|
XDocument xmlConfigFile = GetXmlHandler(CONNECT_DATAMODEL_CONFIG_PATH);
|
|
XElement el = xmlConfigFile.Descendants("Machine").First();
|
|
CMSConnectEntry = new Dictionary<string, string>();
|
|
ElaborateDataModel(el, el.Name.LocalName, ref CMSConnectEntry);
|
|
CMSConnectDataModel = File.ReadAllText(CONNECT_DATAMODEL_CONFIG_PATH);
|
|
}
|
|
|
|
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
|
|
Type = GetHeadType(x.Element("type").Value),
|
|
WarningLimit = Convert.ToInt16(x.Element("warningLimit").Value),
|
|
AlarmLimit = Convert.ToInt16(x.Element("alarmLimit").Value),
|
|
FixedHead = Convert.ToBoolean(x.Element("fixedHead").Value),
|
|
LocalizedNames = x.Element("localizedNames").Elements().ToDictionary( // Read localized names and convert into a dictionary
|
|
y => y.Attribute("langKey").Value, y => y.Value
|
|
),
|
|
})
|
|
.ToList();
|
|
}
|
|
|
|
/// <summary>
|
|
/// IO config setup from file
|
|
/// </summary>
|
|
private static void ReadIOConfig()
|
|
{
|
|
XDocument xmlConfigFile = GetXmlHandlerWithValidator(IO_CONFIG_SCHEMA_PATH, IO_CONFIG_PATH);
|
|
// Read head config from XML file
|
|
IOConfig = xmlConfigFile
|
|
.Root
|
|
.Elements()
|
|
.Select(x => new IOConfigModel()
|
|
{
|
|
Id = Convert.ToInt16(x.Element("id").Value),
|
|
Category = GetTActIO_Type(x.Element("category").Value),
|
|
Bank = x.Element("bank") != null ? x.Element("bank").Value : "0",
|
|
Position = x.Element("position") != null ? x.Element("position").Value : "0",
|
|
Page = x.Element("page") != null ? x.Element("page").Value : "",
|
|
Wire = x.Element("wire") != null ? x.Element("wire").Value : "",
|
|
Profinet = x.Element("profinet") != null ? x.Element("profinet").Value : "",
|
|
DisableForce = x.Element("disableForce") != null ? Convert.ToBoolean(x.Element("disableForce").Value) : false
|
|
})
|
|
.ToList();
|
|
}
|
|
|
|
private static void ReadM156()
|
|
{
|
|
// Get Areas file handler
|
|
XDocument xmlConfigFile = GetXmlHandlerWithValidator(M156_CONFIG_SCHEMA_PATH, M156_CONFIG_PATH);
|
|
|
|
InputsOperatorConfig = xmlConfigFile
|
|
.Descendants("inputsOperator")
|
|
.Elements()
|
|
.Select(x => new InputOperatorConfigModel()
|
|
{
|
|
Id = Convert.ToInt32(x.Element("id").Value),
|
|
Messages = x.Element("title").Elements().ToDictionary( // Read localized names and convert into a dictionary
|
|
y => y.Attribute("langKey").Value, y => y.Value
|
|
),
|
|
Buttons = x.Element("buttons")?.Elements().ToDictionary( // Read buttons data and convert into a dictionary
|
|
y => Convert.ToByte(y.Element("value").Value),
|
|
y => y.Element("title").Elements().ToDictionary( // Read localized names and convert into a dictionary
|
|
z => z.Attribute("langKey").Value,
|
|
z => z.Value
|
|
)
|
|
),
|
|
Type = GetInputOperatoType(x.Name.ToString())
|
|
})
|
|
.ToList();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Module config setup from file
|
|
/// </summary>
|
|
private static void ReadModBlockConfig()
|
|
{
|
|
XDocument xmlConfigFile = GetXmlHandlerWithValidator(MODBLOCK_CONFIG_SCHEMA_PATH, MODBLOCK_CONFIG_PATH);
|
|
|
|
// Read head config from XML file
|
|
ModBlockConfig = xmlConfigFile
|
|
.Root
|
|
.Elements()
|
|
.Select(x => new ModBlockConfigModel()
|
|
{
|
|
Id = Convert.ToInt16(x.Element("id").Value),
|
|
Label = x.Element("label").Value,
|
|
Type = GetTActMB_Type(x.Element("type").Value),
|
|
Section = GetTActMB_Section(x.Element("section").Value),
|
|
IdParam = Convert.ToInt16(x.Element("idParam").Value),
|
|
ShowDelay = Convert.ToBoolean(x.Element("showDelay").Value),
|
|
Priority = Convert.ToInt16(x.Element("priority").Value),
|
|
// attributi presi da default se NON presenti...
|
|
ScaleFactor = x.Element("scaleFactor") != null ? Convert.ToInt16(x.Element("scaleFactor").Value) : 1000,
|
|
NumDec = x.Element("numDec") != null ? Convert.ToInt16(x.Element("numDec").Value) : 1,
|
|
Category = x.Element("category") != null ? x.Element("category").Value : "",
|
|
SubCategory_1 = x.Element("subCategory_1") != null ? x.Element("subCategory_1").Value : "",
|
|
SubCategory_2 = x.Element("subCategory_2") != null ? x.Element("subCategory_2").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();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Recipe Config setup from file
|
|
/// </summary>
|
|
private static void ReadRecipeConfig()
|
|
{
|
|
XDocument xmlConfigFile = GetXmlHandlerWithValidator(RECIPE_CONFIG_SCHEMA_PATH, RECIPE_CONFIG_PATH);
|
|
|
|
// Read Recipe config from XML file
|
|
RecipeConfig = xmlConfigFile
|
|
.Root
|
|
.Elements()
|
|
.Select(x => new RecipeConfigModel()
|
|
{
|
|
Id = Convert.ToInt16(x.Element("id").Value),
|
|
Category = GetTActParamType(x.Element("category").Value),
|
|
SubCategory_1 = x.Element("subCategory_1").Value,
|
|
SubCategory_2 = x.Element("subCategory_2").Value,
|
|
Name = x.Element("name").Value,
|
|
Description = x.Element("description").Value,
|
|
Format = x.Element("format").Value,
|
|
ScaleFactor = Convert.ToInt16(x.Element("scaleFactor").Value),
|
|
NumDec = Convert.ToInt16(x.Element("numDec").Value),
|
|
//EnumVal = new Dictionary<string, string>()
|
|
EnumVal = x.Element("enumList") != null ? x.Element("enumList").Elements().ToDictionary(
|
|
y => y.Element("value").Value,
|
|
y => new EnumDetail(y.Element("label").Value, y.Element("anim") != null ? y.Element("anim").Value : "")
|
|
) : new Dictionary<string, EnumDetail>()
|
|
})
|
|
.ToList();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Warmers config setup from file
|
|
/// </summary>
|
|
private static void ReadRiskConfig()
|
|
{
|
|
XDocument xmlConfigFile = GetXmlHandlerWithValidator(RISK_CONFIG_SCHEMA_PATH, RISK_CONFIG_PATH);
|
|
|
|
int i = 0;
|
|
|
|
List<RiskRiflettore> Riflettori = new List<RiskRiflettore>();
|
|
List<RiskResistenza> Resistenze = new List<RiskResistenza>();
|
|
List<RiskRiferimenti> Riferimenti = new List<RiskRiferimenti>();
|
|
|
|
// carico gli oggetti "nativi"
|
|
Riferimenti = xmlConfigFile
|
|
.Root
|
|
.Elements("riferimenti")
|
|
.Select(x => new RiskRiferimenti()
|
|
{
|
|
Id = Convert.ToInt16(x.Value),
|
|
Dimensione = Convert.ToInt16(x.Attribute("dimensione").Value),
|
|
Potenza = Convert.ToInt16(x.Attribute("potenza").Value),
|
|
Modello = x.Attribute("modello").Value
|
|
})
|
|
.ToList();
|
|
|
|
Riflettori = xmlConfigFile
|
|
.Root
|
|
.Elements("riflettore")
|
|
.Select(x => new RiskRiflettore()
|
|
{
|
|
Tipo = Convert.ToInt16(x.Attribute("tipo").Value),
|
|
Resistenze = x.Elements("resistenza")
|
|
.Select(y => new RiskResistenza()
|
|
{
|
|
Canale = Convert.ToInt16(y.Attribute("canale").Value),
|
|
Riga = Convert.ToInt16(y.Attribute("riga").Value),
|
|
Tipo = Convert.ToInt16(y.Attribute("tipo").Value),
|
|
IdGruppo = Convert.ToInt16(y.Attribute("idGruppo").Value),
|
|
}
|
|
)
|
|
.ToList()
|
|
})
|
|
.ToList();
|
|
|
|
// conversione da modelli RISK a modello Thermo...
|
|
int numCol = -1;
|
|
int ResistId = 0;
|
|
int oldRow = 0;
|
|
int currIdBoard = 0;
|
|
int maxCol = 0;
|
|
int maxRow = 0;
|
|
RiskBoardConfig = new List<RiskBoardModel>();
|
|
RiskResistConfig = new List<RiskResistModel>();
|
|
RiskChannelConfig = new List<RiskChannelModel>();
|
|
|
|
// inizializzo le 64 schede a 0 canali...
|
|
for (int idxBoard = 0; idxBoard < 64; idxBoard++)
|
|
{
|
|
RiskBoardConfig.Add(new RiskBoardModel()
|
|
{
|
|
IdBoard = idxBoard,
|
|
NumChannels = 0
|
|
});
|
|
}
|
|
|
|
// ciclo x calcolare i canali
|
|
foreach (var riflettore in Riflettori)
|
|
{
|
|
// ciclo sulle resistenze
|
|
foreach (var resistenza in riflettore.Resistenze)
|
|
{
|
|
// cerco la scheda dato il canale... 16 ch x ogni scheda
|
|
currIdBoard = (resistenza.Canale - 1) / 16;
|
|
// cerco se ho già la scheda
|
|
var boardFound = RiskBoardConfig.Find(item => item.IdBoard == currIdBoard);
|
|
if (boardFound == null)
|
|
{
|
|
RiskBoardConfig.Add(new RiskBoardModel()
|
|
{
|
|
IdBoard = currIdBoard,
|
|
NumChannels = 1
|
|
});
|
|
}
|
|
else
|
|
{
|
|
boardFound.NumChannels += 1;
|
|
}
|
|
|
|
// cerco se ho già il canale
|
|
var chanFound = RiskChannelConfig.Find(item => item.IdChannel == resistenza.Canale);
|
|
if (chanFound == null)
|
|
{
|
|
// cerco il TIPO...
|
|
var riferimento = Riferimenti.Find(x => x.Id == resistenza.Tipo);
|
|
if (riferimento != null)
|
|
{
|
|
RiskChannelConfig.Add(new RiskChannelModel()
|
|
{
|
|
IdChannel = resistenza.Canale,
|
|
IdReflector = riflettore.Tipo,
|
|
SetpointRecipe = 0,
|
|
SetpointThermo = 0,
|
|
MaxPower = riferimento.Potenza,
|
|
NumResist = 1,
|
|
refPosDistance = 999999,
|
|
refPos = new ThermoPoint(), // imposto default a 0
|
|
// 2020.07.27 applicato x tutti
|
|
CalcIchMin = true //riferimento.Modello.Contains("Quarzo") || riferimento.Modello.Contains("Alogena")
|
|
});
|
|
}
|
|
}
|
|
else
|
|
{
|
|
chanFound.NumResist += 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
// ciclo sui riflettori x recuperare le resistenze...
|
|
foreach (var riflettore in Riflettori)
|
|
{
|
|
// ciclo sulle resistente
|
|
foreach (var resistenza in riflettore.Resistenze)
|
|
{
|
|
if (oldRow != resistenza.Riga)
|
|
{
|
|
numCol = 0;
|
|
oldRow = resistenza.Riga;
|
|
}
|
|
else
|
|
{
|
|
numCol++;
|
|
maxCol = numCol > maxCol ? numCol : maxCol;
|
|
}
|
|
|
|
// cerco il TIPO...
|
|
var riferimento = Riferimenti.Find(x => x.Id == resistenza.Tipo);
|
|
|
|
RiskResistConfig.Add(new RiskResistModel()
|
|
{
|
|
Id = ResistId++,
|
|
Row = resistenza.Riga,
|
|
Column = numCol,
|
|
IdChannel = resistenza.Canale,
|
|
Dimension = riferimento.Dimensione,
|
|
IdReflector = riflettore.Tipo,
|
|
IdGroup = resistenza.IdGruppo,
|
|
}); ;
|
|
maxRow = resistenza.Riga > maxRow ? resistenza.Riga : maxRow;
|
|
}
|
|
}
|
|
|
|
// recupero parametri plate e dim resistenze
|
|
int warmerPlanSizeX = 0;
|
|
int warmerPlanSizeY = 0;
|
|
int resistSizeX = 0;
|
|
int resistSizeY = 0;
|
|
int flirImgX = 0;
|
|
int flirImgY = 0;
|
|
int.TryParse(AdditionalParametersConfig["warmerPlanSizeX"], out warmerPlanSizeX);
|
|
int.TryParse(AdditionalParametersConfig["warmerPlanSizeY"], out warmerPlanSizeY);
|
|
int.TryParse(AdditionalParametersConfig["resistSizeX"], out resistSizeX);
|
|
int.TryParse(AdditionalParametersConfig["resistSizeY"], out resistSizeY);
|
|
int.TryParse(AdditionalParametersConfig["flirImgX"], out flirImgX);
|
|
int.TryParse(AdditionalParametersConfig["flirImgY"], out flirImgY);
|
|
// calcolo punti!
|
|
ThermoPoint centro = new ThermoPoint() { X = warmerPlanSizeX / 2, Y = warmerPlanSizeY / 2 };
|
|
ThermoPoint punto = new ThermoPoint();
|
|
ThermoPoint puntoFlirImg = new ThermoPoint();
|
|
double actDist = warmerPlanSizeX + warmerPlanSizeY;
|
|
double minDist = warmerPlanSizeX + warmerPlanSizeY;
|
|
// ciclo ora per calcolare TUTTE le posizioni di riferimento dei canali (prendendo il centro delle resistenze)
|
|
Dictionary<int, ThermoPoint> newPos = new Dictionary<int, ThermoPoint>();
|
|
var listChSup = RiskChannelConfig.Where(x => x.IdReflector == 0);
|
|
|
|
// spazzo riga x riga da elenco resistenze...
|
|
var listResist = RiskResistConfig.Where(x => x.IdReflector == 0);
|
|
int currRow = -1;
|
|
double currX = 0;
|
|
for (int rigaCorr = 0; rigaCorr <= maxRow; rigaCorr++)
|
|
{
|
|
for (int colCorr = 0; colCorr <= maxCol; colCorr++)
|
|
{
|
|
var currResist = listResist.FirstOrDefault(x => x.Row == rigaCorr && x.Column == colCorr);
|
|
if (currResist != null)
|
|
{
|
|
// se cambio riga --> mi metto a metà della prima cella
|
|
if (currResist.Row != currRow)
|
|
{
|
|
currX = (currResist.Dimension * resistSizeX) / 2;
|
|
currRow = currResist.Row;
|
|
}
|
|
else
|
|
{
|
|
// calcolo coordinata X CumSum
|
|
currX += (currResist.Dimension * resistSizeX);
|
|
}
|
|
//// reset distanza
|
|
//actDist = warmerPlanSizeX + warmerPlanSizeY;
|
|
//minDist = warmerPlanSizeX + warmerPlanSizeY;
|
|
|
|
// tutti i calcoli in coordinate mm del riscaldo
|
|
punto = new ThermoPoint() { X = (int)currX, Y = currResist.Row * resistSizeY + resistSizeY / 2 };
|
|
puntoFlirImg = new ThermoPoint();
|
|
actDist = ThermoPoint.distance(punto, centro);
|
|
// cerco i dati del canale attuale...
|
|
var currChannel = RiskChannelConfig.FirstOrDefault(x => x.IdChannel == currResist.IdChannel);
|
|
if (currChannel.refPosDistance > actDist)
|
|
{
|
|
// riscalo il punto per la dimensione della FLIR
|
|
puntoFlirImg.X = punto.X * flirImgX / warmerPlanSizeX;
|
|
puntoFlirImg.Y = punto.Y * flirImgY / warmerPlanSizeY;
|
|
currChannel.refPos = puntoFlirImg;
|
|
currChannel.refPosDistance = actDist;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void ReadScadaFile()
|
|
{
|
|
DirectoryInfo d = new DirectoryInfo(SCADA_DIRECTORY);
|
|
FileInfo[] files = d.GetFiles("*.xml");
|
|
|
|
int i = 1;
|
|
// Cycle inside xml files
|
|
foreach (var file in files)
|
|
{
|
|
validateScada(SCADA_PAGES_SCHEMA_PATH, SCADA_DIRECTORY + file.Name);
|
|
|
|
StreamReader sr = new StreamReader(SCADA_DIRECTORY + file.Name);
|
|
XmlSerializer xmlSerializer = new XmlSerializer(typeof(ScadaSchemaModel));
|
|
ScadaSchemaModel schema = xmlSerializer.Deserialize(sr) as ScadaSchemaModel;
|
|
|
|
// Setup incremental ids
|
|
schema.Id = i++;
|
|
|
|
var name = Path.GetFileNameWithoutExtension(file.Name);
|
|
schema.BackgroundImage = GetImageBase64String(SCADA_DIRECTORY + name, schema.BackgroundImage);
|
|
|
|
schema.Layers = schema.Layers.Select(x => new ScadaSchemaLayerModel()
|
|
{
|
|
Id = i++,
|
|
Buttons = x.Buttons.Select(y => { y.Id = i++; return y; }).ToArray(),
|
|
Images = x.Images.Select(y =>
|
|
{
|
|
y.Id = i++;
|
|
y.Name = GetImageBase64String(SCADA_DIRECTORY + name, y.Name);
|
|
return y;
|
|
})
|
|
.ToArray(),
|
|
Labels = x.Labels.Select(y => { y.Id = i++; return y; }).ToArray(),
|
|
ProgressBars = x.ProgressBars.Select(y => { y.Id = i++; return y; }).ToArray(),
|
|
Inputs = x.Inputs.Select(y => { y.Id = i++; return y; }).ToArray()
|
|
})
|
|
.ToArray();
|
|
|
|
if (schema.IsInProductionPage == true)
|
|
ProductionScadaSchema.Add(schema);
|
|
else
|
|
ConfiguredScadaSchema.Add(schema);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// ThermoProd setup from file
|
|
/// </summary>
|
|
private static void ReadThermoProdConfig()
|
|
{
|
|
XDocument xmlConfigFile = GetXmlHandlerWithValidator(THERMO_PROD_SCHEMA_PATH, THERMO_PROD_PATH);
|
|
|
|
// Read Recipe config from XML file
|
|
ThermoProdConfig = xmlConfigFile
|
|
.Root
|
|
.Elements()
|
|
.Select(x => new ThermoProdConfigModel()
|
|
{
|
|
Category = GetTActProdCategory(x.Element("category").Value),
|
|
Name = x.Element("name").Value,
|
|
Label = x.Element("label").Value,
|
|
UM = x.Element("um").Value,
|
|
ScaleFactor = Convert.ToInt32(x.Element("scaleFactor").Value),
|
|
NumDec = Convert.ToInt32(x.Element("numDec").Value),
|
|
MinVal = Convert.ToInt32(x.Element("minVal").Value),
|
|
MaxVal = Convert.ToInt32(x.Element("maxVal").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),
|
|
IsVisible = Convert.ToBoolean(x.Element("visible").Value),
|
|
IsStarred = x.Element("starred") != null ? Convert.ToBoolean(x.Element("starred").Value) : false,
|
|
RefCallLabel = x.Element("refCallLabel") != null ? x.Element("refCallLabel").Value : "",
|
|
RefCallParam = x.Element("refCallParam") != null ? x.Element("refCallParam").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().Where(y => Convert.ToBoolean(y.Attribute("active").Value) == true) // Filter for active softkey
|
|
.Select(y => new SubKeysModel() // Populate subkeys if exist
|
|
{
|
|
Id = id++,
|
|
IsActive = Convert.ToBoolean(y.Attribute("active").Value),
|
|
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 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 SetAreaValueByName(XElement element)
|
|
{
|
|
// Choose which area to be set
|
|
switch (element.Name.ToString())
|
|
{
|
|
case AREAS.PRODUCTION_KEY:
|
|
SetAreaValue(ref ProductionConfig, 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;
|
|
|
|
case AREAS.JOBEDITOR_KEY:
|
|
SetAreaValue(ref JobEditorConfig, element);
|
|
break;
|
|
|
|
case AREAS.USERS_KEY:
|
|
SetAreaValue(ref UsersConfig, element);
|
|
break;
|
|
|
|
case AREAS.THERMO_HOOD_KEY:
|
|
SetAreaValue(ref ThermoHoodConfig, element);
|
|
break;
|
|
}
|
|
}
|
|
|
|
private static void validateScada(string configSchemaFilePath, string configFilePath)
|
|
{
|
|
// Create new instance
|
|
XmlSchemaSet readerSettings = new XmlSchemaSet();
|
|
|
|
// Add Schema from Assembly
|
|
Assembly myAssembly = Assembly.GetExecutingAssembly();
|
|
using (Stream schemaStream = myAssembly.GetManifestResourceStream(configSchemaFilePath))
|
|
{
|
|
using (XmlReader schemaReader = XmlReader.Create(schemaStream))
|
|
{
|
|
readerSettings.Add(null, schemaReader);
|
|
}
|
|
}
|
|
|
|
actualFileName = Path.GetFileName(configFilePath);
|
|
|
|
// Open file reader
|
|
XDocument xmlConfigFile = XDocument.Load(configFilePath);
|
|
// Validate file
|
|
xmlConfigFile.Validate(readerSettings, ValidationHandler);
|
|
}
|
|
|
|
private static void ValidationHandler(object sender, ValidationEventArgs e)
|
|
{
|
|
if (e.Severity == XmlSeverityType.Warning)
|
|
{
|
|
ExceptionManager.ManageError(ERROR_LEVEL.WARNING, e.Message, true);
|
|
}
|
|
else if (e.Severity == XmlSeverityType.Error)
|
|
{
|
|
ExceptionManager.ManageError(ERROR_LEVEL.FATAL,
|
|
// "Error while reading file: " + e.Exception.SourceUri +
|
|
"Error while reading XML file \"" + actualFileName + "\" \n\n" + e.Message,
|
|
true
|
|
);
|
|
}
|
|
}
|
|
|
|
#endregion Private Methods
|
|
|
|
#region Public Methods
|
|
|
|
public static string CalculateHash(string filename)
|
|
{
|
|
using (var sha = SHA1.Create())
|
|
{
|
|
using (var stream = File.OpenRead(filename))
|
|
{
|
|
var hash = sha.ComputeHash(stream);
|
|
return BitConverter.ToString(hash).Replace("-", "").ToLowerInvariant();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static bool CheckAreaStatus(string areaName)
|
|
{ // Get Area status ( enabled field) by name
|
|
switch (areaName)
|
|
{
|
|
case AREAS.PRODUCTION_KEY:
|
|
return ProductionConfig.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.JOBEDITOR_KEY:
|
|
return ScadaConfig.Enabled;
|
|
|
|
case AREAS.GENERAL_KEY:
|
|
case AREAS.UNDER_HOOD:
|
|
return true;
|
|
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public static string GetInputOperatoType(string tagName)
|
|
{
|
|
switch (tagName)
|
|
{
|
|
case "modalValue":
|
|
return "REAL";
|
|
|
|
case "buttonsListModal":
|
|
return "MULTIPLE_BUTTONS";
|
|
|
|
case "showValModal":
|
|
return "SHOW_VAL";
|
|
|
|
case "simpleModal":
|
|
return "MODAL";
|
|
|
|
default:
|
|
return "REAL";
|
|
}
|
|
}
|
|
|
|
public static void ReadAssistanceConfig()
|
|
{
|
|
//Read Standard CMS Configuration
|
|
XDocument xmlConfigFile = GetXmlHandlerWithValidator(MAINTENANCES_CONFIG_SCHEMA_PATH, MAINTENANCES_CONFIG_PATH);
|
|
ReadAssistanceConfigFromXml(
|
|
xmlConfigFile.Root.Descendants("cmsContacts").FirstOrDefault(),
|
|
out CmsContactConfig,
|
|
out CmsAuxContact1,
|
|
out CmsAuxContact2
|
|
);
|
|
|
|
xmlConfigFile = GetXmlHandlerWithValidator(MAINTENANCES_CONFIG_SCHEMA_PATH, MAINTENANCES_CONFIG_PATH);
|
|
ReadAssistanceConfigFromXml(
|
|
xmlConfigFile.Root.Descendants("scmContacts").FirstOrDefault(),
|
|
out ScmContactConfig,
|
|
out ScmAuxContact1,
|
|
out ScmAuxContact2
|
|
);
|
|
}
|
|
|
|
public static void ReadAssistanceConfigFromXml(XElement xmlRoot, out ContactModel MainContact, out ContactModel AuxContact1, out ContactModel AuxContact2)
|
|
{
|
|
MainContact = xmlRoot
|
|
.Descendants("MainOffice")
|
|
.Select(x =>
|
|
new ContactModel()
|
|
{
|
|
Company = x.Element("company").Value,
|
|
Email = x.Element("email").Value,
|
|
PhoneNumber = x.Element("phoneNumber").Value,
|
|
WebSite = x.Element("moreInfoUrl").Value,
|
|
})
|
|
.FirstOrDefault();
|
|
|
|
AuxContact1 = xmlRoot
|
|
.Descendants("AuxOffice1")
|
|
.Select(x =>
|
|
new ContactModel()
|
|
{
|
|
Visible = Convert.ToBoolean(x.Element("visible").Value),
|
|
Name = x.Element("name").Value,
|
|
Email = x.Element("email").Value,
|
|
PhoneNumber = x.Element("phoneNumber").Value
|
|
})
|
|
.FirstOrDefault();
|
|
|
|
AuxContact2 = xmlRoot
|
|
.Descendants("AuxOffice2")
|
|
.Select(x =>
|
|
new ContactModel()
|
|
{
|
|
Visible = Convert.ToBoolean(x.Element("visible").Value),
|
|
Name = x.Element("name").Value,
|
|
Email = x.Element("email").Value,
|
|
PhoneNumber = x.Element("phoneNumber").Value
|
|
})
|
|
.FirstOrDefault();
|
|
}
|
|
|
|
public static bool ReadAssistanceCustomConfig()
|
|
{
|
|
DealerContactConfig = null;
|
|
DealerAuxContact1 = null;
|
|
DealerAuxContact2 = null;
|
|
|
|
//Read Dealer Configuration
|
|
if (File.Exists(CUSTOMER_CONTACTS))
|
|
{
|
|
// Open file reader
|
|
XmlDocument xmlContactFile = new XmlDocument();
|
|
xmlContactFile.Load(CUSTOMER_CONTACTS);
|
|
|
|
// Create new instance
|
|
XmlSchemaSet readerSettings = new XmlSchemaSet();
|
|
|
|
// Add Schema from Assembly
|
|
Assembly myAssembly = Assembly.GetExecutingAssembly();
|
|
using (Stream schemaStream = myAssembly.GetManifestResourceStream(CUSTOMER_CONTACTS_CONFIG_SCHEMA_PATH))
|
|
{
|
|
using (XmlReader schemaReader = XmlReader.Create(schemaStream))
|
|
{
|
|
readerSettings.Add(null, schemaReader);
|
|
}
|
|
}
|
|
|
|
xmlContactFile.Schemas.Add(readerSettings);
|
|
|
|
// Validate file
|
|
try
|
|
{
|
|
xmlContactFile.Validate(null);
|
|
}
|
|
catch (XmlSchemaValidationException)
|
|
{
|
|
ReadAssistanceConfig();
|
|
return false;
|
|
}
|
|
|
|
ReadAssistanceConfigFromXml(
|
|
XDocument.Parse(xmlContactFile.OuterXml).Root,
|
|
out DealerContactConfig,
|
|
out DealerAuxContact1,
|
|
out DealerAuxContact2
|
|
);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public static void ReadMacros()
|
|
{
|
|
XDocument xmlConfigFile = GetXmlHandlerWithValidator(MACROS_CONFIG_SCHEMA_PATH, MACROS_CONFIG_PATH);
|
|
|
|
// Read config from XML file
|
|
MacrosConfig = xmlConfigFile
|
|
.Descendants("macros")
|
|
.Elements()
|
|
.Select(x => x.Value)
|
|
.ToList();
|
|
}
|
|
|
|
public static void ReadMaintenancesConfig()
|
|
{
|
|
// Get Maintenances file handler
|
|
XDocument xmlConfigFile = GetXmlHandlerWithValidator(MAINTENANCES_CONFIG_SCHEMA_PATH, MAINTENANCES_CONFIG_PATH);
|
|
|
|
ReadAssistanceConfig();
|
|
|
|
MaintenancesConfig = xmlConfigFile
|
|
.Descendants("maintenances")
|
|
.Elements("maintenance")
|
|
.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.ParseExact(x.Element("deadline").Value, DATE_TIME_FORMATS, CultureInfo.InvariantCulture, DateTimeStyles.AdjustToUniversal),
|
|
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();
|
|
}
|
|
|
|
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,
|
|
SharedPath = x.Element("sharedPath").Value,
|
|
SharedName = x.Element("sharedName").Value,
|
|
InstallationDate = x.Element("installationDate").Value,
|
|
MgiOption = Convert.ToBoolean(x.Element("mgiOption").Value),
|
|
SiemensKeyboardOption = Convert.ToBoolean(x.Element("siemensKeyboardOption").Value),
|
|
MachineNumberHasLetters = Convert.ToBoolean(x.Element("machineNumberHasLetters").Value)
|
|
}).FirstOrDefault();
|
|
|
|
// Read Prod Software Config with LINQ
|
|
SoftwareProdConfig = xmlConfigFile
|
|
.Root
|
|
.Descendants(PROD_SFT_CONFIG_KEY)
|
|
.Select(x => new SoftwareProdConfigModel()
|
|
{
|
|
Enabled = Convert.ToBoolean(x.Element("enabled").Value),
|
|
Path = x.Element("path").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,
|
|
AutoOpenCmsClient = Convert.ToBoolean(x.Element("autoOpenCmsClient").Value),
|
|
TextEditorPath = x.Element("textEditorPath").Value,
|
|
MTCFolderPath = x.Element("MTCFolderPath").Value,
|
|
MTCApplicationName = x.Element("MTCApplicationName").Value,
|
|
MaxAlarmsRows = Convert.ToInt32(x.Element("maxAlarmsRows").Value),
|
|
AlarmToDelete = Convert.ToInt32(x.Element("alarmToDelete").Value),
|
|
MaxSheetHistoryRows = Convert.ToInt32(x.Element("maxSheetHistoryRows").Value),
|
|
SheetHistoryToDelete = Convert.ToInt32(x.Element("sheetHistoryToDelete").Value),
|
|
CmsConnectReady = Convert.ToBoolean(x.Element("CMSConnectReady").Value)
|
|
}).FirstOrDefault();
|
|
|
|
int softwareId = 0;
|
|
ExtSoftwaresConfig = xmlConfigFile
|
|
.Descendants("extSoftwares")
|
|
.Elements("software")
|
|
.Select(x => new ExtSoftwareModel()
|
|
{
|
|
Path = x.Element("path").Value,
|
|
Arguments = x.Element("arguments").Value,
|
|
LongName = x.Element("longName").Value,
|
|
ShortName = x.Element("shortName").Value,
|
|
IconBase64 = ExtractBase64ProgIcon(x.Element("path").Value),
|
|
InMainMenuBar = Convert.ToBoolean(x.Element("inMainMenuBar").Value),
|
|
Id = softwareId++.ToString()
|
|
}).ToList();
|
|
|
|
// carico additionals parameters
|
|
AdditionalParametersConfig = xmlConfigFile
|
|
.Descendants("additionalParameters")
|
|
.Elements("entry")
|
|
.Select(x => new KeyValuePair<string, string>(x.Element("key").Value, x.Element("value").Value))
|
|
.ToDictionary(x => x.Key, x => x.Value);
|
|
|
|
// carico unità di misura...
|
|
UnitMeasuresConfig = xmlConfigFile
|
|
.Descendants("unitOfMeasures")
|
|
.Elements("unitOfMeasure")
|
|
.Select(x => new KeyValuePair<int, string>(Convert.ToInt32(x.Attribute("id").Value), x.Attribute("value").Value))
|
|
.ToDictionary(x => x.Key, x => x.Value);
|
|
|
|
// carico conf periodi thread...
|
|
ThreadSamplingConfig = xmlConfigFile
|
|
.Descendants("sampling")
|
|
.Elements("thread")
|
|
.Select(x => new KeyValuePair<string, int>(x.Attribute("name").Value, Convert.ToInt32(x.Attribute("value").Value)))
|
|
.ToDictionary(x => x.Key, x => x.Value);
|
|
}
|
|
|
|
public static void ReadStartupConfig()
|
|
{
|
|
try
|
|
{
|
|
ReadServerConfig();
|
|
ReadAreaConfig();
|
|
ReadMaintenancesConfig();
|
|
ReadNcSoftKeys();
|
|
ReadUserSoftKeysConfig();
|
|
ReadAlarmsConfig();
|
|
ReadHeadsConfig();
|
|
ReadThermoProdConfig();
|
|
ReadRecipeConfig();
|
|
ReadModBlockConfig();
|
|
ReadIOConfig();
|
|
ReadRiskConfig();
|
|
ReadAxesConfig();
|
|
ReadCMSConnectConfig();
|
|
ReadMacros();
|
|
ReadScadaFile();
|
|
ReadM156();
|
|
ReadDataModel();
|
|
}
|
|
catch (XmlException ex)
|
|
{
|
|
ExceptionManager.ManageError(ERROR_LEVEL.FATAL,
|
|
"Error while reading file: " + ex.SourceUri +
|
|
"\n Error: " + ex.Message,
|
|
true
|
|
);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
var message = ex.Message;
|
|
if (ex.InnerException != null)
|
|
message += "\n" + ex.InnerException.Message;
|
|
ExceptionManager.ManageError(ERROR_LEVEL.FATAL, message, true);
|
|
}
|
|
}
|
|
|
|
#endregion Public Methods
|
|
}
|
|
} |