private static FilterSignal GetFilterSignal(MOE.Common.Models.Signal signal)
        {
            var filterSignal = new FilterSignal
            {
                Exclude     = false,
                SignalId    = signal.SignalID,
                VersionId   = signal.VersionID,
                Description = signal.SignalDescription
            };

            foreach (var approach in signal.Approaches)
            {
                var filterApproach = new FilterApproach
                {
                    ApproachId  = approach.ApproachID,
                    Exclude     = false,
                    Description = approach.Description
                };
                foreach (var detector in approach.Detectors)
                {
                    var filterDetector = new FilterDetector
                    {
                        Id          = detector.ID,
                        Exclude     = false,
                        Description = detector.Description
                    };
                    filterApproach.FilterDetectors.Add(filterDetector);
                }
                filterSignal.FilterApproaches.Add(filterApproach);
            }

            return(filterSignal);
        }
        protected void SetFilterSignal(SignalAggregationMetricOptions options)
        {
            List <FilterSignal> filterSignals = new List <FilterSignal>();
            var signals = Db.Signals.Take(2);

            foreach (var signal in signals)
            {
                var filterSignal = new FilterSignal {
                    SignalId = signal.SignalID, Exclude = false
                };
                foreach (var approach in signal.Approaches)
                {
                    var filterApproach = new FilterApproach
                    {
                        ApproachId  = approach.ApproachID,
                        Description = String.Empty,
                        Exclude     = false
                    };
                    filterSignal.FilterApproaches.Add(filterApproach);
                    foreach (var detector in approach.Detectors)
                    {
                        filterApproach.FilterDetectors.Add(new FilterDetector
                        {
                            Id          = detector.ID,
                            Description = String.Empty,
                            Exclude     = false
                        });
                    }
                }
                filterSignals.Add(filterSignal);
            }
            options.FilterSignals    = filterSignals;
            options.FilterDirections = new List <FilterDirection>();
            options.FilterDirections.Add(new FilterDirection {
                Description = "", DirectionTypeId = 0, Include = true
            });
            options.FilterDirections.Add(new FilterDirection {
                Description = "", DirectionTypeId = 1, Include = true
            });
            options.FilterDirections.Add(new FilterDirection {
                Description = "", DirectionTypeId = 2, Include = true
            });
            options.FilterDirections.Add(new FilterDirection {
                Description = "", DirectionTypeId = 3, Include = true
            });
            options.FilterMovements = new List <FilterMovement>();
            options.FilterMovements.Add(new FilterMovement {
                Description = "", MovementTypeId = 0, Include = true
            });
            options.FilterMovements.Add(new FilterMovement {
                Description = "", MovementTypeId = 1, Include = true
            });
            options.FilterMovements.Add(new FilterMovement {
                Description = "", MovementTypeId = 2, Include = true
            });
            options.FilterMovements.Add(new FilterMovement {
                Description = "", MovementTypeId = 3, Include = true
            });
        }
        private static void RemoveDetectorsFromApproachByFilter(FilterApproach filterApproach, Approach approach)
        {
            var detectorRepository  = DetectorRepositoryFactory.Create();
            var excludedDetectorIds =
                filterApproach.FilterDetectors.Where(f => f.Exclude).Select(f => f.Id).ToList();
            var excludedDetectors = detectorRepository.GetDetectorsByIds(excludedDetectorIds);

            foreach (var excludedDetector in excludedDetectors)
            {
                var detectorsToExclude = approach.Detectors.Where(d =>
                                                                  d.LaneNumber == excludedDetector.LaneNumber &&
                                                                  d.LaneTypeID == excludedDetector.LaneTypeID &&
                                                                  d.MovementTypeID == excludedDetector.MovementTypeID &&
                                                                  d.DetectionHardwareID == excludedDetector.DetectionHardwareID &&
                                                                  d.DetChannel == excludedDetector.DetChannel
                                                                  ).ToList();
                foreach (var detectorToExclude in detectorsToExclude)
                {
                    approach.Detectors.Remove(detectorToExclude);
                }
            }
        }