public void Reset()
{
concreteModel = null;
delta = new Delta();
importHelper = new ImportHelper();
report = null;
}
public TransformAndLoadReport CreateNMSDelta(ConcreteModel cimConcreteModel)
{
LogManager.Log("Importing PowerTransformer Elements...", LogLevel.Info);
report = new TransformAndLoadReport();
concreteModel = cimConcreteModel;
delta.ClearDeltaOperations();
if ((concreteModel != null) && (concreteModel.ModelMap != null))
{
try
{
// convert into DMS elements
ConvertModelAndPopulateDelta();
}
catch (Exception ex)
{
string message = string.Format("{0} - ERROR in data import - {1}", DateTime.Now, ex.Message);
LogManager.Log(message);
report.Report.AppendLine(ex.Message);
report.Success = false;
}
}
LogManager.Log("Importing PowerTransformer Elements - END.", LogLevel.Info);
return(report);
}
private ConditionalValue <Delta> DoTransformAndLoad(Assembly assembly, ConcreteModel concreteModel, SupportedProfiles extractType, StringBuilder logBuilder)
{
Delta nmsDelta;
bool success;
try
{
Logger.LogInfo($"Importing {extractType} data...");
if (extractType != SupportedProfiles.Outage)
{
Logger.LogWarn($"Import of {extractType} data is NOT SUPPORTED.");
}
TransformAndLoadReport report = OutageImporter.Instance.CreateNMSDelta(concreteModel, resourcesDesc);
success = report.Success;
nmsDelta = success ? OutageImporter.Instance.NMSDelta : null;
logBuilder.Append(report.Report.ToString());
OutageImporter.Instance.Reset();
}
catch (Exception ex)
{
success = false;
nmsDelta = null;
Logger.LogError("Import unsuccessful.", ex);
}
return(new ConditionalValue <Delta>(success, nmsDelta));
}
public TransformAndLoadReport CreateNMSDelta(ConcreteModel cimConcreteModel, ModelResourcesDesc resourcesDesc)
{
Logger.LogInfo("Importing Outage Elements...");
report = new TransformAndLoadReport();
concreteModel = cimConcreteModel;
delta.ClearDeltaOperations();
MridToPositiveGidFromServer.Clear();
MridsFromConcreteModel.Clear();
NegativeGidToMrid.Clear();
if ((concreteModel != null) && (concreteModel.ModelMap != null))
{
try
{
ConvertModelAndPopulateDelta(resourcesDesc);
}
catch (Exception ex)
{
string message = $"{DateTime.Now} - ERROR in data import - {ex.Message}";
//LogManager.Log(message);
Logger.LogError(message, ex);
report.Report.AppendLine(ex.Message);
report.Success = false;
}
}
Logger.LogInfo("Importing Outage Elements - END");
return(report);
}
private void LoadCIMXMLIntoConcreteModel()
{
////LOAD CIM/RDF AND MAKE A ConcreateModel
try
{
concreteModel = null;
string log;
using (FileStream fs = File.Open(textBoxCIMFile.Text, FileMode.Open))
{
if (LoadModelFromExtractFile(fs, ref concreteModel, out log))
{
// to do: zadak
StringBuilder sb = new StringBuilder();
foreach (KeyValuePair <string, SortedDictionary <string, object> > m in concreteModel.ModelMap)
{
sb.AppendLine($"{m.Key}: {m.Value.Count}");
}
if (concreteModel.ModelMap.ContainsKey("FTN.WindingTest") && concreteModel.ModelMap["FTN.WindingTest"].ContainsKey("939140759_TW1_WT"))
{
sb.AppendLine($"WindingTest with MRID[939140759_TW1_WT] has the load loss: {((FTN.WindingTest)concreteModel.ModelMap["FTN.WindingTest"]["939140759_TW1_WT"]).LoadLoss}");
}
resultTbx.Text = sb.ToString();
}
else
{
MessageBox.Show(string.Format("Extract is not valid.\n\n{0}", log), "Warning", MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
}
}
catch (Exception e)
{
MessageBox.Show(string.Format("An error occurred.\n\n{0}", e.Message), "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
public TransformAndLoadReport CreateNMSDelta(ConcreteModel cimConcreteModel)
{
LogManager.Log("Importing IES2 Elements...", LogLevel.Info);
report = new TransformAndLoadReport();
concreteModel = cimConcreteModel;
delta.ClearDeltaOperations();
if (concreteModel != null && concreteModel.ModelMap != null)
{
try
{
// convert into DMS elements
ConvertModelAndPopulateDelta();
}
catch (Exception ex)
{
var message = $"{DateTime.Now} - ERROR in data import - {ex.Message}";
LogManager.Log(message);
report.Report.AppendLine(ex.Message);
report.Success = false;
}
}
LogManager.Log("Importing IES2 Elements - END.", LogLevel.Info);
return(report);
}
public Delta CreateNMSDelta(ConcreteModel concreteModel)
{
if (concreteModel == null || concreteModel.ModelMap == null)
{
return(null);
}
Delta delta = new Delta();
foreach (DMSType type in ModelResourcesDesc.TypeIdsInInsertOrder)
{
SortedDictionary <string, object> cimObjects = concreteModel.GetAllObjectsOfType("FTN." + ModelCodeHelper.DMSTypeToName(type));
if (cimObjects == null)
{
continue;
}
foreach (KeyValuePair <string, object> cimObjectPair in cimObjects)
{
IDClass idc = cimObjectPair.Value as IDClass;
long gid = ModelCodeHelper.CreateGID(0, type, --counters[type]);
ResourceDescription rd = new ResourceDescription(gid);
idMapping[idc.ID] = gid;
PopulateProperties(idc, rd);
delta.InsertOperations.Add(rd);
}
}
return(delta);
}
private void IntializeView()
{
foreach (string observerKey in this.ObserverKeys)
{
ConcreteModel.RegisterObserver(this, observerKey);
}
this._treeView.AfterSelect += this.treeView_SelectedValue;
}
private void IntializeView()
{
foreach (string observerKey in this.ObserverKeys)
{
ConcreteModel.RegisterObserver(this, observerKey);
}
this._dataGridView.SelectionChanged += this.dataGridView_SelectionChanged;
}
public void Reset()
{
concreteModel = null;
delta = new Delta();
mridToPositiveGidFromServer = new Dictionary <string, long>();
mridsFromConcreteModel = new HashSet <string>();
negativeGidToMrid = new Dictionary <long, string>();
importHelper = new ImportHelper();
report = null;
}
private bool LoadModelFromExtractFile(Stream extract, ref ConcreteModel concreteModelResult, out string errorLog)
{
bool valid = false;
errorLog = string.Empty;
System.Globalization.CultureInfo culture = Thread.CurrentThread.CurrentCulture;
Thread.CurrentThread.CurrentCulture = new System.Globalization.CultureInfo("en-US");
try
{
Assembly assembly;
LoadAssembly(".\\" + ProfileName + ".dll", out assembly);
if (assembly != null)
{
CIMModel cimModel = new CIMModel();
CIMModelLoaderResult modelLoadResult = CIMModelLoader.LoadCIMXMLModel(extract, Namespace, out cimModel);
if (modelLoadResult.Success)
{
concreteModelResult = new ConcreteModel();
ConcreteModelBuilder builder = new ConcreteModelBuilder();
ConcreteModelBuildingResult modelBuildResult = builder.GenerateModel(cimModel, assembly, Namespace, ref concreteModelResult);
if (modelBuildResult.Success)
{
valid = true;
}
else
{
errorLog = modelBuildResult.Report.ToString();
}
}
else
{
errorLog = modelLoadResult.Report.ToString();
}
}
Thread.CurrentThread.CurrentCulture = culture;
}
catch (Exception e)
{
Thread.CurrentThread.CurrentCulture = culture;
errorLog = e.Message;
}
return(valid);
}
public Delta CreateDelta(Stream extract, SupportedProfiles extractType, out string log)
{
Delta nmsDelta = null;
ConcreteModel concreteModel = null;
Assembly assembly = null;
string loadLog = string.Empty;
string transformLog = string.Empty;
if (LoadModelFromExtractFile(extract, extractType, ref concreteModel, ref assembly, out loadLog))
{
DoTransformAndLoad(assembly, concreteModel, extractType, out nmsDelta, out transformLog);
}
log = string.Concat("Load report:\r\n", loadLog, "\r\nTransform report:\r\n", transformLog);
return(nmsDelta);
}
private bool DoTransformAndLoad(Assembly assembly, ConcreteModel concreteModel, SupportedProfiles extractType, out Delta nmsDelta, out string log)
{
nmsDelta = null;
log = string.Empty;
bool success = false;
try
{
LogManager.Log(string.Format("Importing {0} data...", extractType), LogLevel.Info);
switch (extractType)
{
case SupportedProfiles.Project36:
{
// transformation to DMS delta
TransformAndLoadReport report = Importer.Importer.Instance.CreateNMSDelta(concreteModel);
if (report.Success)
{
nmsDelta = Importer.Importer.Instance.NMSDelta;
success = true;
}
else
{
success = false;
}
log = report.Report.ToString();
Importer.Importer.Instance.Reset();
break;
}
default:
{
LogManager.Log(string.Format("Import of {0} data is NOT SUPPORTED.", extractType), LogLevel.Warning);
break;
}
}
return(success);
}
catch (Exception ex)
{
LogManager.Log(string.Format("Import unsuccessful: {0}", ex.StackTrace), LogLevel.Error);
return(false);
}
}
private bool LoadModelFromExtractFile(Stream extract, SupportedProfiles extractType, ref ConcreteModel concreteModelResult, ref Assembly assembly, out string log)
{
bool valid = false;
log = string.Empty;
System.Globalization.CultureInfo culture = Thread.CurrentThread.CurrentCulture;
Thread.CurrentThread.CurrentCulture = new System.Globalization.CultureInfo("en-US");
try
{
ProfileManager.LoadAssembly(extractType, out assembly);
if (assembly != null)
{
CIMModel cimModel = new CIMModel();
CIMModelLoaderResult modelLoadResult = CIMModelLoader.LoadCIMXMLModel(extract, ProfileManager.Namespace, out cimModel);
if (modelLoadResult.Success)
{
concreteModelResult = new ConcreteModel();
ConcreteModelBuilder builder = new ConcreteModelBuilder();
ConcreteModelBuildingResult modelBuildResult = builder.GenerateModel(cimModel, assembly, ProfileManager.Namespace, ref concreteModelResult);
if (modelBuildResult.Success)
{
valid = true;
}
log = modelBuildResult.Report.ToString();
}
else
{
log = modelLoadResult.Report.ToString();
}
}
}
catch (Exception e)
{
log = e.Message;
}
finally
{
Thread.CurrentThread.CurrentCulture = culture;
}
return(valid);
}
public ConditionalValue <Delta> CreateDelta(Stream extract, SupportedProfiles extractType, StringBuilder logBuilder)
{
ConditionalValue <Delta> result;
ConcreteModel concreteModel = null;
Assembly assembly = null;
report = new TransformAndLoadReport();
string loadLog;
if (LoadModelFromExtractFile(extract, extractType, ref concreteModel, ref assembly, out loadLog))
{
logBuilder.AppendLine($"Load report:\r\n{loadLog}");
result = DoTransformAndLoad(assembly, concreteModel, extractType, logBuilder);
}
else
{
result = new ConditionalValue <Delta>(false, null);
}
return(result);
}
