예제 #1
0
		public ClauseGroupViewModel(GKBase gkBase, GKClauseGroup clauseGroup)
		{
			AddCommand = new RelayCommand(OnAdd);
			AddGroupCommand = new RelayCommand(OnAddGroup);
			RemoveCommand = new RelayCommand<ClauseViewModel>(OnRemove);
			RemoveGroupCommand2 = new RelayCommand(OnRemoveGroup2, CanRemoveGroup2);
			RemoveGroupCommand = new RelayCommand<ClauseGroupViewModel>(OnRemoveGroup);
			ChangeJoinOperatorCommand = new RelayCommand(OnChangeJoinOperator);

			GKBase = gkBase;
			Clauses = new ObservableCollection<ClauseViewModel>();
			foreach (var clause in clauseGroup.Clauses)
			{
				var clauseViewModel = new ClauseViewModel(gkBase, clause);
				Clauses.Add(clauseViewModel);
			}

			ClauseGroups = new ObservableCollection<ClauseGroupViewModel>();
			foreach (var clause in clauseGroup.ClauseGroups)
			{
				var clauseGroupViewModel = new ClauseGroupViewModel(gkBase, clause);
				clauseGroupViewModel.Parent = this;
				ClauseGroups.Add(clauseGroupViewModel);
			}

			JoinOperator = clauseGroup.ClauseJounOperationType;
		}
예제 #2
0
		public ICIndicatorLogic()
		{
			Blink1ClausesGroup = new GKClauseGroup();
			Blink3ClausesGroup = new GKClauseGroup();
			OffClausesGroup = new GKClauseGroup();
			UseOffCounterLogic = false;
		}
예제 #3
0
파일: GKLogic.cs 프로젝트: xbadcode/Rubezh
		public GKLogic()
		{
			OnClausesGroup = new GKClauseGroup();
			On2ClausesGroup = new GKClauseGroup();
			OffClausesGroup = new GKClauseGroup();
			OnNowClausesGroup = new GKClauseGroup();
			OffNowClausesGroup = new GKClauseGroup();
			StopClausesGroup = new GKClauseGroup();
			UseOffCounterLogic = true;
			RedIndicatorLogic = new ICIndicatorLogic();
			GreenIndicatorLogic = new ICIndicatorLogic();
			YellowIndicatorLogic = new ICIndicatorLogic();
		}
예제 #4
0
		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;
		}
	   public GKClauseGroup InvalidateOneClauseGroup(GKBase gkBase, GKClauseGroup clauseGroup)
		{
			var result = new GKClauseGroup();
			result.ClauseJounOperationType = clauseGroup.ClauseJounOperationType;
			var groups = new List<GKClauseGroup>();
			foreach (var group in clauseGroup.ClauseGroups)
			{
				var _clauseGroup = InvalidateOneClauseGroup(gkBase, group);
				if (_clauseGroup.Clauses.Count + _clauseGroup.ClauseGroups.Count > 0)
					groups.Add(_clauseGroup);
			}
			result.ClauseGroups = groups;

			foreach (var clause in clauseGroup.Clauses)
			{
				clause.Devices = new List<GKDevice>();
				clause.Zones = new List<GKZone>();
				clause.GuardZones = new List<GKGuardZone>();
				clause.Directions = new List<GKDirection>();
				clause.MPTs = new List<GKMPT>();
				clause.Delays = new List<GKDelay>();
				clause.Doors = new List<GKDoor>();
				clause.PumpStations = new List<GKPumpStation>();

				var deviceUIDs = new List<Guid>();
				foreach (var deviceUID in clause.DeviceUIDs)
				{
					var device = Devices.FirstOrDefault(x => x.UID == deviceUID);
					if (device != null)
					{
						deviceUIDs.Add(deviceUID);
						clause.Devices.Add(device);
					}
				}
				clause.DeviceUIDs = deviceUIDs;

				var zoneUIDs = new List<Guid>();
				foreach (var zoneUID in clause.ZoneUIDs)
				{
					var zone = Zones.FirstOrDefault(x => x.UID == zoneUID);
					if (zone != null)
					{
						zoneUIDs.Add(zoneUID);
						clause.Zones.Add(zone);
					}
				}
				clause.ZoneUIDs = zoneUIDs;

				var guardZoneUIDs = new List<Guid>();
				foreach (var guardZoneUID in clause.GuardZoneUIDs)
				{
					var guardZone = GuardZones.FirstOrDefault(x => x.UID == guardZoneUID);
					if (guardZone != null)
					{
						guardZoneUIDs.Add(guardZoneUID);
						clause.GuardZones.Add(guardZone);
					}
				}
				clause.GuardZoneUIDs = guardZoneUIDs;

				var directionUIDs = new List<Guid>();
				foreach (var directionUID in clause.DirectionUIDs)
				{
					var direction = Directions.FirstOrDefault(x => x.UID == directionUID);
					if (direction != null)
					{
						directionUIDs.Add(directionUID);
						clause.Directions.Add(direction);
					}
				}
				clause.DirectionUIDs = directionUIDs;

				var mptUIDs = new List<Guid>();
				foreach (var mptUID in clause.MPTUIDs)
				{
					var mpt = MPTs.FirstOrDefault(x => x.UID == mptUID);
					if (mpt != null)
					{
						mptUIDs.Add(mptUID);
						clause.MPTs.Add(mpt);
					}
				}
				clause.MPTUIDs = mptUIDs;

				var delayUIDs = new List<Guid>();
				foreach (var delayUID in clause.DelayUIDs)
				{
					var delay = Delays.FirstOrDefault(x => x.UID == delayUID);
					if (delay != null)
					{
						delayUIDs.Add(delayUID);
						clause.Delays.Add(delay);
					}
				}
				clause.DelayUIDs = delayUIDs;

				var doorUIDs = new List<Guid>();
				foreach (var doorUID in clause.DoorUIDs)
				{
					var door = Doors.FirstOrDefault(x => x.UID == doorUID);
					if (door != null)
					{
						doorUIDs.Add(doorUID);
						clause.Doors.Add(door);
					}
				}
				clause.DoorUIDs = doorUIDs;

				var pumpStationsUIDs = new List<Guid>();
				foreach (var pumpStationUID in clause.PumpStationsUIDs)
				{
					var pumpStation = PumpStations.FirstOrDefault(x => x.UID == pumpStationUID);
					if (pumpStation != null)
					{
						pumpStationsUIDs.Add(pumpStationUID);
						clause.PumpStations.Add(pumpStation);
					}
				}
				clause.PumpStationsUIDs = pumpStationsUIDs;

				if (clause.HasObjects())
					result.Clauses.Add(clause);
			}
			return result;
		}
예제 #6
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;
		}
예제 #7
0
파일: GKBase.cs 프로젝트: xbadcode/Rubezh
		void LinkLogic(GKBase gkBase, GKClauseGroup clauseGroup)
		{
			if (clauseGroup.Clauses != null)
			{
				foreach (var clause in clauseGroup.Clauses)
				{
					foreach (var clauseDevice in clause.Devices)
						gkBase.LinkToDescriptor(clauseDevice);
					foreach (var zone in clause.Zones)
						gkBase.LinkToDescriptor(zone);
					foreach (var guardZone in clause.GuardZones)
						gkBase.LinkToDescriptor(guardZone);
					foreach (var direction in clause.Directions)
						gkBase.LinkToDescriptor(direction);
					foreach (var mpt in clause.MPTs)
						gkBase.LinkToDescriptor(mpt);
					foreach (var delay in clause.Delays)
						gkBase.LinkToDescriptor(delay);
					foreach (var door in clause.Doors)
						gkBase.LinkToDescriptor(door);
					foreach (var pumpStation in clause.PumpStations)
						gkBase.LinkToDescriptor(pumpStation);
				}
			}
			if (clauseGroup.ClauseGroups != null)
			{
				foreach (var group in clauseGroup.ClauseGroups)
				{
					LinkLogic(gkBase, group);
				}
			}
		}
예제 #8
0
		public static string GetPresentationLogic(GKClauseGroup clauseGroup)
		{
			var stringBuilder = new StringBuilder();
			var index = 0;
			foreach (var clause in clauseGroup.Clauses)
			{
				if (index > 0)
					stringBuilder.Append(" " + clauseGroup.ClauseJounOperationType.ToDescription() + " ");

				if (clause.ClauseConditionType == ClauseConditionType.IfNot)
					stringBuilder.Append("Если НЕ ");
				stringBuilder.Append(GKClause.ClauseToString(clause.ClauseOperationType, clause.StateType) + " ");
				stringBuilder.Append(clause.ClauseOperationType.ToDescription() + " ");
				stringBuilder.Append(GetCommaSeparatedDevices(clause.Devices));
				stringBuilder.Append(GetCommaSeparatedObjects(new List<ModelBase>(clause.Zones), new List<ModelBase>(Zones)));
				stringBuilder.Append(GetCommaSeparatedObjects(new List<ModelBase>(clause.GuardZones), new List<ModelBase>(GuardZones)));
				stringBuilder.Append(GetCommaSeparatedObjects(new List<ModelBase>(clause.Directions), new List<ModelBase>(Directions)));
				stringBuilder.Append(GetCommaSeparatedObjects(new List<ModelBase>(clause.MPTs), new List<ModelBase>(MPTs)));
				stringBuilder.Append(GetCommaSeparatedObjects(new List<ModelBase>(clause.Delays), new List<ModelBase>(Delays)));
				stringBuilder.Append(GetCommaSeparatedObjects(new List<ModelBase>(clause.Doors), new List<ModelBase>(Doors)));
				stringBuilder.Append(GetCommaSeparatedObjects(new List<ModelBase>(clause.PumpStations), new List<ModelBase>(PumpStations)));
				index++;
			}

			foreach (var group in clauseGroup.ClauseGroups)
			{
				if (index > 0)
					stringBuilder.Append(" " + clauseGroup.ClauseJounOperationType.ToDescription() + " ");

				var groupString = GetPresentationLogic(group);

				stringBuilder.Append("(" + groupString + ")");
				index++;
			}
			return stringBuilder.ToString();
		}
예제 #9
0
		static bool AppendClauseGroupString(GKClauseGroup gkClauseGroup, string name, List<StringBuilder> list)
		{
			if (gkClauseGroup.IsNotEmpty())
			{
				var stringBuilder = new StringBuilder();
				stringBuilder.Append(name);
				stringBuilder.Append(": ");
				stringBuilder.Append(GetPresentationLogic(gkClauseGroup));
				list.Add(stringBuilder);
				return true;
			}
			return false;
		}
예제 #10
0
		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;
		}