public override void DoubleLockDoor(string Token)
{
string operationName = "DoubleLock";
Func <DoorCapabilities, bool> capabilitiesCheck = new Func <DoorCapabilities, bool>(DC => DC.DoubleLock);
Func <DoorModeType, bool> operationForbiddenCheck =
DM => (DM == DoorModeType.LockedDown || DM == DoorModeType.LockedOpen);
DoorModeType target = DoorModeType.DoubleLocked;
string forbidType = "denied";
DoorOperation(Token, operationName, capabilitiesCheck, operationForbiddenCheck, forbidType, target);
}
void DoorOperation(string Token,
string operationName,
Func <DoorCapabilities, bool> capabilitiesCheck,
Func <DoorModeType, bool> operationAllowedCheck,
string notAllowedSeverity,
DoorModeType targetState)
{
Func <DoorModeType, DoorModeType> transition = new Func <DoorModeType, DoorModeType>(DM => targetState);
DoorOperation(Token, operationName, capabilitiesCheck, operationAllowedCheck, notAllowedSeverity, transition);
}
public override void LockOpenReleaseDoor(string Token)
{
string operationName = "LockedOpen";
Func <DoorCapabilities, bool> capabilitiesCheck = new Func <DoorCapabilities, bool>(DC => DC.LockOpen);
Func <DoorModeType, bool> operationForbiddenCheck =
DM => (DM != DoorModeType.LockedOpen);
DoorModeType target = DoorModeType.Unlocked;
string forbidSeverity = "not applicable";
DoorOperation(Token, operationName, capabilitiesCheck, operationForbiddenCheck, forbidSeverity, target);
}
/***************************************************************************************/
#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 void LockOpenDoor(string Token)
{
BeginMethod("LockOpenDoor");
string operationName = "LockOpen";
Func <DoorCapabilities, bool> capabilitiesCheck = new Func <DoorCapabilities, bool>(DC => DC.LockOpen);
Func <DoorModeType, bool> operationForbiddenCheck =
DM => (DM == DoorModeType.LockedDown);
DoorModeType target = DoorModeType.LockedOpen;
string forbidSeverity = "denied";
DoorOperation(Token, operationName, capabilitiesCheck, operationForbiddenCheck, forbidSeverity, target);
EndMethod();
}
void DoorOperation(string Token,
string operationName,
Func <DoorCapabilities, bool> capabilitiesCheck,
Func <DoorModeType, bool> operationForbiddenCheck,
string notAllowedSeverity,
Func <DoorModeType, DoorModeType> transition)
{
Log(string.Format("{0} operation requested for {1}", operationName, Token));
if (SimulatorConfiguration.PacsConfiguration.DoorStateList.ContainsKey(Token))
{
if (capabilitiesCheck(SimulatorConfiguration.PacsConfiguration.DoorCapabilitiesList[Token]))
{
DoorState doorState = SimulatorConfiguration.PacsConfiguration.DoorStateList[Token];
if (operationForbiddenCheck(doorState.DoorMode))
{
string message = String.Format("Door {0} is {1}. Operation {2}", Token,
doorState.DoorMode.ToString(), notAllowedSeverity);
Log(message);
Transport.CommonUtils.ReturnFault("Receiver", "ActionNotAllowed");
}
else
{
DoorModeType targetState = transition(doorState.DoorMode);
doorState.DoorMode = targetState;
//DoorSensorService.ProcessModeChanging(Token, targetState, ConfStorage, EventServer, StateReporter);
//EventServer.DoorModeEvent(this, "Changed", Token, doorState.DoorMode);
}
}
else
{
string message = string.Format("{0} is not supported for {1}.", operationName, Token);
Log(message);
Transport.CommonUtils.ReturnFault("Receiver", "ActionNotSupported");
}
}
else
{
string message = string.Format("Token {0} does not exist", Token);
Log(message);
Transport.CommonUtils.ReturnFault("Sender", "InvalidArg", "TokenNotFound");
}
}
public override void UnlockDoor(string Token)
{
string operationName = "Unlock";
Func <DoorCapabilities, bool> capabilitiesCheck = new Func <DoorCapabilities, bool>(DC => DC.Unlock);
Func <DoorModeType, bool> operationForbiddenCheck =
DM => (DM == DoorModeType.LockedDown || DM == DoorModeType.LockedOpen);
DoorModeType target = DoorModeType.Locked;
string forbidSeverity = "denied";
Func <DoorModeType, DoorModeType> transition =
new Func <DoorModeType, DoorModeType>(
(initial) =>
{
return(initial == DoorModeType.DoubleLocked ? DoorModeType.Locked : DoorModeType.Unlocked);
}
);
DoorOperation(Token, operationName, capabilitiesCheck, operationForbiddenCheck, forbidSeverity, transition);
}
public AccessDoorResponse AccessDoor(TestTool.Onvif.AccessDoorRequest request)
{
BeginMethod("AccessDoor");
string token = request.Token;
Log(string.Format("AccessDoor operation requested for {0}", token));
if (SimulatorConfiguration.PacsConfiguration.DoorStateList.ContainsKey(token))
{
if (SimulatorConfiguration.PacsConfiguration.DoorCapabilitiesList[token].MomentaryAccess)
{
DoorModeType doorMode = SimulatorConfiguration.PacsConfiguration.DoorStateList[token].DoorMode;
if ((doorMode == DoorModeType.Blocked) || (doorMode == DoorModeType.LockedDown) || (doorMode == DoorModeType.LockedOpen))
{
string message = "Door " + token + " is " + SimulatorConfiguration.PacsConfiguration.DoorStateList[token].DoorMode.ToString() +
". Operation denied.";
Log(message);
Transport.CommonUtils.ReturnFault("Receiver", "OperationDenied");
}
else
{
try
{
TimeSpan timeSpan = TimeSpan.Zero;
if (!string.IsNullOrEmpty(request.AccessTime))
{
timeSpan = System.Xml.XmlConvert.ToTimeSpan(request.AccessTime);
}
if (SimulatorConfiguration.PacsConfiguration.DoorStateList[token].DoorMode != DoorModeType.Accessed)
{
SimulatorConfiguration.PacsConfiguration.DoorAccessPreviousStateList[token] = SimulatorConfiguration.PacsConfiguration.DoorStateList[token].DoorMode;
}
SimulatorConfiguration.PacsConfiguration.DoorStateList[token].DoorMode = DoorModeType.Accessed;
//DoorSensorService.ProcessModeChanging(Token, DoorModeType.Accessed, ConfStorage, EventServer, StateReporter);
//EventServer.DoorModeEvent(this, "Changed", Token, SimulatorConfiguration.PacsConfiguration.DoorStateList[Token].DoorMode);
AccessToDoor func = new AccessToDoor(AccessToDoorImplementation);
SimulatorConfiguration.PacsConfiguration.DoorAccessList[token]++;
func.BeginInvoke(token, timeSpan, SimulatorConfiguration.PacsConfiguration.DoorAccessList[token], null, null);
}
catch (Exception)
{
Log(string.Format("Wrong duration ({0})", request.AccessTime));
Transport.CommonUtils.ReturnFault("Receiver", "InvalidArg");
}
}
}
else
{
string message = string.Format("MomentaryAccess isn't supported for {0}.", token);
Log(message);
Transport.CommonUtils.ReturnFault("Receiver", "ActionNotSupported");
}
}
else
{
string message = string.Format("Token {0} does not exist", token);
Log(message);
Transport.CommonUtils.ReturnFault("Receiver", "InvalidArg", "TokenNotFound");
}
EndMethod();
return(new AccessDoorResponse());
}
