/***************************************************************************************/
#region Utils
void DoorOperation(string Token,
string operationName,
Func <DoorCapabilities, bool> capabilitiesCheck,
Func <DoorMode, bool> operationForbiddenCheck,
string notAllowedSeverity,
Func <DoorMode, DoorMode> transition)
{
LoggingService.LogMessage(string.Format("{0} operation requested for {1}", operationName, Token), ExternalLogging.MessageType.Details);
ConfStorageLoad();
EventServerLoad();
if (ConfStorage.DoorStateList.ContainsKey(Token))
{
if (capabilitiesCheck(ConfStorage.DoorInfoList[Token].Capabilities))
{
DoorState doorState = ConfStorage.DoorStateList[Token];
if (operationForbiddenCheck(doorState.DoorMode))
{
string message = String.Format("Door {0} is {1}. Operation {2}", Token,
doorState.DoorMode.ToString(), notAllowedSeverity);
LoggingService.LogMessage(message, ExternalLogging.MessageType.Error);
FaultLib.ReturnFault(message, new string[] { "Sender", "ActionNotSupported" });
//throw FaultLib.GetSoapException(FaultType.General, message);
}
else
{
DoorMode targetState = transition(doorState.DoorMode);
doorState.DoorMode = targetState;
DoorSensorService.ProcessModeChanging(Token, targetState, ConfStorage, EventServer, StateReporter);
StateReporter.ReportStateUpdate(Token, doorState);
EventServer.DoorModeEvent(this, "Changed", Token, doorState.DoorMode);
}
}
else
{
string message = string.Format("{0} is not supported for {1}.", operationName, Token);
LoggingService.LogMessage(message, ExternalLogging.MessageType.Error);
FaultLib.ReturnFault(message, new string[] { "Sender", "ActionNotSupported" });
//throw FaultLib.GetSoapException(FaultType.General, message);
}
}
else
{
string message = string.Format("Token {0} does not exist", Token);
LoggingService.LogMessage(message, ExternalLogging.MessageType.Error);
FaultLib.ReturnFault(message, new string[] { "Sender", "InvalidArgVal", "NotFound" });
//throw FaultLib.GetSoapException(FaultType.General, message);
}
EventServerSave();
ConfStorageSave();
}
/***************************************************************************************/
#region Utils
void DoorOperation(string Token,
string operationName,
Func <DoorCapabilities, bool> capabilitiesCheck,
Func <DoorModeType, bool> operationForbiddenCheck,
string notAllowedSeverity,
Func <DoorModeType, DoorModeType> transition)
{
LoggingService.LogMessage(string.Format("{0} operation requested for {1}", operationName, Token), ExternalLogging.MessageType.Details);
ConfStorageLoad();
EventServerLoad();
if (ConfStorage.DoorStateList.ContainsKey(Token))
{
if (capabilitiesCheck(ConfStorage.DoorCapabilitiesList[Token]))
{
DoorState doorState = ConfStorage.DoorStateList[Token];
if (operationForbiddenCheck(doorState.DoorMode))
{
string message = String.Format("Door {0} is {1}. Operation {2}", Token,
doorState.DoorMode.ToString(), notAllowedSeverity);
LoggingService.LogMessage(message, ExternalLogging.MessageType.Error);
throw FaultLib.GetSoapException(FaultType.General,
message);
}
else
{
DoorModeType targetState = transition(doorState.DoorMode);
doorState.DoorMode = targetState;
StateReporter.ReportStateUpdate(Token, doorState);
EventServer.DoorModeEvent(this, "Changed", Token, doorState.DoorMode);
}
}
else
{
string message = string.Format("{0} is not suported for {1}.", operationName, Token);
LoggingService.LogMessage(message, ExternalLogging.MessageType.Error);
throw FaultLib.GetSoapException(FaultType.General, message);
}
}
else
{
string message = string.Format("Token {0} does not exist", Token);
LoggingService.LogMessage(message, ExternalLogging.MessageType.Error);
throw FaultLib.GetSoapException(FaultType.General, message);
}
EventServerSave();
ConfStorageSave();
}
public Task RequestAsync(String requestString, IPEndPoint remoteEndPoint)
{
return(Task.Run(() =>
{
StateReporter statusReporter = new StateReporter(++CLIENT_ID, this);
try
{
using (TcpIpClient client = new TcpIpClient(remoteEndPoint.AddressFamily, Preferences.ClientStringEncoding, Preferences.ReceiveTimeout, Preferences.SendTimeout, TcpIpClient.DEF_RECEIVE_BUFFER_SIZE))
{
statusReporter.Report("Connecting to " + remoteEndPoint + "...");
client.Connect(remoteEndPoint);
if (Preferences.ReplaceHex)
{
requestString = Utilities.ConvertAllHex(requestString, Preferences.ClientStringEncoding);
}
statusReporter.Report("Connected to " + client.RemoteEndPoint + ".");
client.Send(requestString);
statusReporter.Report("Request sent to " + client.RemoteEndPoint + ":", requestString, true);
string respsonseString;
while (true)
{
respsonseString = client.Receive();
if (respsonseString == null)
{
statusReporter.Report("The socket at " + client.RemoteEndPoint + " was shut down.");
break;
}
else
{
statusReporter.Report("Response received from " + client.RemoteEndPoint + ":", respsonseString, true);
}
}
}
}
catch (SocketException ex)
{
statusReporter.Report("Socket Error " + ex.ErrorCode + ":\n" + ex.Message);
}
statusReporter.Report("Client stopped.");
}));
}
public MainWindow()
{
InitializeComponent();
DataObject.AddPastingHandler(tbxRemoteIp, tbxRemoteIp_OnPasting);
client = new Client();
server = new Server();
clientStatusReporter = new StateReporter(client);
serverStatusReporter = new StateReporter(server);
this.Title = "TCP/IP-Proxy " + FileVersionInfo.GetVersionInfo(Assembly.GetExecutingAssembly().Location).ProductVersion;
StateReporter.setReporter(new Progress <State>(ProcessState));
Interaction.GetBehaviors(dgCommands).Add(new RemoveEmptyRowBehavior <Command>());
//commands.Add(new Command()
//{
// Request = "Marco",
// Response = "Polo"
//});
dgCommands.ItemsSource = commands;
server.CommandsList = commands;
btnToggleServer.Content = SERVER_START;
sbServerStatus.Text = SERVER_STATE_STOPPED;
checkBoxCloseConnection.IsChecked = true;
tbxRequestInterval.Value = 1000;
tbxLocalPort.Value = 8000;
//tbxRemoteIp.Text = "webservice";
//tbxRequest.Text = "GET /qs1/ HTTP/1.1\nHost: " + tbxRemoteIp.Text + "\n\n";
//tbxRemotePort.Value = 80;
//tbxRequest.Text = "Marco";
//tbxResponse.Text = "Polo";
tbxRemoteIp.Text = TcpIp.Helper.GetHostIpAsync(Dns.GetHostName()).Result.ToString();
tbxRemotePort.Value = 8000;
UpdateView();
}
private void AccessToDoorImplementation(string Token, TimeSpan AccessTime, int DoorAccessSesion)
{
if (AccessTime == TimeSpan.Zero)
{
System.Threading.Thread.Sleep(c_DefaultAccessTime);
}
else
{
System.Threading.Thread.Sleep((int)(AccessTime.TotalMilliseconds));
}
if (ConfStorage.DoorStateList[Token].DoorMode == DoorMode.Accessed)
{
if (DoorAccessSesion == ConfStorage.DoorAccessList[Token])
{
ConfStorage.DoorStateList[Token].DoorMode = ConfStorage.DoorAccessPreviousStateList[Token];
DoorSensorService.ProcessModeChanging(Token, ConfStorage.DoorStateList[Token].DoorMode, ConfStorage, EventServer, StateReporter);
StateReporter.ReportStateUpdate(Token, ConfStorage.DoorStateList[Token]);
EventServer.DoorModeEvent(this, "Changed", Token, ConfStorage.DoorStateList[Token].DoorMode);
}
}
}
public override void AccessDoor(string Token, bool UseExtendedTime, [System.Xml.Serialization.XmlIgnoreAttribute()] bool UseExtendedTimeSpecified, [System.Xml.Serialization.XmlElementAttribute(DataType = "duration")] string AccessTime, [System.Xml.Serialization.XmlElementAttribute(DataType = "duration")] string OpenTooLongTime, [System.Xml.Serialization.XmlElementAttribute(DataType = "duration")] string PreAlarmTime, AccessDoorExtension Extension)
{
ConfStorageLoad();
EventServerLoad();
LoggingService.LogMessage(string.Format("AccessDoor operation requested for {0}", Token),
ExternalLogging.MessageType.Details);
if (ConfStorage.DoorStateList.ContainsKey(Token))
{
if (ConfStorage.DoorInfoList[Token].Capabilities.AccessSpecified && ConfStorage.DoorInfoList[Token].Capabilities.Access)
{
if ((ConfStorage.DoorStateList[Token].DoorMode == DoorMode.Blocked) || (ConfStorage.DoorStateList[Token].DoorMode == DoorMode.LockedDown) || (ConfStorage.DoorStateList[Token].DoorMode == DoorMode.LockedOpen))
{
string message = "Door " + Token + " is " + ConfStorage.DoorStateList[Token].DoorMode.ToString() +
". Operation denied.";
LoggingService.LogMessage(message, ExternalLogging.MessageType.Error);
FaultLib.ReturnFault(message, new string[] { "Sender", "ActionNotSupported" });
//throw FaultLib.GetSoapException(FaultType.General, message);
}
else
{
try
{
TimeSpan timeSpan = TimeSpan.Zero;
if (!string.IsNullOrEmpty(AccessTime))
{
timeSpan = System.Xml.XmlConvert.ToTimeSpan(AccessTime);
}
if (ConfStorage.DoorStateList[Token].DoorMode != DoorMode.Accessed)
{
ConfStorage.DoorAccessPreviousStateList[Token] = ConfStorage.DoorStateList[Token].DoorMode;
}
ConfStorage.DoorStateList[Token].DoorMode = DoorMode.Accessed;
StateReporter.ReportStateUpdate(Token, ConfStorage.DoorStateList[Token]);
DoorSensorService.ProcessModeChanging(Token, DoorMode.Accessed, ConfStorage, EventServer, StateReporter);
EventServer.DoorModeEvent(this, "Changed", Token, ConfStorage.DoorStateList[Token].DoorMode);
AccessToDoor func = new AccessToDoor(AccessToDoorImplementation);
ConfStorage.DoorAccessList[Token]++;
func.BeginInvoke(Token, timeSpan, ConfStorage.DoorAccessList[Token], null, null);
}
catch (Exception)
{
string message = string.Format("Wrong duration ({0})", AccessTime);
LoggingService.LogMessage(message, ExternalLogging.MessageType.Error);
FaultLib.ReturnFault(message, new string[] { "Sender", "InvalidArgVal" });
//throw FaultLib.GetSoapException(FaultType.General, "Wrong duration.");
}
}
}
else
{
string message = string.Format("MomentaryAccess isn't supported for {0}.", Token);
LoggingService.LogMessage(message, ExternalLogging.MessageType.Error);
FaultLib.ReturnFault(message, new string[] { "Sender", "ActionNotSupported" });
//throw FaultLib.GetSoapException(FaultType.General, message);
}
}
else
{
string message = string.Format("Token {0} does not exist", Token);
LoggingService.LogMessage(message, ExternalLogging.MessageType.Error);
FaultLib.ReturnFault(message, new string[] { "Sender", "InvalidArgVal", "NotFound" });
//throw FaultLib.GetSoapException(FaultType.General, message);
}
EventServerSave();
ConfStorageSave();
}
public Server()
{
stateReporter = new StateReporter(this);
}
public void SignalReceived(string deviceToken, string deviceType, string sensor, string value)
{
ConfStorageLoad();
LoggingService.LogMessage(string.Format("Signal received: token={0}, deviceType={1} sensor={2}, value={3}", deviceToken, deviceType, sensor, value), ExternalLogging.MessageType.Details);
if (deviceType == "Door")
{
DoorState doorState = null;
if (ConfStorage.DoorStateList.ContainsKey(deviceToken))
{
doorState = ConfStorage.DoorStateList[deviceToken];
}
switch (sensor)
{
case "Alarm":
{
DoorAlarmState state = (DoorAlarmState)Enum.Parse(typeof(DoorAlarmState), value);
if (doorState != null)
{
doorState.Alarm = state;
EventServer.DoorAlarmMonitorEvent(null, "Changed", deviceToken, state);
}
}
break;
case "LockPhysicalState":
{
LockPhysicalState state =
(LockPhysicalState)Enum.Parse(typeof(LockPhysicalState), value);
if (doorState != null)
{
doorState.LockPhysicalState = state;
EventServer.LockPhysicalStateEvent(null, "Changed", deviceToken, state);
}
}
break;
case "DoubleLockPhysicalState":
{
LockPhysicalState state =
(LockPhysicalState)Enum.Parse(typeof(LockPhysicalState), value);
if (doorState != null)
{
doorState.DoubleLockPhysicalState = state;
EventServer.DoubleLockPhysicalStateEvent(null, "Changed", deviceToken, state);
}
}
break;
case "DoorPhysicalState":
{
DoorPhysicalState state =
(DoorPhysicalState)Enum.Parse(typeof(DoorPhysicalState), value);
if (doorState != null)
{
doorState.DoorPhysicalState = state;
EventServer.DoorPhysicalStateEvent(null, "Changed", deviceToken, state);
}
}
break;
case "Tamper":
{
DoorTamperState state =
(DoorTamperState)Enum.Parse(typeof(DoorTamperState), value);
if ((doorState != null) && (doorState.Tamper != null))
{
doorState.Tamper.State = state;
EventServer.DoorTamperMonitorEvent(null, "Changed", deviceToken, state);
}
}
break;
case "Fault":
{
DoorFaultState state =
(DoorFaultState)Enum.Parse(typeof(DoorFaultState), value);
if ((doorState != null) && (doorState.Fault != null))
{
doorState.Fault.State = state;
EventServer.DoorFaultEvent(null, "Changed", deviceToken, state);
}
}
break;
}
StateReporter.ReportStateUpdate(deviceToken, doorState);
}
if (deviceType == "Credential")
{
CredentialState credentialState = null;
if (ConfStorage.CredentialStateList.ContainsKey(deviceToken))
{
credentialState = ConfStorage.CredentialStateList[deviceToken];
}
switch (sensor)
{
case "AntipassbackViolated":
{
bool state = (value == "True");
if (credentialState != null)
{
credentialState.AntipassbackState.AntipassbackViolated = state;
//TODO: event
}
}
break;
}
}
}
public void Unsubscribe(Guid receiver)
{
StateReporter.Unsubscribe(receiver);
}
public Guid Subscribe(string receiver)
{
return(StateReporter.Subscribe(receiver));
}
