/// <summary>
/// Report the user status
/// </summary>
/// <param name="Status"></param>
/// <returns></returns>
public bool ReportUserStatus(MacomberMapCommunications.Messages.MM_Client_Status Status)
{
try
{
return(innerChannel.ReportUserStatus(Status));
}
catch (Exception ex)
{
MM_System_Interfaces.LogError(ex.Message);
try
{
if (ex.Message.IndexOf("aborted", StringComparison.OrdinalIgnoreCase) >= 0 || ex.Message.IndexOf("Faulted", StringComparison.OrdinalIgnoreCase) >= 0 && (!lastConnect.HasValue || (DateTime.Now - lastConnect.Value).TotalSeconds > 10))
{
// can we reconnect?
Exception error = null;
// this login method should reconnect us.
MM_Server_Interface.TryLogin(MM_Server_Interface.ServerName, MM_Server_Interface.ConnectionURI, MM_Server_Interface.UserName, MM_Server_Interface.Password, out error);
lastConnect = DateTime.Now;
if (error != null)
{
throw error;
}
}
}
catch (Exception exp)
{
MM_System_Interfaces.LogError(exp.Message);
}
return(false);
}
}
/// <summary>Report the server name</summary>
/// <returns></returns>
public string ServerName()
{
try
{
return(innerChannel.ServerName());
} catch (Exception ex)
{
MM_System_Interfaces.LogError(ex.Message);
try
{
if (ex.Message.IndexOf("aborted", StringComparison.OrdinalIgnoreCase) >= 0 || ex.Message.IndexOf("Faulted", StringComparison.OrdinalIgnoreCase) >= 0 && (!lastConnect.HasValue || (DateTime.Now - lastConnect.Value).TotalSeconds > 10))
{
// can we reconnect?
Exception error = null;
// this login method should reconnect us.
if (MM_Server_Interface.TryLogin(MM_Server_Interface.ServerName, MM_Server_Interface.ConnectionURI, MM_Server_Interface.UserName, MM_Server_Interface.Password, out error))
{
return(MM_Server_Interface.ServerName);
}
lastConnect = DateTime.Now;
if (error != null)
{
throw error;
}
}
}
catch (Exception exp)
{
MM_System_Interfaces.LogError(exp.Message);
}
return("SERVER ERROR");
}
}
/// <summary>
/// Log in to a server
/// </summary>
/// <param name="Title"></param>
/// <param name="ConnectionUri"></param>
private void LoginToServer(String Title, Uri ConnectionUri)
{
frmWindowsSecurityDialog SecurityDialog = new frmWindowsSecurityDialog();
SecurityDialog.CaptionText = Application.ProductName + " " + Application.ProductVersion;
SecurityDialog.MessageText = "Enter the credentials to log into Macomber Map Server " + Title;
string Username, Password, Domain;
Exception LoginError;
if (SecurityDialog.ShowLoginDialog(out Username, out Password, out Domain))
{
if (MM_Server_Interface.TryLogin(Title, ConnectionUri, Username, Password, out LoginError))
{
tpProgress.Show();
tcMain.SelectedTab = tpProgress;
StartupDelegate = new Data_Integration.StartupModelDelegate(Data_Integration.StartupModel);
IAsyncResult Resp = StartupDelegate.BeginInvoke(MM_Server_Interface.Client, this, false, HandleServerLoginCompletion, null);
MM_Repository.user = Username;
MM_Repository.pw = Password;
}
else
{
MessageBox.Show("Unable to log into Macomber Map Server: " + LoginError.Message, Application.ProductName, MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
}
/// <summary>
/// Execute the command within its own thread
/// </summary>
/// <param name="Elem"></param>
///
public void Execute(MM_Element Elem)
{
//Thread.CurrentThread.SetApartmentState(ApartmentState.STA);
String InCmd = Command;
//Replace the {word} with the values for that element
int Bracket = InCmd.IndexOf("{");
while (Bracket > -1)
{
String InWord = InCmd.Substring(Bracket + 1, InCmd.IndexOf("}", Bracket) - Bracket - 1);
Object InValue = null;
foreach (MemberInfo mI in Elem.GetType().GetMember(InWord))
{
if (mI is FieldInfo)
{
InValue = (mI as FieldInfo).GetValue(Elem);
}
else if (mI is PropertyInfo)
{
InValue = (mI as PropertyInfo).GetValue(Elem, null);
}
}
InCmd = InCmd.Substring(0, Bracket) + InValue.ToString() + InCmd.Substring(InCmd.IndexOf('}', Bracket) + 1);
Bracket = InCmd.IndexOf("{");
}
//Now, send our command if appropriate
if (MM_Server_Interface.SendCommand(InCmd, "") == CheckState.Unchecked)
{
MessageBox.Show("Unable to send command. Please retry.", Application.ProductName, MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
/// <summary>
/// Remove a line outage
/// </summary>
/// <param name="LineOutageData"></param>
public void RemoveLineOutageData(MM_Outage_Line_Data[] LineOutageData)
{
foreach (MM_Outage_Line_Data LineOutage in LineOutageData)
{
Data_Integration.RemoveViolation(MM_Server_Interface.CreateViolation(LineOutage));
}
MM_Server_Interface.UpdateTimestamp(typeof(MM_Outage_Line_Data));
}
/// <summary>
/// Remove a contingency violation
/// </summary>
/// <param name="ContingencyData"></param>
public void RemoveContingencyViolationData(MM_Contingency_Violation_Data[] ContingencyData)
{
foreach (MM_Contingency_Violation_Data Contingency in ContingencyData)
{
Data_Integration.RemoveViolation(MM_Server_Interface.CreateViolation(Contingency));
}
MM_Server_Interface.UpdateTimestamp(typeof(MM_Contingency_Violation_Data));
}
/// <summary>
/// Update our simulator time
/// </summary>
/// <param name="TimeData"></param>
public void UpdateSimulatorTime(MM_Simulation_Time[] TimeData)
{
foreach (MM_Simulation_Time Time in TimeData)
{
MM_Server_Interface.UpdateSimulatorTime(Time);
}
MM_Server_Interface.UpdateTimestamp(typeof(MM_Simulation_Time));
}
/// <summary>
/// Remove a basecase violation
/// </summary>
/// <param name="BasecaseData"></param>
public void RemoveBasecaseViolationData(MM_Basecase_Violation_Data[] BasecaseData)
{
foreach (MM_Basecase_Violation_Data Basecase in BasecaseData)
{
Data_Integration.RemoveViolation(MM_Server_Interface.CreateViolation(Basecase));
}
MM_Server_Interface.UpdateTimestamp(typeof(MM_Basecase_Violation_Data));
}
/// <summary>
/// Handle our updated interface data
/// </summary>
/// <param name="InterfaceData"></param>
public void UpdateInterfaceData(MM_Interface_Monitoring_Data[] InterfaceData)
{
foreach (MM_Interface_Monitoring_Data Interface in InterfaceData)
{
MM_Server_Interface.UpdateInterfaceData(Interface, true);
}
MM_Server_Interface.UpdateTimestamp(typeof(MM_Interface_Monitoring_Data));
}
/// <summary>
/// Update our unit type data
/// </summary>
/// <param name="UnitTypeData"></param>
public void UpdateUnitTypeGenerationData(MM_UnitType_Generation_Data[] UnitTypeData)
{
foreach (MM_UnitType_Generation_Data UnitTypeDatum in UnitTypeData)
{
MM_Server_Interface.UpdateUnitTypeData(UnitTypeDatum);
}
MM_Server_Interface.UpdateTimestamp(typeof(MM_UnitType_Generation_Data));
}
/// <summary>
/// Update our operatorship data
/// </summary>
/// <param name="OperatorshipUpdateData"></param>
public void UpdateOperatorshipData(MM_Operatorship_Update[] OperatorshipUpdateData)
{
foreach (MM_Operatorship_Update OperatorshipUpdate in OperatorshipUpdateData)
{
MM_Server_Interface.UpdateOperatorshipData(OperatorshipUpdate);
}
MM_Server_Interface.UpdateTimestamp(typeof(MM_Operatorship_Update));
}
/// <summary>
/// Update our transformer outage data
/// </summary>
/// <param name="TransformerOutageData"></param>
public void UpdateTransformerOutageData(MM_Outage_Transformer_Data[] TransformerOutageData)
{
foreach (MM_Outage_Transformer_Data TransformerData in TransformerOutageData)
{
Data_Integration.UpdateViolation(MM_Server_Interface.CreateViolation(TransformerData));
}
MM_Server_Interface.UpdateTimestamp(typeof(MM_Outage_Transformer_Data));
}
/// <summary>
/// Update our unit outage data
/// </summary>
/// <param name="UnitOutageData"></param>
public void UpdateUnitOutageData(MM_Outage_Unit_Data[] UnitOutageData)
{
foreach (MM_Outage_Unit_Data UnitData in UnitOutageData)
{
Data_Integration.UpdateViolation(MM_Server_Interface.CreateViolation(UnitData));
}
MM_Server_Interface.UpdateTimestamp(typeof(MM_Outage_Unit_Data));
}
/// <summary>
/// Update our chart information
/// </summary>
/// <param name="ChartData"></param>
public void UpdateChartData(MM_Chart_Data[] ChartData)
{
Data_Integration.ChartData = ChartData;
Data_Integration.ChartDate = DateTime.Now;
if (ChartData.Length > 0)
{
MM_Server_Interface.UpdateTimestamp(typeof(MM_Chart_Data));
}
}
/// <summary>
/// Update our island simulation data
/// </summary>
/// <param name="IslandSimulationData"></param>
public void UpdateIslandSimulationData(MM_Island_Simulation_Data[] IslandSimulationData)
{
//Create a new island if we need it
foreach (MM_Island_Simulation_Data InIsland in IslandSimulationData)
{
MM_Server_Interface.UpdateIslandSimulationData(InIsland, true);
}
MM_Server_Interface.UpdateTimestamp(typeof(MM_Island_Simulation_Data));
}
/// <summary>
/// Update our line outage data
/// </summary>
/// <param name="LineOutageData"></param>
public void UpdateLineOutageData(MM_Outage_Line_Data[] LineOutageData)
{
foreach (MM_Outage_Line_Data LineData in LineOutageData)
{
Data_Integration.UpdateViolation(MM_Server_Interface.CreateViolation(LineData));
}
MM_Server_Interface.CheckForOutagedLines();
MM_Server_Interface.UpdateTimestamp(typeof(MM_Outage_Line_Data));
}
/// <summary>
/// Update system wide generation data
/// </summary>
/// <param name="SystemWideData"></param>
public void UpdateSystemWideGenerationData(MM_SystemWide_Generation_Data[] SystemWideData)
{
foreach (MM_SystemWide_Generation_Data SystemWideDatum in SystemWideData)
{
MM_Server_Interface.UpdateSystemWideData(SystemWideDatum);
}
if (SystemWideData.Length > 0)
{
MM_Server_Interface.UpdateTimestamp(typeof(MM_SystemWide_Generation_Data));
}
}
/// <summary>
/// Update our analog measurement data
/// </summary>
/// <param name="AnalogMeasurementData"></param>
public void UpdateAnalogMeasurementData(MM_Analog_Measurement[] AnalogMeasurementData)
{
MM_Element FoundElem;
foreach (MM_Analog_Measurement Meas in AnalogMeasurementData)
{
if (MM_Repository.TEIDs.TryGetValue(Meas.TEID, out FoundElem))
{
}
}
MM_Server_Interface.UpdateTimestamp(typeof(MM_Analog_Measurement));
}
/// <summary>
/// Update our island data
/// </summary>
/// <param name="IslandData"></param>
public void UpdateIslandData(MM_Island_Data[] IslandData)
{
//Create a new island if we need it
foreach (MM_Island_Data InIsland in IslandData)
{
MM_Server_Interface.UpdateIslandData(InIsland, true);
}
if (IslandData.Length > 0)
{
MM_Server_Interface.UpdateTimestamp(typeof(MM_Island_Data));
}
}
/// <summary>
/// Report an updated unit control status
/// </summary>
/// <param name="UnitStatus"></param>
public void UpdateUnitControlStatus(MM_Unit_Control_Status[] UnitStatus)
{
MM_Element FoundElem;
foreach (MM_Unit_Control_Status InUnit in UnitStatus)
{
if (MM_Repository.TEIDs.TryGetValue(InUnit.TEID, out FoundElem) && FoundElem is MM_Unit)
{
MM_Server_Interface.UpdateUnitControlStatus(InUnit, FoundElem as MM_Unit, true);
}
}
MM_Server_Interface.UpdateTimestamp(typeof(MM_Unit_Control_Status));
}
/// <summary>
/// Update our transformer PS data
/// </summary>
/// <param name="PhaseShiftData"></param>
public void UpdateTransformerPhaseShifterData(MM_Transformer_PhaseShifter_Data[] PhaseShiftData)
{
MM_Element FoundElem;
foreach (MM_Transformer_PhaseShifter_Data InPS in PhaseShiftData)
{
if (MM_Repository.TEIDs.TryGetValue(InPS.TEID_XF, out FoundElem) && FoundElem is MM_TransformerWinding)
{
MM_Server_Interface.UpdateTransformerPhaseShifterData(InPS, FoundElem as MM_TransformerWinding, true);
}
}
MM_Server_Interface.UpdateTimestamp(typeof(MM_Transformer_PhaseShifter_Data));
}
/// <summary>
/// Update our synchroscope data
/// </summary>
/// <param name="SynchroscopeData"></param>
public void UpdateSynchroscopeData(MM_Synchroscope_Data[] SynchroscopeData)
{
MM_Element FoundElem;
foreach (MM_Synchroscope_Data InBreakerSwitch in SynchroscopeData)
{
if (MM_Repository.TEIDs.TryGetValue(InBreakerSwitch.TEID_CB, out FoundElem) && FoundElem is MM_Breaker_Switch)
{
MM_Server_Interface.UpdateSynchroscopeData(InBreakerSwitch, (MM_Breaker_Switch)FoundElem, true);
}
}
MM_Server_Interface.UpdateTimestamp(typeof(MM_Synchroscope_Data));
}
/// <summary>
/// Update Static Var Compensator data
/// </summary>
/// <param name="SVCData"></param>
public void UpdateStaticVarCompensatorData(MM_StaticVarCompensator_Data[] SVCData)
{
MM_Element FoundElem;
foreach (MM_StaticVarCompensator_Data InSVC in SVCData)
{
if (MM_Repository.TEIDs.TryGetValue(InSVC.TEID_SVS, out FoundElem) && FoundElem is MM_StaticVarCompensator)
{
MM_Server_Interface.UpdateSVCData(InSVC, (MM_StaticVarCompensator)FoundElem, true);
}
}
MM_Server_Interface.UpdateTimestamp(typeof(MM_StaticVarCompensator_Data));
}
/// <summary>
/// update lmp data in mm
/// </summary>
/// <param name="lmpData"></param>
public void UpdateLmpData(MM_LMP_Data[] lmpData)
{
foreach (var data in lmpData)
{
try
{
MM_Server_Interface.UpdateLmpData(data, true);
} catch (Exception)
{
}
}
MM_Server_Interface.UpdateTimestamp(typeof(MM_LMP_Data));
}
/// <summary>
/// Update our unit simulation data
/// </summary>
/// <param name="UnitSimulationData"></param>
public void UpdateUnitSimulationData(MM_Unit_Simulation_Data[] UnitSimulationData)
{
MM_Element FoundElem;
foreach (MM_Unit_Simulation_Data InUnit in UnitSimulationData)
{
if (MM_Repository.TEIDs.TryGetValue(InUnit.TEID_Un, out FoundElem) && FoundElem is MM_Unit)
{
MM_Server_Interface.UpdateUnitSimulationData(InUnit, FoundElem as MM_Unit, true);
}
}
MM_Server_Interface.UpdateTimestamp(typeof(MM_Unit_Simulation_Data));
}
/// <summary>
/// Handle an island being removed
/// </summary>
/// <param name="IslandData"></param>
public void HandleIslandRemoval(MM_Island_Data[] IslandData)
{
MM_Island FoundIsland;
foreach (MM_Island_Data Island in IslandData)
{
if (MM_Repository.Islands.TryGetValue(Island.Isl_Num, out FoundIsland))
{
FoundIsland.Frequency = FoundIsland.Generation = FoundIsland.Load = float.NaN;
MM_Repository.Islands.Remove(Island.Isl_Num);
}
}
MM_Server_Interface.UpdateTimestamp(typeof(MM_Island_Data));
Data_Integration.OverallIndicators[(int)Data_Integration.OverallIndicatorEnum.IslandCount] = MM_Repository.Islands.Count;
}
/// <summary>
/// Update our ZBR data
/// </summary>
/// <param name="ZBRData"></param>
public void UpdateZBRData(MM_ZeroImpedanceBridge_Data[] ZBRData)
{
MM_Element FoundElem;
foreach (MM_ZeroImpedanceBridge_Data InLine in ZBRData)
{
if (MM_Repository.TEIDs.TryGetValue(InLine.TEID_ZBR, out FoundElem) && FoundElem is MM_Line)
{
MM_Server_Interface.UpdateZBRData(InLine, (MM_Line)FoundElem, true);
}
}
if (ZBRData.Length > 0)
{
MM_Server_Interface.UpdateTimestamp(typeof(MM_ZeroImpedanceBridge_Data));
}
}
/// <summary>
/// Update our state measurement data
/// </summary>
/// <param name="StateMeasurementData"></param>
public void UpdateStateMeasurementData(MM_State_Measurement[] StateMeasurementData)
{
MM_Element FoundElem;
foreach (MM_State_Measurement InState in StateMeasurementData)
{
if (MM_Repository.TEIDs.TryGetValue(InState.TEID_Stat, out FoundElem) && FoundElem is MM_Breaker_Switch)
{
MM_Server_Interface.UpdateStateData(InState, FoundElem as MM_Breaker_Switch, true);
}
}
if (StateMeasurementData.Length > 0)
{
MM_Server_Interface.UpdateTimestamp(typeof(MM_State_Measurement));
}
}
/// <summary>
/// Update our unit gen data
/// </summary>
/// <param name="UnitGenData"></param>
public void UpdateUnitGenData(MM_Unit_Gen_Data[] UnitGenData)
{
MM_Element FoundElem;
foreach (MM_Unit_Gen_Data Unit in UnitGenData)
{
if ((MM_Repository.TEIDs.TryGetValue(Unit.TEID_UNIT, out FoundElem) && FoundElem is MM_Unit))
{
MM_Server_Interface.UpdateUnitGenData(Unit, (MM_Unit)FoundElem, true);
}
}
if (UnitGenData.Length > 0)
{
MM_Server_Interface.UpdateTimestamp(typeof(MM_Unit_Gen_Data));
}
}
/// <summary>
/// Update our line data
/// </summary>
/// <param name="LineData"></param>
public void UpdateLineData(MM_Line_Data[] LineData)
{
MM_Element FoundElem;
foreach (MM_Line_Data InLine in LineData)
{
if (MM_Repository.TEIDs.TryGetValue(InLine.TEID_Ln, out FoundElem) && FoundElem is MM_Line)
{
MM_Server_Interface.UpdateLineData(InLine, FoundElem as MM_Line, true);
}
}
if (LineData.Length > 0)
{
MM_Server_Interface.UpdateTimestamp(typeof(MM_Line_Data));
}
}
