/// <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)); } }