public DeviceExecutableCommandViewModel(GKDevice device, GKStateBit stateType)
{
ExecuteControlCommand = new RelayCommand(OnExecuteControl);
Device = device;
StateBit = stateType;
Name = ((GKStateBit)stateType).ToDescription();
if (Device.DriverType == GKDriverType.RSR2_Valve_DU || Device.DriverType == GKDriverType.RSR2_Valve_KV || Device.DriverType == GKDriverType.RSR2_Valve_KVMV)
{
switch (stateType)
{
case GKStateBit.TurnOn_InManual:
Name = "Открыть";
break;
case GKStateBit.TurnOnNow_InManual:
Name = "Открыть немедленно";
break;
case GKStateBit.TurnOff_InManual:
Name = "Закрыть";
break;
case GKStateBit.Stop_InManual:
Name = "Остановить";
break;
}
}
}
/* RG-890 (Включение табличек "Не входи", "Уходи", и "Сирена", если МПТ включается без задержки на включение)*/
public void TestMptBoardsOnWhenMptTurnOnWithoutDelay(GKStateBit mode, int delay)
{
var device1 = AddDevice(kauDevice11, GKDriverType.RSR2_RM_1);
var device2 = AddDevice(kauDevice11, GKDriverType.RSR2_RM_1);
var device3 = AddDevice(kauDevice11, GKDriverType.RSR2_RM_1);
var mpt = new GKMPT {Name = "МПТ", No = 1, Delay = delay};
var clause = new GKClause
{
ClauseOperationType = ClauseOperationType.AllDevices,
StateType = GKStateBit.Failure,
DeviceUIDs = { kauDevice11.UID }
};
mpt.MptLogic.OnClausesGroup.Clauses.Add(clause);
mpt.MPTDevices.Add(new GKMPTDevice { MPTDeviceType = GKMPTDeviceType.DoNotEnterBoard, DeviceUID = device1.UID });
mpt.MPTDevices.Add(new GKMPTDevice { MPTDeviceType = GKMPTDeviceType.ExitBoard, DeviceUID = device2.UID });
mpt.MPTDevices.Add(new GKMPTDevice { MPTDeviceType = GKMPTDeviceType.Speaker, DeviceUID = device3.UID });
GKManager.AddMPT(mpt);
SetConfigAndRestartImitator();
WaitWhileState(mpt, XStateClass.Off, 10000, "Ждем Норму в МПТ");
Assert.IsTrue(mpt.State.StateClass == XStateClass.Off, "Проверка того, что МПТ Выключен");
ConrtolGKBase(mpt, mode, "Включаем МПТ");
WaitWhileState(mpt, XStateClass.On, 3000, "Ждем Включено в МПТ");
Assert.IsTrue(mpt.State.StateClass == XStateClass.On, "Проверка того, что МПТ Включен");
Assert.IsTrue(device1.State.StateClass == XStateClass.On, "Проверка того, что Табличка Не Входи Включена");
Assert.IsTrue(device2.State.StateClass == XStateClass.On, "Проверка того, что Табличка Уходи Включена");
Assert.IsTrue(device3.State.StateClass == XStateClass.On, "Проверка того, что Сирена Включена");
CheckJournal(5, JournalItem(mpt, JournalEventNameType.Включено), JournalItem(device1, JournalEventNameType.Включено),
JournalItem(device2, JournalEventNameType.Включено), JournalItem(device3, JournalEventNameType.Включено),
JournalItem(Led("Устройство Включение ПУСК "), JournalEventNameType.Включено));
}
void SetRegime(GKMPTDeviceType deviceType, GKStateBit stateBit)
{
var count = 0;
foreach (var mptDevice in MPT.MPTDevices.Where(x => x.MPTDeviceType == deviceType && x.Device != null))
{
if (mptDevice.Device.Driver.IsCardReaderOrCodeReader)
{
if (mptDevice.CodeReaderSettings.MPTSettings.CanBeUsed)
{
FormulaHelper.AddCodeReaderLogic(Formula, mptDevice.CodeReaderSettings.MPTSettings, mptDevice.Device);
if (count > 0)
Formula.Add(FormulaOperationType.OR);
count++;
}
}
else
{
Formula.AddGetBit(GKStateBit.Fire1, mptDevice.Device);
if (count > 0)
Formula.Add(FormulaOperationType.OR);
count++;
}
}
if (count > 0)
{
Formula.Add(FormulaOperationType.BR, 1, 3);
Formula.Add(FormulaOperationType.CONST, 0, 1);
Formula.AddPutBit(stateBit, MPT);
Formula.Add(FormulaOperationType.EXIT);
}
}
public void ControlGKDevice(Guid clientUID, Guid deviceUid, GKStateBit command)
{
SafeOperationCall(() =>
{
var rubezhService = RubezhServiceFactory.Create(TimeSpan.FromMinutes(10));
using (rubezhService as IDisposable)
rubezhService.ControlGKDevice(clientUID, deviceUid, command);
}, "ControlGKDevice");
}
public bool GetStateBit(GKStateBit stateBit)
{
var stateBitViewModel = StateBits.FirstOrDefault(x => x.StateBit == stateBit);
if (stateBitViewModel != null)
{
return stateBitViewModel.IsActive;
}
return false;
}
public JsonResult OnExecuteCommand(GKStateBit commandName, Guid UID)
{
var device = GKManager.Devices.FirstOrDefault(dev => dev.UID == UID);
if (device != null)
{
ClientManager.RubezhService.GKExecuteDeviceCommand(device, commandName, ClientManager.CurrentUser.Name);
}
return new JsonResult();
}
public OperationResult<bool> ConrtolGKBase(Guid uid, GKStateBit command, bool isPim)
{
DescriptorViewModel descriptor;
if (isPim)
descriptor = MainViewModel.Current.Descriptors.FirstOrDefault(x => (x.GKBase is GKPim) && (x.GKBase as GKPim).DeviceUid == uid);
else
descriptor = MainViewModel.Current.Descriptors.FirstOrDefault(x => x.GKBase.UID == uid);
if (descriptor == null)
return OperationResult<bool>.FromError("Не найден элемент " + uid + " в конфигурации");
if (!ValidateCommand(descriptor, command))
return OperationResult<bool>.FromError("Команда " + command.ToDescription() + " для типа " + descriptor.GKBase.GetType() + " запрещена");
switch (command)
{
case GKStateBit.Fire1:
descriptor.SetFire1Command.Execute();
break;
case GKStateBit.Fire2:
descriptor.SetFire2Command.Execute();
break;
case GKStateBit.Reset:
descriptor.ResetFireCommand.Execute();
break;
case GKStateBit.TurnOn_InAutomatic:
descriptor.TurnOnCommand.Execute();
break;
case GKStateBit.TurnOnNow_InAutomatic:
descriptor.TurnOnNowCommand.Execute();
break;
case GKStateBit.TurnOff_InAutomatic:
descriptor.TurnOffCommand.Execute();
break;
case GKStateBit.TurnOffNow_InAutomatic:
descriptor.TurnOffNowCommand.Execute();
break;
case GKStateBit.SetRegime_Manual:
descriptor.TurnOffCommand.Execute();
break;
case GKStateBit.TurnOn_InManual:
descriptor.TurnOffCommand.Execute();
break;
case GKStateBit.TurnOnNow_InManual:
descriptor.TurnOffCommand.Execute();
break;
case GKStateBit.TurnOff_InManual:
descriptor.TurnOffCommand.Execute();
break;
case GKStateBit.TurnOffNow_InManual:
descriptor.TurnOffCommand.Execute();
break;
default:
return OperationResult<bool>.FromError("Команда " + command.ToDescription() + " ещё не реализована");
}
return new OperationResult<bool>(true);
}
void AddGuardDevicesLogic(IEnumerable<GKGuardZoneDevice> guardDevices, GKStateBit commandStateBit)
{
int count = DescriptorHelper.AddCodeReadersLogic(guardDevices, Formula, commandStateBit);
switch (commandStateBit)
{
case GKStateBit.Fire1:
if (count > 0)
{
if (ChangeGuardDevices.Count > 0)
Formula.AddGetBit(GKStateBit.On, GuardZone.Pim);
else
Formula.AddGetBit(GKStateBit.Attention, GuardZone);
Formula.Add(FormulaOperationType.OR);
Formula.AddPutBit(GKStateBit.Fire1, GuardZone.ChangePim);
}
break;
case GKStateBit.TurnOnNow_InAutomatic:
case GKStateBit.TurnOffNow_InAutomatic:
if (count > 0 || ChangeGuardDevices.Count > 0)
{
if (ChangeGuardDevices.Count > 0)
{
if (ChangeGuardDevices.Count > 0)
{
DescriptorHelper.AddChangeLogic(ChangeGuardDevices, Formula);
if (commandStateBit == GKStateBit.TurnOnNow_InAutomatic)
{
Formula.AddGetBit(GKStateBit.Off, GuardZone);
Formula.Add(FormulaOperationType.AND);
}
if (commandStateBit == GKStateBit.TurnOffNow_InAutomatic)
{
Formula.AddGetBit(GKStateBit.On, GuardZone);
Formula.Add(FormulaOperationType.AND);
}
}
if (count > 0 && ChangeGuardDevices.Count > 0)
{
Formula.Add(FormulaOperationType.OR);
}
}
Formula.Add(FormulaOperationType.BR, 1, 3);
Formula.Add(FormulaOperationType.CONST, 0, 1);
Formula.AddPutBit(commandStateBit, GuardZone.ChangePim);
Formula.Add(FormulaOperationType.EXIT);
}
break;
}
}
public bool SetStateBit(GKStateBit stateBit, bool value, ImitatorJournalItem additionalJournalItem = null)
{
var stateBitViewModel = StateBits.FirstOrDefault(x => x.StateBit == stateBit);
if (stateBitViewModel != null)
{
if (stateBitViewModel.IsActive != value)
{
stateBitViewModel.IsActive = value;
OnStateBitChanged(stateBit, value, additionalJournalItem);
NotifyIndicators(stateBit, value);
return true;
}
}
return false;
}
void NotifyIndicators(GKStateBit stateBit, bool value)
{
var fireZoneCondition = GKBase is GKZone && (stateBit == GKStateBit.Attention || stateBit == GKStateBit.Fire1 || stateBit == GKStateBit.Fire2);
var manualCondition = HasManualRegime && stateBit == GKStateBit.Norm;
var ignoreCondition = HasIgnoreRegime && stateBit == GKStateBit.Ignore;
if (GKBase is GKMPT || GKBase is GKPumpStation || GKBase is GKDirection)
{
if (stateBit == GKStateBit.On || stateBit == GKStateBit.TurningOn && (value || TurningState == TurningState.Paused))
OnStateChanged(GKStateBit.Reserve1, value, GKBase.UID);
OnStateChanged(GKStateBit.Reserve2, TurningState == TurningState.Paused, GKBase.UID);
}
if (fireZoneCondition || manualCondition || ignoreCondition || stateBit == GKStateBit.Failure)
{
if (OnStateChanged != null)
OnStateChanged(stateBit, value, GKBase.UID);
}
}
public static int AddCodeReadersLogic(IEnumerable<GKGuardZoneDevice> guardDevices, FormulaBuilder Formula, GKStateBit commandStateBit)
{
var count = 0;
foreach (var guardDevice in guardDevices)
{
if (commandStateBit == GKStateBit.TurnOnNow_InAutomatic || commandStateBit == GKStateBit.TurnOn_InAutomatic)
FormulaHelper.AddCodeReaderLogic(Formula, guardDevice.CodeReaderSettings.SetGuardSettings, guardDevice.Device);
if (commandStateBit == GKStateBit.TurnOffNow_InAutomatic || commandStateBit == GKStateBit.TurnOff_InAutomatic)
FormulaHelper.AddCodeReaderLogic(Formula, guardDevice.CodeReaderSettings.ResetGuardSettings, guardDevice.Device);
if (commandStateBit == GKStateBit.Fire1)
FormulaHelper.AddCodeReaderLogic(Formula, guardDevice.CodeReaderSettings.AlarmSettings, guardDevice.Device);
if (count > 0)
{
Formula.Add(FormulaOperationType.OR);
}
count++;
}
return count;
}
public void ClientCommand(GKStateBit stateBit)
{
switch (stateBit)
{
case GKStateBit.SetRegime_Automatic:
OnSetAutomaticRegime();
CommandManager.InvalidateRequerySuggested();
break;
case GKStateBit.SetRegime_Manual:
OnSetManualRegime();
CommandManager.InvalidateRequerySuggested();
break;
case GKStateBit.SetRegime_Off:
OnSetIgnoreRegime();
CommandManager.InvalidateRequerySuggested();
break;
case GKStateBit.TurnOn_InManual:
if (Regime == Regime.Manual)
OnTurnOn();
break;
case GKStateBit.TurnOnNow_InManual:
if (Regime == Regime.Manual)
OnTurnOnNow();
break;
case GKStateBit.TurnOff_InManual:
if (Regime == Regime.Manual)
OnTurnOff();
break;
case GKStateBit.TurnOffNow_InManual:
if (Regime == Regime.Manual)
OnTurnOffNow();
break;
case GKStateBit.TurnOn_InAutomatic:
if (Regime == Regime.Automatic)
OnTurnOn();
break;
case GKStateBit.TurnOnNow_InAutomatic:
if (Regime == Regime.Automatic)
OnTurnOnNow();
break;
case GKStateBit.TurnOff_InAutomatic:
if (Regime == Regime.Automatic)
OnTurnOff();
break;
case GKStateBit.TurnOffNow_InAutomatic:
if (Regime == Regime.Automatic)
OnTurnOffNow();
break;
case GKStateBit.Stop_InManual:
if (Regime == Regime.Manual)
OnPauseTurnOn();
break;
case GKStateBit.Fire1:
case GKStateBit.Fire2:
case GKStateBit.Reset:
OnResetFire();
break;
}
}
void OnStateBitChanged(GKStateBit stateBit, bool isActive, ImitatorJournalItem additionalJournalItem = null)
{
ImitatorJournalItem journalItem = null;
if (stateBit == GKStateBit.Failure)
{
journalItem = new ImitatorJournalItem(2, 6, (byte)(isActive ? 1 : 0), (byte)(isActive ? 1 : 0));
AddJournalItem(additionalJournalItem ?? journalItem);
}
else if (stateBit == GKStateBit.Test)
{
journalItem = new ImitatorJournalItem(2, 5, 255, (byte)(isActive ? 1 : 0));
AddJournalItem(additionalJournalItem ?? journalItem);
}
else if (isActive)
{
if (stateBit != GKStateBit.Norm)
{
CurrentOnDelay = 0;
CurrentOffDelay = 0;
CurrentHoldDelay = 0;
TurningState = TurningState.None;
}
if (stateBit == GKStateBit.On)
{
journalItem = new ImitatorJournalItem(2, 9, 2, 0);
if (HoldDelay != 0 && !(GKBase is GKDoor && Regime == Regime.Manual))
{
CurrentHoldDelay = HoldDelay;
TurningState = TurningState.Holding;
}
}
if (stateBit == GKStateBit.TurningOn)
{
journalItem = new ImitatorJournalItem(2, 9, 4, 0);
if (OnDelay != 0)
{
CurrentOnDelay = OnDelay;
TurningState = TurningState.TurningOn;
}
}
if (stateBit == GKStateBit.TurningOff)
{
journalItem = new ImitatorJournalItem(2, 9, 5, 0);
if (OffDelay != 0)
{
CurrentOffDelay = OffDelay;
TurningState = TurningState.TurningOff;
SetStateBit(GKStateBit.Fire1, false);
SetStateBit(GKStateBit.Fire2, false);
}
}
if (stateBit == GKStateBit.Off)
{
AdditionalShortParameters[0] = 0;
AdditionalShortParameters[1] = 0;
AdditionalShortParameters[2] = 0;
journalItem = new ImitatorJournalItem(2, 9, 3, 3);
SetStateBit(GKStateBit.Attention, false);
SetStateBit(GKStateBit.Fire1, false);
SetStateBit(GKStateBit.Fire2, false);
}
if (stateBit == GKStateBit.Norm)
{
journalItem = new ImitatorJournalItem(2, 14, 0, 0);
}
if (stateBit == GKStateBit.Fire1)
{
journalItem = new ImitatorJournalItem(2, 2, 0, 0);
}
if (stateBit == GKStateBit.Fire2)
{
journalItem = new ImitatorJournalItem(2, 3, 0, 0);
}
if (stateBit == GKStateBit.Ignore)
{
journalItem = new ImitatorJournalItem(2, 10, 2, 0);
}
if (stateBit == GKStateBit.Attention)
{
journalItem = new ImitatorJournalItem(2, 4, 0, 0);
}
AddJournalItem(additionalJournalItem ?? journalItem);
}
if (additionalJournalItem != null || journalItem != null)
RecalculateOutputLogic();
}
public StateTypeViewModel(ClauseOperationType clauseOperationType, GKStateBit stateBit)
{
StateBit = stateBit;
Name = GKClause.ClauseToString(clauseOperationType, stateBit);
}
public void ControlGKDevice(Guid deviceUid, GKStateBit command)
{
ControlGKDevice(RubezhServiceFactory.UID, deviceUid, command);
}
public void GKExecuteDeviceCommand(GKDevice device, GKStateBit stateBit, string userName = null)
{
SafeOperationCall(() =>
{
var rubezhService = RubezhServiceFactory.Create(TimeSpan.FromMinutes(10));
using (rubezhService as IDisposable)
rubezhService.GKExecuteDeviceCommand(RubezhServiceFactory.UID, device.UID, stateBit,userName);
}, "GKExecuteDeviceCommand");
}
public OperationResult<bool> ConrtolGKBase(Guid uid, GKStateBit command, bool isPim = false)
{
var imitatorService = ImitatorServiceFactory.Create();
return imitatorService.ConrtolGKBase(uid, command, isPim);
}
public static void SendControlCommand(GKBase gkBase, GKStateBit stateBit, string description)
{
var code = 0x80 + (int)stateBit;
SendControlCommand(gkBase, (byte)code, description);
}
public StateBitViewModel(DescriptorViewModel descriptorViewModel, GKStateBit stateBit, bool isActive = false)
{
DescriptorViewModel = descriptorViewModel;
StateBit = stateBit;
_isActive = isActive;
}
bool CanDo(GKStateBit stateBit)
{
var onState = StateBits.FirstOrDefault(x => x.StateBit == GKStateBit.On);
var turningOnState = StateBits.FirstOrDefault(x => x.StateBit == GKStateBit.TurningOn);
var offState = StateBits.FirstOrDefault(x => x.StateBit == GKStateBit.Off);
var turningOffState = StateBits.FirstOrDefault(x => x.StateBit == GKStateBit.TurningOff);
var fire1State = StateBits.FirstOrDefault(x => x.StateBit == GKStateBit.Fire1);
var fire2State = StateBits.FirstOrDefault(x => x.StateBit == GKStateBit.Fire2);
if (stateBit == GKStateBit.TurnOn_InManual)
return onState != null && !onState.IsActive && (turningOnState == null || !turningOnState.IsActive);
if (stateBit == GKStateBit.TurnOnNow_InManual)
return onState != null && !onState.IsActive;
if (stateBit == GKStateBit.TurnOff_InManual)
return offState != null && !offState.IsActive && (turningOffState == null || !turningOffState.IsActive);
if (stateBit == GKStateBit.TurnOffNow_InManual)
return offState != null && !offState.IsActive;
if (stateBit == GKStateBit.Fire1)
return fire1State != null && !fire1State.IsActive;
if (stateBit == GKStateBit.Fire2)
return fire2State != null && !fire2State.IsActive;
return false;
}
void ChangeIndicatorStates(DescriptorViewModel indicator, GKStateBit stateBit)
{
if (activeStateBits.Any(x => x.Item2 == stateBit))
{
if (indicator.GetStateBit(GKStateBit.Off))
indicator.TurnOnNowCommand.Execute();
}
else
{
if (indicator.GetStateBit(GKStateBit.On))
indicator.TurnOffNowCommand.Execute();
}
}
public static void GKExecuteDeviceCommand(GKDevice device, GKStateBit stateBit, string userName)
{
Watcher.SendControlCommand(device, stateBit, stateBit.ToDescription());
AddGKMessage(JournalEventNameType.Команда_оператора, JournalEventDescriptionType.NULL, stateBit.ToDescription(), device, userName);
}
void AddGuardDevicesLogic(IEnumerable<GKDevice> devices, GKStateBit commandStateBit)
{
var count = DescriptorHelper.AddFireOrFailureLogic(devices, Formula);
switch (commandStateBit)
{
case GKStateBit.Fire1:
if (count > 0 || SetAlarmPimDevices.Any())
{
if (UsePim)
Formula.AddGetBit(GKStateBit.TurningOn, GuardZone.Pim);
else
Formula.AddGetBit(GKStateBit.Attention, GuardZone);
if (count > 0)
Formula.Add(FormulaOperationType.OR);
if (SetAlarmPimDevices.Any())
{
Formula.AddGetBit(GKStateBit.Fire1, GuardZone.ChangePim);
int count2 = DescriptorHelper.AddCodeReadersLogic(SetAlarmPimDevices, Formula, commandStateBit);
if (count2 > 0)
Formula.Add(FormulaOperationType.AND);
Formula.Add(FormulaOperationType.OR);
}
Formula.AddPutBit(GKStateBit.Attention, GuardZone);
}
break;
case GKStateBit.TurnOn_InAutomatic:
case GKStateBit.TurnOff_InAutomatic:
var useChangePimLogic = ChangeGuardPimDevices.Count > 0
|| (commandStateBit == GKStateBit.TurnOn_InAutomatic && SetGuardPimDevices.Any())
|| (commandStateBit == GKStateBit.TurnOff_InAutomatic && ResetGuardPimDevices.Any());
if (count > 0 || useChangePimLogic)
{
if (useChangePimLogic)
{
DescriptorHelper.AddChangeLogic(ChangeGuardPimDevices, Formula);
int count2 = 0;
if (commandStateBit == GKStateBit.TurnOn_InAutomatic)
{
count2 = DescriptorHelper.AddCodeReadersLogic(SetGuardPimDevices, Formula, commandStateBit);
if (ChangeGuardPimDevices.Count > 0 && count2 > 0)
Formula.Add(FormulaOperationType.OR);
Formula.AddGetBit(GKStateBit.On, GuardZone.ChangePim);
}
else
{
count2 = DescriptorHelper.AddCodeReadersLogic(ResetGuardPimDevices, Formula, commandStateBit);
if (ChangeGuardPimDevices.Count > 0 && count2 > 0)
Formula.Add(FormulaOperationType.OR);
Formula.AddGetBit(GKStateBit.Off, GuardZone.ChangePim);
}
Formula.Add(FormulaOperationType.AND);
if (count > 0)
Formula.Add(FormulaOperationType.OR);
}
if (commandStateBit == GKStateBit.TurnOn_InAutomatic)
AddMissedLogic();
Formula.Add(FormulaOperationType.BR, 1, 3);
Formula.Add(FormulaOperationType.CONST, 0, 1);
Formula.AddPutBit(commandStateBit, GuardZone);
Formula.Add(FormulaOperationType.EXIT);
}
break;
}
}
bool ValidateCommand(DescriptorViewModel descriptor, GKStateBit command)
{
var availableCommands = new List<GKStateBit>();
if (descriptor.HasAutomaticRegime)
availableCommands.Add(GKStateBit.SetRegime_Automatic);
if (descriptor.HasManualRegime)
availableCommands.Add(GKStateBit.SetRegime_Manual);
if (descriptor.HasIgnoreRegime)
availableCommands.Add(GKStateBit.Ignore);
if (descriptor.HasReset || descriptor.HasResetFire)
availableCommands.Add(GKStateBit.Reset);
if (descriptor.HasSetFireHandDetector || descriptor.HasFire12)
availableCommands.Add(GKStateBit.Fire2);
if (descriptor.HasSetFireSmoke || descriptor.HasSetFireTemperature || descriptor.HasSetFireTemperatureGradient || descriptor.HasFire12 || descriptor.HasFire1)
availableCommands.Add(GKStateBit.Fire1);
if (descriptor.HasTest)
availableCommands.Add(GKStateBit.Test);
if (descriptor.HasTurnOn)
{
availableCommands.Add(GKStateBit.TurnOn_InManual);
availableCommands.Add(GKStateBit.TurnOn_InAutomatic);
}
if (descriptor.HasTurnOnNow)
{
availableCommands.Add(GKStateBit.TurnOnNow_InManual);
availableCommands.Add(GKStateBit.TurnOnNow_InAutomatic);
}
if (descriptor.HasTurnOff)
{
availableCommands.Add(GKStateBit.TurnOff_InManual);
availableCommands.Add(GKStateBit.TurnOff_InAutomatic);
}
if (descriptor.HasTurnOffNow)
{
availableCommands.Add(GKStateBit.TurnOffNow_InManual);
availableCommands.Add(GKStateBit.TurnOffNow_InAutomatic);
}
if (descriptor.HasAlarm)
availableCommands.Add(GKStateBit.Fire1);
return availableCommands.Contains(command);
}
void InitIndicatorsStates(GKStateBit stateBit, bool value, Guid objectUid)
{
if (stateBit == GKStateBit.Norm)
value = !value;
var activeStateBit = activeStateBits.FirstOrDefault(x => x.Item1 == objectUid && x.Item2 == stateBit);
if (activeStateBit == null && value)
activeStateBits.Add(new Tuple<Guid, GKStateBit>(objectUid, stateBit));
else if (!value)
activeStateBits.RemoveAll(x => x.Item1 == objectUid && x.Item2 == stateBit);
ChangeIndicatorStates(failureIndicator, GKStateBit.Failure);
ChangeIndicatorStates(fire1Indicator, GKStateBit.Fire1);
ChangeIndicatorStates(fire2Indicator, GKStateBit.Fire2);
ChangeIndicatorStates(attentionIndicator, GKStateBit.Attention);
ChangeIndicatorStates(startIndicator, GKStateBit.Reserve1);
ChangeIndicatorStates(ignoreIndicator, GKStateBit.Ignore);
ChangeIndicatorStates(manualIndicator, GKStateBit.Norm);
ChangeIndicatorStates(suspendIndicator, GKStateBit.Reserve2);
}
void AddStateBit(GKStateBit stateBit, bool isActive = false)
{
if(StateBits.All(x => x.StateBit != stateBit))
StateBits.Add(new StateBitViewModel(this, stateBit, isActive));
}
public static string ClauseToString(ClauseOperationType clauseOperationType, GKStateBit stateBit)
{
switch (clauseOperationType)
{
case ClauseOperationType.AllZones:
case ClauseOperationType.AnyZone:
switch (stateBit)
{
case GKStateBit.Fire1:
return "Пожар 1";
case GKStateBit.Fire2:
return "Пожар 2";
case GKStateBit.Attention:
return "Внимание";
}
break;
case ClauseOperationType.AllGuardZones:
case ClauseOperationType.AnyGuardZone:
switch (stateBit)
{
case GKStateBit.On:
return "На охране";
case GKStateBit.Off:
return "Не на охране";
case GKStateBit.Fire1:
return "Тревога";
}
break;
case ClauseOperationType.AllDoors:
case ClauseOperationType.AnyDoor:
switch (stateBit)
{
case GKStateBit.Fire1:
return "Тревога";
}
break;
}
return stateBit.ToDescription();
}
public static void AddAvailableStateBits(GKDriver driver, GKStateBit stateType)
{
if (driver.AvailableStateBits.Count == 0)
{
driver.AvailableStateBits.Add(GKStateBit.Norm);
driver.AvailableStateBits.Add(GKStateBit.Failure);
driver.AvailableStateBits.Add(GKStateBit.Ignore);
}
driver.AvailableStateBits.Add(stateType);
}
CommandType XStateBitToCommandType(GKStateBit stateString)
{
if (GKDeviceArgument.ExplicitValue.Device != null)
{
switch (stateString)
{
case GKStateBit.SetRegime_Automatic:
return CommandType.SetRegime_Automatic;
case GKStateBit.SetRegime_Manual:
return CommandType.SetRegime_Manual;
case GKStateBit.SetRegime_Off:
return CommandType.SetRegime_Off;
case GKStateBit.TurnOn_InManual:
return CommandType.TurnOn_InManual;
case GKStateBit.TurnOnNow_InManual:
return CommandType.TurnOnNow_InManual;
case GKStateBit.TurnOff_InManual:
return CommandType.TurnOff_InManual;
case GKStateBit.Stop_InManual:
return CommandType.Stop_InManual;
case GKStateBit.Reset:
return CommandType.Reset;
case GKStateBit.ForbidStart_InManual:
return CommandType.ForbidStart_InManual;
case GKStateBit.TurnOffNow_InManual:
return CommandType.TurnOffNow_InManual;
case GKStateBit.TurnOn_InAutomatic:
return CommandType.TurnOn_InAutomatic;
case GKStateBit.TurnOnNow_InAutomatic:
return CommandType.TurnOnNow_InAutomatic;
case GKStateBit.TurnOff_InAutomatic:
return CommandType.TurnOff_InAutomatic;
case GKStateBit.TurnOffNow_InAutomatic:
return CommandType.TurnOffNow_InAutomatic;
default:
return CommandType.Unknown;
}
}
switch (stateString)
{
case GKStateBit.SetRegime_Automatic:
return CommandType.SetRegime_Automatic;
case GKStateBit.SetRegime_Manual:
return CommandType.SetRegime_Manual;
case GKStateBit.SetRegime_Off:
return CommandType.SetRegime_Off;
case GKStateBit.TurnOn_InManual:
return CommandType.TurnOn_InManual;
case GKStateBit.TurnOnNow_InManual:
return CommandType.TurnOnNow_InManual;
case GKStateBit.TurnOff_InManual:
return CommandType.TurnOff_InManual;
case GKStateBit.Stop_InManual:
return CommandType.Stop_InManual;
case GKStateBit.Reset:
return CommandType.Reset;
case GKStateBit.ForbidStart_InManual:
return CommandType.ForbidStart_InManual;
case GKStateBit.TurnOffNow_InManual:
return CommandType.TurnOffNow_InManual;
case GKStateBit.TurnOnNow_InAutomatic:
return CommandType.TurnOnNow_InAutomatic;
case GKStateBit.TurnOffNow_InAutomatic:
return CommandType.TurnOffNow_InAutomatic;
default:
return CommandType.Unknown;
}
}
public void ControlGKDevice(Guid clientUID, Guid deviceUid, GKStateBit command)
{
ProcedureHelper.ControlGKDevice(clientUID, deviceUid, command);
}
