/* 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.Включено));
}
public void TestPumpStationOnGK()
{
var device1 = AddDevice(kauDevice2, GKDriverType.RSR2_HandDetector);
var device2 = AddDevice(kauDevice1, GKDriverType.RSR2_Bush_Fire);
var device3 = AddDevice(kauDevice1, GKDriverType.RSR2_Bush_Fire);
var clause = new GKClause()
{
ClauseOperationType = ClauseOperationType.AllDevices,
StateType = GKStateBit.Failure
};
clause.DeviceUIDs.Add(device1.UID);
var pumpStation = new GKPumpStation()
{
NSDeviceUIDs = { device2.UID, device3.UID }
};
pumpStation.StartLogic.OnClausesGroup.Clauses.Add(clause);
GKManager.PumpStations.Add(pumpStation);
Compile();
CheckObjectLogicOnGK(pumpStation);
var kau1DelayDescriptor = Kau1Database.Descriptors.FirstOrDefault(x => x.GKBase is GKDelay && (x.GKBase as GKDelay).PumpStationUID == pumpStation.UID);
var gkDelayDescriptor = GkDatabase.Descriptors.FirstOrDefault(x => x.GKBase is GKDelay && (x.GKBase as GKDelay).PumpStationUID == pumpStation.UID);
Assert.IsNull(kau1DelayDescriptor, "На КАУ присутствует компонент НС");
Assert.IsTrue(gkDelayDescriptor.Formula.FormulaOperations.Count > 1, "Отсутствует логика на ГК");
var kau1PimDescriptor = Kau1Database.Descriptors.FirstOrDefault(x => x.GKBase is GKPim && (x.GKBase as GKPim).PumpStationUID == pumpStation.UID);
var gkPimDescriptor = GkDatabase.Descriptors.FirstOrDefault(x => x.GKBase is GKPim && (x.GKBase as GKPim).PumpStationUID == pumpStation.UID);
Assert.IsNull(kau1PimDescriptor, "На КАУ присутствует компонент НС");
Assert.IsTrue(gkPimDescriptor.Formula.FormulaOperations.Count > 1, "Отсутствует логика на ГК");
CheckDeviceLogicOnGK(device2);
}
public ClauseViewModel(GKBase gkBase, GKClause clause)
{
SelectDevicesCommand = new RelayCommand(OnSelectDevices);
SelectZonesCommand = new RelayCommand(OnSelectZones);
SelectGuardZonesCommand = new RelayCommand(OnSelectGuardZones);
SelectDirectionCommand = new RelayCommand(OnSelectDirections);
SelectMPTsCommand = new RelayCommand(OnSelectMPTs);
SelectDelaysCommand = new RelayCommand(OnSelectDelays);
SelectDoorsCommand = new RelayCommand(OnSelectDoors);
SelectPumpStationsCommand = new RelayCommand(OnSelectPumpStations);
GKBase = gkBase;
ClauseConditionTypes = Enum.GetValues(typeof(ClauseConditionType)).Cast<ClauseConditionType>().ToList();
ClauseOperationTypes = Enum.GetValues(typeof(ClauseOperationType)).Cast<ClauseOperationType>().ToList();
SelectedClauseOperationType = clause.ClauseOperationType;
Devices = clause.Devices.ToList();
Zones = clause.Zones.ToList();
GuardZones = clause.GuardZones.ToList();
Directions = clause.Directions.ToList();
MPTs = clause.MPTs.ToList();
Delays = clause.Delays.ToList();
Doors = clause.Doors.ToList();
PumpStations = clause.PumpStations.ToList();
SelectedClauseConditionType = clause.ClauseConditionType;
SelectedStateType = StateTypes.FirstOrDefault(x => x.StateBit == clause.StateType);
}
/* RG-1004 (Включение НС по условию - пожар1 в зоне)*/
public void TestPumpStaitionStartLogicWithFirezone()
{
var pumpStaition = new GKPumpStation {Name = "Насосная станция", No = 1};
var zone = new GKZone {Name = "Пожарная зона", No = 1};
var clause = new GKClause
{
ClauseOperationType = ClauseOperationType.AllZones,
StateType = GKStateBit.Fire1,
ZoneUIDs = {zone.UID}
};
var device1 = AddDevice(kauDevice11, GKDriverType.RSR2_HeatDetector);
var device2 = AddDevice(kauDevice11, GKDriverType.RSR2_HeatDetector);
var device3 = AddDevice(kauDevice11, GKDriverType.RSR2_HeatDetector);
var pump = AddDevice(kauDevice11, GKDriverType.RSR2_Bush_Fire);
var gkpim = AddPim(gkDevice1);
var kaupim = AddPim(kauDevice11);
pumpStaition.StartLogic.OnClausesGroup.Clauses.Add(clause);
pumpStaition.NSDeviceUIDs.Add(pump.UID);
pumpStaition.NSDevices.Add(pump);
pumpStaition.Delay = 3;
GKManager.AddZone(zone);
GKManager.AddPumpStation(pumpStaition);
GKManager.AddDeviceToZone(device1, zone);
GKManager.AddDeviceToZone(device2, zone);
GKManager.AddDeviceToZone(device3, zone);
SetConfigAndRestartImitator();
WaitWhileState(zone, XStateClass.Norm, 10000, "Ждем Норму в зоне");
Assert.IsTrue(zone.State.StateClass == XStateClass.Norm, "Проверка того, что зона в Норме");
TurnOnPim(gkpim);
TurnOnPim(kaupim);
ConrtolGKBase(device1, GKStateBit.Fire1, "Сработка1 у датчика1");
WaitWhileState(zone, XStateClass.Attention, 4000, "Ждем пока зона не перейдёт во Внимание");
Assert.IsTrue(zone.State.StateClass == XStateClass.Attention, "Проверка того, что зона во Внимание");
Assert.IsTrue(pumpStaition.State.StateClass == XStateClass.Off, "Проверка того, что НС Выключен");
CheckJournal(3, JournalItem(device1, JournalEventNameType.Сработка_1),
JournalItem(zone, JournalEventNameType.Внимание), JournalItem(Led("Устройство Внимание "), JournalEventNameType.Включено));
ConrtolGKBase(device2, GKStateBit.Fire1, "Сработка1 у датчика2");
WaitWhileState(zone, XStateClass.Fire1, 3000, "Ждем пока зона не перейдёт в Пожар");
Assert.IsTrue(zone.State.StateClass == XStateClass.Fire1, "Проверка того, что зона перешла в Пожар");
Assert.IsTrue(pumpStaition.State.StateClass == XStateClass.TurningOn, "Проверка того, что НС Включается");
WaitWhileState(zone, XStateClass.On, 4000, "Ждем пока НС не Включится");
Assert.IsTrue(pumpStaition.State.StateClass == XStateClass.On, "Проверка того, что НС Включен");
Assert.IsTrue(pump.State.StateClass == XStateClass.On, "Проверка того, что насос Включен");
CheckJournal(8, JournalItem(device2, JournalEventNameType.Сработка_1), JournalItem(Led("Устройство Внимание "), JournalEventNameType.Выключено),
JournalItem(zone, JournalEventNameType.Пожар_1), JournalItem(pumpStaition, JournalEventNameType.Включается),
JournalItem(Led("Устройство Включение ПУСК "), JournalEventNameType.Включено), JournalItem(Led("Устройство Пожар 1 "), JournalEventNameType.Включено),
JournalItem(pumpStaition, JournalEventNameType.Включено), JournalItem(pump, JournalEventNameType.Включено));
}
public void TestDelayInMultiGk()
{
var device1 = AddDevice(kauDevice11, GKDriverType.RSR2_GuardDetector);
var device2 = AddDevice(kauDevice21, GKDriverType.RSR2_GuardDetector);
var delay = new GKDelay();
GKManager.Delays.Add(delay);
var clause = new GKClause
{
ClauseOperationType = ClauseOperationType.AllDevices,
StateType = GKStateBit.Failure,
DeviceUIDs = {device1.UID, device2.UID}
};
delay.Logic.OnClausesGroup.Clauses.Add(clause);
var validator = new Validator();
var errors = validator.Validate();
Assert.IsTrue(errors.Any(x => x.ErrorLevel == ValidationErrorLevel.CannotWrite && x.Error == "Содержится в нескольких ГК"));
}
/* RG-1015 (Если у НС задан Режим после удержания "Включено", то после окончания отсчета удержания он не должен переходить в режим "Включается")*/
public void TestPumpStationDelayRegime(DelayRegime regime, XStateClass state, JournalEventNameType eventname)
{
var pumpStaition = new GKPumpStation { Name = "Насосная станция", No = 1 };
var zone = new GKZone { Name = "Пожарная зона", No = 1 };
var clause = new GKClause
{
ClauseOperationType = ClauseOperationType.AllZones,
StateType = GKStateBit.Fire1,
ZoneUIDs = { zone.UID }
};
var device1 = AddDevice(kauDevice11, GKDriverType.RSR2_HeatDetector);
var device2 = AddDevice(kauDevice11, GKDriverType.RSR2_HeatDetector);
var device3 = AddDevice(kauDevice11, GKDriverType.RSR2_HeatDetector);
var pump = AddDevice(kauDevice11, GKDriverType.RSR2_Bush_Fire);
var gkpim = AddPim(gkDevice1);
var kaupim = AddPim(kauDevice11);
pumpStaition.StartLogic.OnClausesGroup.Clauses.Add(clause);
pumpStaition.NSDeviceUIDs.Add(pump.UID);
pumpStaition.NSDevices.Add(pump);
pumpStaition.Delay = 3;
pumpStaition.Hold = 3;
pumpStaition.DelayRegime = regime;
GKManager.AddZone(zone);
GKManager.AddPumpStation(pumpStaition);
GKManager.AddDeviceToZone(device1, zone);
GKManager.AddDeviceToZone(device2, zone);
GKManager.AddDeviceToZone(device3, zone);
SetConfigAndRestartImitator();
WaitWhileState(zone, XStateClass.Norm, 10000, "Ждем Норму в зоне");
Assert.IsTrue(zone.State.StateClass == XStateClass.Norm, "Проверка того, что зона в Норме");
TurnOnPim(gkpim);
TurnOnPim(kaupim);
ConrtolGKBase(device1, GKStateBit.Fire1, "Сработка1 у датчика1");
ConrtolGKBase(device2, GKStateBit.Fire1, "Сработка1 у датчика2");
WaitWhileState(pumpStaition, XStateClass.On, 5000, "Ждем пока НС не Включится");
Assert.IsTrue(pumpStaition.State.StateClass == XStateClass.On, "Проверка того, что НС Включен");
WaitWhileState(pumpStaition, XStateClass.TurningOn, 6000, "Ждем 6 секунд, НС не должен перейти в режим Включается");
Assert.IsFalse(pumpStaition.State.StateClass == XStateClass.TurningOn, "Проверка того, что НС не перешёл в режим Включается");
Assert.IsTrue(pumpStaition.State.StateClass == state, "Проверка того, что НС Включен/Выключен");
Assert.IsTrue(pump.State.StateClass == state, "Проверка того, что насос Включен/Выключен");
WaitWhileState(Led("Устройство Включение ПУСК "), state, 2000,"Ждём пока индикатор не будет Включен/Выключен");
// RG-1340 CheckJournal(3, JournalItem(pumpStaition, eventname), JournalItem(pump, eventname), JournalItem(Led("Устройство Включение ПУСК "), eventname));
}
public void TestMPTOnGK()
{
var device1 = AddDevice(kauDevice2, GKDriverType.RSR2_HandDetector);
var device2 = AddDevice(kauDevice1, GKDriverType.RSR2_RM_1);
var mpt = new GKMPT();
var clause = new GKClause()
{
ClauseOperationType = ClauseOperationType.AllDevices,
StateType = GKStateBit.Failure,
DeviceUIDs = { device1.UID }
};
mpt.MptLogic.OnClausesGroup.Clauses.Add(clause);
mpt.MPTDevices.Add(new GKMPTDevice() { MPTDeviceType = GKMPTDeviceType.Bomb, DeviceUID = device2.UID });
GKManager.MPTs.Add(mpt);
Compile();
CheckObjectLogicOnGK(mpt);
CheckDeviceLogicOnGK(device2);
}
public void TestMPTWithCodesOnKau()
{
var device1 = AddDevice(kauDevice1, GKDriverType.RSR2_HandDetector);
var device2 = AddDevice(kauDevice1, GKDriverType.RSR2_CodeReader);
var code = new GKCode();
GKManager.DeviceConfiguration.Codes.Add(code);
var mpt = new GKMPT();
var clause = new GKClause()
{
ClauseOperationType = ClauseOperationType.AllDevices,
StateType = GKStateBit.Failure,
DeviceUIDs = { device1.UID }
};
mpt.MptLogic.OnClausesGroup.Clauses.Add(clause);
mpt.MPTDevices.Add(new GKMPTDevice() { MPTDeviceType = GKMPTDeviceType.HandStart, DeviceUID = device2.UID, CodeReaderSettings = new GKCodeReaderSettings() { MPTSettings = new GKCodeReaderSettingsPart() { CodeUIDs = {code.UID}} } });
GKManager.MPTs.Add(mpt);
Compile();
CheckObjectLogicOnKau(mpt);
Assert.IsNotNull(Kau1Database.Descriptors.FirstOrDefault(x => x.GKBase == code));
}
public GKClauseGroup Clone()
{
var result = new GKClauseGroup();
result.ClauseJounOperationType = ClauseJounOperationType;
foreach (var clause in Clauses)
{
var clonedClause = new GKClause()
{
ClauseConditionType = clause.ClauseConditionType,
ClauseOperationType = clause.ClauseOperationType,
StateType = clause.StateType,
DeviceUIDs = clause.DeviceUIDs,
ZoneUIDs = clause.ZoneUIDs,
GuardZoneUIDs = clause.GuardZoneUIDs,
DirectionUIDs = clause.DirectionUIDs,
DelayUIDs = clause.DelayUIDs,
DoorUIDs = clause.DoorUIDs,
MPTUIDs = clause.MPTUIDs,
PumpStationsUIDs = clause.PumpStationsUIDs,
Devices = clause.Devices,
Zones = clause.Zones,
GuardZones = clause.GuardZones,
Directions = clause.Directions,
Delays = clause.Delays,
Doors = clause.Doors,
MPTs = clause.MPTs,
PumpStations = clause.PumpStations,
};
result.Clauses.Add(clonedClause);
}
foreach (var clauseGroup in ClauseGroups)
{
result.ClauseGroups.Add(clauseGroup.Clone());
}
return result;
}
/* RG-1015 (Если у задержки задан Режим после удержания "Включено", то после окончания отсчета удержания она не должена переходить в режим "Включается")*/
public void TestDelayRegimeDelay(DelayRegime regime, XStateClass state)
{
var delay = new GKDelay { Name = "Задержка", No = 1 };
var zone = new GKZone { Name = "Пожарная зона", No = 1 };
var clause = new GKClause
{
ClauseOperationType = ClauseOperationType.AllZones,
StateType = GKStateBit.Fire1,
ZoneUIDs = { zone.UID }
};
var device1 = AddDevice(kauDevice11, GKDriverType.RSR2_HeatDetector);
var device2 = AddDevice(kauDevice11, GKDriverType.RSR2_HeatDetector);
var device3 = AddDevice(kauDevice11, GKDriverType.RSR2_HeatDetector);
delay.Logic.OnClausesGroup.Clauses.Add(clause);
delay.DelayTime = 3;
delay.Hold = 3;
delay.DelayRegime = regime;
GKManager.AddZone(zone);
GKManager.AddDelay(delay);
GKManager.AddDeviceToZone(device1, zone);
GKManager.AddDeviceToZone(device2, zone);
GKManager.AddDeviceToZone(device3, zone);
SetConfigAndRestartImitator();
WaitWhileState(zone, XStateClass.Norm, 10000, "Ждем Норму в зоне");
Assert.IsTrue(zone.State.StateClass == XStateClass.Norm, "Проверка того, что зона в Норме");
ConrtolGKBase(device1, GKStateBit.Fire1, "Сработка1 у датчика1");
ConrtolGKBase(device2, GKStateBit.Fire1, "Сработка1 у датчика2");
WaitWhileState(delay, XStateClass.On, 5000, "Ждем пока задрежка не Включится");
Assert.IsTrue(delay.State.StateClass == XStateClass.On, "Проверка того, что задержка Включена");
WaitWhileState(delay, XStateClass.TurningOn, 6000, "Ждем 6 секунд, задрежка не должена перейти в режим Включается");
Assert.IsFalse(delay.State.StateClass == XStateClass.TurningOn, "Проверка того, что задрежка не перешла в режим Включается");
Assert.IsTrue(delay.State.StateClass == state, "Проверка того, что задрежка Включена/Выключена");
if (delay.DelayRegime == DelayRegime.On)
CheckJournal(3, JournalItem(delay, JournalEventNameType.Включается), JournalItem(Led("Устройство Пожар 1 "), JournalEventNameType.Включено), JournalItem(delay, JournalEventNameType.Включено));
else
CheckJournal(4, JournalItem(delay, JournalEventNameType.Включается), JournalItem(Led("Устройство Пожар 1 "), JournalEventNameType.Включено), JournalItem(delay, JournalEventNameType.Включено), JournalItem(delay, JournalEventNameType.Выключено));
}
public void ChangeGroupDeviceWithLogicTest()
{
SetMokForNewDeviceViewModel(GKDriverType.RSR2_MDU);
var devicesViewModel = GroupControllerModule.DevicesViewModel;
var selectedDevice = devicesViewModel.SelectedDevice = devicesViewModel.AllDevices.FirstOrDefault(x => x.Driver.DriverType == GKDriverType.RSR2_KAU_Shleif);
devicesViewModel.SelectedDevice.AddCommand.Execute();
GKManager.UpdateConfiguration();
var delay = new GKDelay();
var clause = new GKClause
{
ClauseOperationType = ClauseOperationType.AllDevices,
DeviceUIDs = { selectedDevice.Device.Children[0].UID }
};
var gkLogic = new GKLogic();
gkLogic.OnClausesGroup.Clauses.Add(clause);
GKManager.AddDelay(delay);
GKManager.SetDelayLogic(delay, gkLogic);
GKManager.SetDeviceLogic(selectedDevice.Device.Children[0], gkLogic);
selectedDevice = devicesViewModel.AllDevices.FirstOrDefault(x => x.Device == selectedDevice.Device.Children[0]);
selectedDevice.Driver = RSR2_RM_2_Helper.Create();
selectedDevice = devicesViewModel.SelectedDevice = devicesViewModel.AllDevices.FirstOrDefault(x => x.Driver.DriverType == GKDriverType.RSR2_KAU_Shleif);
var device = selectedDevice.Device.Children[0];
Assert.IsTrue(device.DriverType == GKDriverType.RSR2_RM_2);
Assert.IsTrue(device.Logic.GetObjects().Count == 0);
Assert.IsTrue(device.InputDependentElements.Count == 0);
Assert.IsTrue(delay.OutputDependentElements.Count == 0);
Assert.IsTrue(delay.Logic.GetObjects().Count == 0);
}
GKLogic CreateLogic(GKDevice device)
{
var clause = new GKClause() { ClauseOperationType = ClauseOperationType.AnyDevice, StateType = GKStateBit.Fire1 };
clause.Devices.Add(device);
clause.DeviceUIDs.Add(device.UID);
var clauseGroup = new GKClauseGroup();
clauseGroup.Clauses.Add(clause);
var logic = new GKLogic();
logic.OnClausesGroup = clauseGroup;
return logic;
}
public void TestDelayLogicOnGK()
{
var device1 = AddDevice(kauDevice1, GKDriverType.RSR2_HandDetector);
var device2 = AddDevice(kauDevice2, GKDriverType.RSR2_HandDetector);
var delay = new GKDelay();
GKManager.Delays.Add(delay);
var clause = new GKClause()
{
ClauseOperationType = ClauseOperationType.AllDevices,
StateType = GKStateBit.Failure,
DeviceUIDs = { device1.UID, device2.UID }
};
delay.Logic.OnClausesGroup.Clauses.Add(clause);
Compile();
CheckObjectLogicOnGK(delay);
}
public void TestDirectionLogicOnKau()
{
var device1 = AddDevice(kauDevice1, GKDriverType.RSR2_HandDetector);
var direction = new GKDirection();
GKManager.Directions.Add(direction);
var clause = new GKClause()
{
ClauseOperationType = ClauseOperationType.AllDevices,
DeviceUIDs = { device1.UID }
};
direction.Logic.OnClausesGroup.Clauses.Add(clause);
Compile();
CheckObjectLogicOnKau(direction);
}
GKClause GetClause(GKBase gkBase)
{
var clause = new GKClause();
if (gkBase is GKDevice)
{
clause.ClauseOperationType = ClauseOperationType.AllDevices;
clause.DeviceUIDs = new List<Guid> { gkBase.UID };
clause.StateType = GKStateBit.Failure;
}
if (gkBase is GKZone)
{
clause.ClauseOperationType = ClauseOperationType.AllZones;
clause.ZoneUIDs = new List<Guid> { gkBase.UID };
clause.StateType = GKStateBit.Fire1;
}
if (gkBase is GKGuardZone)
{
clause.ClauseOperationType = ClauseOperationType.AllGuardZones;
clause.GuardZoneUIDs = new List<Guid> { gkBase.UID };
clause.StateType = GKStateBit.Attention;
}
if (gkBase is GKDirection)
{
clause.ClauseOperationType = ClauseOperationType.AllDirections;
clause.DirectionUIDs = new List<Guid> { gkBase.UID };
clause.StateType = GKStateBit.On;
}
if (gkBase is GKDelay)
{
clause.ClauseOperationType = ClauseOperationType.AllDelays;
clause.DelayUIDs = new List<Guid> { gkBase.UID };
clause.StateType = GKStateBit.On;
}
if (gkBase is GKDoor)
{
clause.ClauseOperationType = ClauseOperationType.AllDoors;
clause.DoorUIDs = new List<Guid> { gkBase.UID };
clause.StateType = GKStateBit.On;
}
if (gkBase is GKMPT)
{
clause.ClauseOperationType = ClauseOperationType.AllMPTs;
clause.MPTUIDs = new List<Guid> { gkBase.UID };
clause.StateType = GKStateBit.On;
}
if (gkBase is GKPumpStation)
{
clause.ClauseOperationType = ClauseOperationType.AllPumpStations;
clause.PumpStationsUIDs = new List<Guid> { gkBase.UID };
clause.StateType = GKStateBit.On;
}
return clause;
}
public void RemoveDeviceTestLogicForMptNsDoor()
{
var device = AddDevice(kauDevice11, GKDriverType.RSR2_AM_1);
var device2 = AddDevice(kauDevice11, GKDriverType.RSR2_AM_1);
GKManager.UpdateConfiguration();
var clause = new GKClause
{
ClauseOperationType = ClauseOperationType.AllDevices,
DeviceUIDs = { device.UID }
};
var gkLogic = new GKLogic();
gkLogic.OnClausesGroup.Clauses.Add(clause);
var mpt = new GKMPT();
var gkMptDevice = new GKMPTDevice { Device = device, DeviceUID = device.UID };
GKManager.AddMPT(mpt);
GKManager.SetMPTLogic(mpt, gkLogic);
mpt.MPTDevices.Add(gkMptDevice);
Assert.IsTrue(mpt.MptLogic.OnClausesGroup.Clauses.Any(x => x.DeviceUIDs.Contains(device.UID)));
Assert.IsTrue(mpt.MPTDevices.Any(x => x.DeviceUID == device.UID));
Assert.IsTrue(mpt.InputDependentElements.Contains(device));
Assert.IsTrue(device.OutputDependentElements.Contains(mpt));
var pump = new GKPumpStation();
GKManager.AddPumpStation(pump);
GKManager.SetPumpStationStartLogic(pump, gkLogic);
GKManager.ChangePumpDevices(pump, new List<GKDevice>() {device});
Assert.IsTrue(pump.StartLogic.OnClausesGroup.Clauses.Any(x => x.DeviceUIDs.Contains(device.UID)));
Assert.IsTrue(pump.NSDevices.Contains(device));
Assert.IsTrue(pump.InputDependentElements.Contains(device));
Assert.IsTrue(device.OutputDependentElements.Contains(pump));
var door = new GKDoor();
GKManager.AddDoor(door);
GKManager.SetDoorOpenRegimeLogic(door, gkLogic);
GKManager.SetDoorCloseRegimeLogic(door, gkLogic);
GKManager.ChangeEnterButtonDevice(door, device);
Assert.IsTrue(door.EnterButton == device);
Assert.IsTrue(door.EnterButtonUID == device.UID);
Assert.IsTrue(device.Door == door);
Assert.IsTrue(device.OutputDependentElements.Contains(door));
Assert.IsTrue(door.InputDependentElements.Contains(device));
door.EnterButton = null;
door.EnterButtonUID = Guid.Empty;
GKManager.ChangeExitButtonDevice(door, device);
Assert.IsTrue(door.ExitButton == device);
Assert.IsTrue(door.ExitButtonUID == device.UID);
Assert.IsTrue(device.Door == door);
door.ExitButton = null;
door.ExitButtonUID = Guid.Empty;
GKManager.ChangeLockControlDevice(door, device);
Assert.IsTrue(door.LockControlDevice == device);
Assert.IsTrue(door.LockControlDeviceUID == device.UID);
Assert.IsTrue(device.Door == door);
door.LockDevice = null;
door.LockControlDeviceUID = Guid.Empty;
GKManager.ChangeLockControlDeviceExit(door, device);
Assert.IsTrue(door.LockControlDeviceExitUID == device.UID);
Assert.IsTrue(door.LockControlDeviceExit == device);
Assert.IsTrue(device.Door == door);
door.LockDeviceExit = null;
door.LockControlDeviceExitUID = Guid.Empty;
GKManager.ChangeLockDevice(door, device);
Assert.IsTrue(door.LockDevice == device);
Assert.IsTrue(door.LockDeviceUID == device.UID);
Assert.IsTrue(device.Door == door);
door.LockDeviceUID = Guid.Empty;
door.LockDevice = null;
GKManager.ChangeLockDeviceExit(door, device);
Assert.IsTrue(door.LockDeviceExit == device);
Assert.IsTrue(door.LockDeviceExitUID == device.UID);
Assert.IsTrue(device.Door == door);
Assert.IsTrue(door.OpenRegimeLogic.OnClausesGroup.Clauses.Any(x => x.DeviceUIDs.Contains( device.UID)));
Assert.IsTrue(door.CloseRegimeLogic.OnClausesGroup.Clauses.Any(x => x.DeviceUIDs.Contains(device.UID)));
GKManager.RemoveDevice(device);
Assert.IsFalse(mpt.MptLogic.OnClausesGroup.Clauses.Any(x => x.DeviceUIDs.Contains(device.UID)));
Assert.IsFalse(mpt.InputDependentElements.Any(x => x.UID == device.UID));
Assert.IsFalse(pump.StartLogic.OnClausesGroup.Clauses.Any(x => x.DeviceUIDs.Contains(device.UID)));
Assert.IsFalse(pump.InputDependentElements.Any(x => x.UID == device.UID));
Assert.IsFalse(mpt.MPTDevices.Any(x => x.DeviceUID == device.UID));
Assert.IsFalse(pump.NSDevices.Contains(device));
Assert.IsFalse(door.InputDependentElements.Any(x => x.UID == device.UID));
}
public void TestMPTWithGlobalPimOnGk()
{
var device1 = AddDevice(kauDevice1, GKDriverType.RSR2_HandDetector);
var device2 = AddDevice(kauDevice1, GKDriverType.RSR2_CodeReader);
var mpt = new GKMPT();
var clause = new GKClause
{
ClauseOperationType = ClauseOperationType.AllDevices,
StateType = GKStateBit.Failure,
DeviceUIDs = { device1.UID }
};
mpt.MptLogic.OnClausesGroup.Clauses.Add(clause);
mpt.MPTDevices.Add(new GKMPTDevice { MPTDeviceType = GKMPTDeviceType.HandStart, DeviceUID = device2.UID, CodeReaderSettings = new GKCodeReaderSettings { MPTSettings = new GKCodeReaderSettingsPart{AccessLevel = 1} } });
GKManager.MPTs.Add(mpt);
Compile();
var globalPimDescriptor = GkDatabase.Descriptors.FirstOrDefault(x => (x.GKBase is GKPim) && (x.GKBase as GKPim).IsGlobalPim && x.GKBase.KauDatabaseParent == null);
Assert.IsNotNull(globalPimDescriptor);
var mptDescriptor = GkDatabase.Descriptors.FirstOrDefault(x => (x.GKBase == mpt));
Assert.IsNotNull(mptDescriptor);
Assert.IsTrue(mptDescriptor.Formula.FormulaOperations.Any(x => x.GKBaseSecondOperand == globalPimDescriptor.GKBase));
}
public void TestMPTWithAccessLevelsOnGK()
{
var device1 = AddDevice(kauDevice1, GKDriverType.RSR2_HandDetector);
var device2 = AddDevice(kauDevice1, GKDriverType.RSR2_CodeReader);
var mpt = new GKMPT();
var clause = new GKClause()
{
ClauseOperationType = ClauseOperationType.AllDevices,
StateType = GKStateBit.Failure,
DeviceUIDs = { device1.UID }
};
mpt.MptLogic.OnClausesGroup.Clauses.Add(clause);
mpt.MPTDevices.Add(new GKMPTDevice() { MPTDeviceType = GKMPTDeviceType.HandStart, DeviceUID = device2.UID, CodeReaderSettings = new GKCodeReaderSettings() { MPTSettings = new GKCodeReaderSettingsPart() { AccessLevel = 1 } } });
GKManager.MPTs.Add(mpt);
Compile();
CheckObjectLogicOnGK(mpt);
}
public GKClauseGroup GetClauseGroup()
{
var clauseGroup = new GKClauseGroup();
clauseGroup.ClauseJounOperationType = JoinOperator;
foreach (var clauseGroupViewModel in ClauseGroups)
{
clauseGroup.ClauseGroups.Add(clauseGroupViewModel.GetClauseGroup());
}
foreach (var clauseViewModel in Clauses)
{
var clause = new GKClause()
{
ClauseConditionType = clauseViewModel.SelectedClauseConditionType,
StateType = clauseViewModel.SelectedStateType.StateBit,
ClauseOperationType = clauseViewModel.SelectedClauseOperationType
};
switch (clause.ClauseOperationType)
{
case ClauseOperationType.AllDevices:
case ClauseOperationType.AnyDevice:
clause.Devices = clauseViewModel.Devices.ToList();
clause.DeviceUIDs = clauseViewModel.Devices.Select(x => x.UID).ToList();
break;
case ClauseOperationType.AllZones:
case ClauseOperationType.AnyZone:
clause.Zones = clauseViewModel.Zones.ToList();
clause.ZoneUIDs = clauseViewModel.Zones.Select(x => x.UID).ToList();
break;
case ClauseOperationType.AllGuardZones:
case ClauseOperationType.AnyGuardZone:
clause.GuardZones = clauseViewModel.GuardZones.ToList();
clause.GuardZoneUIDs = clauseViewModel.GuardZones.Select(x => x.UID).ToList();
break;
case ClauseOperationType.AllDirections:
case ClauseOperationType.AnyDirection:
clause.Directions = clauseViewModel.Directions.ToList();
clause.DirectionUIDs = clauseViewModel.Directions.Select(x => x.UID).ToList();
break;
case ClauseOperationType.AllMPTs:
case ClauseOperationType.AnyMPT:
clause.MPTs = clauseViewModel.MPTs.ToList();
clause.MPTUIDs = clauseViewModel.MPTs.Select(x => x.UID).ToList();
break;
case ClauseOperationType.AllDelays:
case ClauseOperationType.AnyDelay:
clause.Delays = clauseViewModel.Delays.ToList();
clause.DelayUIDs = clauseViewModel.Delays.Select(x => x.UID).ToList();
break;
case ClauseOperationType.AllDoors:
case ClauseOperationType.AnyDoor:
clause.Doors = clauseViewModel.Doors.ToList();
clause.DoorUIDs = clauseViewModel.Doors.Select(x => x.UID).ToList();
break;
case ClauseOperationType.AnyPumpStation:
case ClauseOperationType.AllPumpStations:
clause.PumpStations = clauseViewModel.PumpStations.ToList();
clause.PumpStationsUIDs = clauseViewModel.PumpStations.Select(x => x.UID).ToList();
break;
}
if (clause.HasObjects())
clauseGroup.Clauses.Add(clause);
}
return clauseGroup;
}
public void TestMPTInMultiGk()
{
var device1 = AddDevice(kauDevice11, GKDriverType.RSR2_GuardDetector);
var device2 = AddDevice(kauDevice21, GKDriverType.RSR2_GuardDetector);
var mpt = new GKMPT();
GKManager.MPTs.Add(mpt);
var clause = new GKClause
{
ClauseOperationType = ClauseOperationType.AllDevices,
StateType = GKStateBit.Failure,
DeviceUIDs = {device1.UID, device2.UID}
};
mpt.MptLogic.OnClausesGroup.Clauses.Add(clause);
var validator = new Validator();
var errors = validator.Validate();
Assert.IsTrue(errors.Any(x => x.ErrorLevel == ValidationErrorLevel.CannotWrite && x.Error == "Содержится в нескольких ГК"));
mpt.MptLogic = new GKLogic();
clause = new GKClause
{
ClauseOperationType = ClauseOperationType.AllDevices,
StateType = GKStateBit.Failure,
DeviceUIDs = { device1.UID }
};
mpt.MptLogic.OnClausesGroup.Clauses.Add(clause);
foreach (var deviceType in new List<GKMPTDeviceType>(Enum.GetValues(typeof(GKMPTDeviceType)).Cast<GKMPTDeviceType>()))
{
mpt.MPTDevices = new List<GKMPTDevice>();
var mptDevice = new GKMPTDevice { Device = device2, DeviceUID = device2.UID, MPTDeviceType = deviceType };
mpt.MPTDevices.Add(mptDevice);
validator = new Validator();
errors = validator.Validate();
Assert.IsTrue(errors.Any(x => x.ErrorLevel == ValidationErrorLevel.CannotWrite && x.Error == "Содержится в нескольких ГК"));
}
}
public void TestDeviceLogicOnGK()
{
var device1 = AddDevice(kauDevice1, GKDriverType.RSR2_HandDetector);
var device2 = AddDevice(kauDevice2, GKDriverType.RSR2_HandDetector);
var device3 = AddDevice(kauDevice1, GKDriverType.RSR2_RM_1);
var clause = new GKClause()
{
ClauseOperationType = ClauseOperationType.AllDevices,
StateType = GKStateBit.Failure,
DeviceUIDs = { device1.UID, device2.UID }
};
device3.Logic.OnClausesGroup.Clauses.Add(clause);
Compile();
CheckDeviceLogicOnGK(device3);
}
public void TestPumpStationWithGlobalPimOnKau()
{
var device1 = AddDevice(kauDevice1, GKDriverType.RSR2_HandDetector);
var device2 = AddDevice(kauDevice1, GKDriverType.RSR2_Bush_Fire);
var device3 = AddDevice(kauDevice1, GKDriverType.RSR2_Bush_Fire);
var clause = new GKClause()
{
ClauseOperationType = ClauseOperationType.AllDevices,
StateType = GKStateBit.Failure
};
clause.DeviceUIDs.Add(device1.UID);
var pumpStation = new GKPumpStation()
{
NSDeviceUIDs = { device2.UID, device3.UID }
};
pumpStation.StartLogic.OnClausesGroup.Clauses.Add(clause);
GKManager.PumpStations.Add(pumpStation);
Compile();
var globalPimDescriptor = Kau1Database.Descriptors.FirstOrDefault(x => (x.GKBase is GKPim) && (x.GKBase as GKPim).IsGlobalPim);
Assert.IsNotNull(globalPimDescriptor);
var pumpStationDescriptor = Kau1Database.Descriptors.FirstOrDefault(x => (x.GKBase == pumpStation));
Assert.IsNotNull(pumpStationDescriptor);
Assert.IsTrue(pumpStationDescriptor.Formula.FormulaOperations.Any(x => x.GKBaseSecondOperand == globalPimDescriptor.GKBase));
}
public void RemoveDeviceTestLogicForDelayAndDirection()
{
var device = AddDevice(kauDevice11, GKDriverType.RSR2_MDU);
GKManager.UpdateConfiguration();
var clause = new GKClause
{
ClauseOperationType = ClauseOperationType.AllDevices,
DeviceUIDs = { device.UID }
};
var gkLogic = new GKLogic();
gkLogic.OnClausesGroup.Clauses.Add(clause);
GKManager.SetDeviceLogic(device, gkLogic);
Assert.IsTrue(device.Logic.OnClausesGroup.Clauses.Any(x => x.DeviceUIDs.Contains(device.UID)));
Assert.IsFalse(device.OutputDependentElements.Any(x => x.UID == device.UID));
Assert.IsFalse(device.InputDependentElements.Any(x => x.UID == device.UID));
var delay = new GKDelay();
GKManager.AddDelay(delay);
GKManager.SetDelayLogic(delay, gkLogic);
Assert.IsTrue(delay.Logic.OnClausesGroup.Clauses.Any(x => x.DeviceUIDs.Contains(device.UID)));
Assert.IsTrue(device.OutputDependentElements.Any(x => x.UID == delay.UID));
Assert.IsTrue(delay.InputDependentElements.Any(x => x.UID == device.UID));
var direction = new GKDirection();
GKManager.AddDirection(direction);
GKManager.SetDirectionLogic(direction,gkLogic);
Assert.IsTrue(direction.Logic.OnClausesGroup.Clauses.Any(x => x.DeviceUIDs.Any()));
Assert.IsTrue(device.OutputDependentElements.Any(x => x.UID == direction.UID));
Assert.IsTrue(direction.InputDependentElements.Any(x => x.UID == device.UID));
GKManager.RemoveDevice(device);
Assert.IsFalse(delay.Logic.OnClausesGroup.Clauses.Any(x => x.DeviceUIDs.Contains(device.UID)));
Assert.IsFalse(direction.Logic.OnClausesGroup.Clauses.Any(x => x.DeviceUIDs.Contains(device.UID)));
Assert.IsFalse(delay.InputDependentElements.Any(x => x.UID == device.UID));
Assert.IsFalse(direction.InputDependentElements.Any(x => x.UID == device.UID));
}
public void TestDeviceLogicOnKau()
{
var device1 = AddDevice(kauDevice1, GKDriverType.RSR2_HandDetector);
var device2 = AddDevice(kauDevice1, GKDriverType.RSR2_RM_1);
var clause = new GKClause()
{
ClauseOperationType = ClauseOperationType.AllDevices,
DeviceUIDs = { device1.UID }
};
device2.Logic.OnClausesGroup.Clauses.Add(clause);
Compile();
CheckDeviceLogicOnKau(device2);
}
