protected IQueryable <IGrouping <DateTime, FleetHistory> > GetAvailabilityHistoryGroupedByDate()
        {
            var avHistory = GetAvailabilityHistory();


            avHistory = FleetHistoryRestriction.RestrictVehicleQueryable(DataContext, avHistory);


            var groupedData = from v in avHistory
                              group v by v.Timestamp
                              into gd
                              select gd;

            var returned = groupedData;

            return(returned);
        }
        public IQueryable <FleetHistory> GetAvailabilityHistory()
        {
            var availability = DataContext.FleetHistories.Select(d => d);


            availability = FleetHistoryRestriction.RestrictVehicleQueryable(DataContext, availability);



            var startDate = Parameters.GetDateFromDictionary(DictionaryParameter.StartDate);
            var endDate   = Parameters.GetDateFromDictionary(DictionaryParameter.EndDate);

            availability = availability.Where(d => d.Timestamp.Date >= startDate);
            if (endDate != DateTime.MinValue)
            {
                availability = availability.Where(d => d.Timestamp.Date <= endDate);
            }

            if (Parameters.ContainsValueAndIsntEmpty(DictionaryParameter.FleetTypes))
            {
                var selectedFleetTypes = Parameters[DictionaryParameter.FleetTypes].Split(',').Select(byte.Parse);
                availability = availability.Where(d => selectedFleetTypes.Contains(d.FleetTypeId));
            }

            if (Parameters.ContainsKey(DictionaryParameter.DayOfWeek) &&
                Parameters[DictionaryParameter.DayOfWeek] != string.Empty)
            {
                DayOfWeek dowEntered;
                var       success = Enum.TryParse(Parameters[DictionaryParameter.DayOfWeek], out dowEntered);
                if (!success)
                {
                    throw new InvalidCastException("Unable to case Day of Week");
                }
                availability = availability.Where(d => d.Timestamp.DayOfWeek == dowEntered);
            }

            if (Parameters.ContainsValueAndIsntEmpty(DictionaryParameter.CarGroup))
            {
                var carGroupId = int.Parse(Parameters[DictionaryParameter.CarGroup]);
                availability = availability.Where(d => d.CarGroupId == carGroupId);
            }
            else if (Parameters.ContainsValueAndIsntEmpty(DictionaryParameter.CarClass))
            {
                var carClassId = int.Parse(Parameters[DictionaryParameter.CarClass]);
                availability = availability.Where(d => d.CAR_GROUP.car_class_id == carClassId);
            }
            else if (Parameters.ContainsValueAndIsntEmpty(DictionaryParameter.CarSegment))
            {
                var carSegmentId = int.Parse(Parameters[DictionaryParameter.CarSegment]);
                availability = availability.Where(d => d.CAR_GROUP.CAR_CLASS.car_segment_id == carSegmentId);
            }
            else if (Parameters.ContainsValueAndIsntEmpty(DictionaryParameter.OwningCountry))
            {
                var owningCountry = Parameters[DictionaryParameter.OwningCountry];
                availability = availability.Where(d => d.CAR_GROUP.CAR_CLASS.CAR_SEGMENT.country == owningCountry);
            }


            if (Parameters.ContainsValueAndIsntEmpty(DictionaryParameter.Location))
            {
                var location = int.Parse(Parameters[DictionaryParameter.Location]);
                availability = availability.Where(d => d.LOCATION.dim_Location_id == location);
            }
            else if (Parameters.ContainsValueAndIsntEmpty(DictionaryParameter.LocationGroup) ||
                     Parameters.ContainsValueAndIsntEmpty(DictionaryParameter.Area))
            {
                if (Parameters.ContainsValueAndIsntEmpty(DictionaryParameter.LocationGroup))
                {
                    var locationGroupId = int.Parse(Parameters[DictionaryParameter.LocationGroup]);
                    availability = from av in availability
                                   where av.LOCATION.cms_location_group_id == locationGroupId
                                   select av;
                }
                else
                {
                    var areaId = int.Parse(Parameters[DictionaryParameter.Area]);
                    availability = from av in availability
                                   where av.LOCATION.ops_area_id == areaId
                                   select av;
                }
            }
            else if (Parameters.ContainsValueAndIsntEmpty(DictionaryParameter.Pool) ||
                     Parameters.ContainsValueAndIsntEmpty(DictionaryParameter.Region))
            {
                if (Parameters.ContainsValueAndIsntEmpty(DictionaryParameter.Pool))
                {
                    var poolId = int.Parse(Parameters[DictionaryParameter.Pool]);
                    availability = from av in availability
                                   where av.LOCATION.CMS_LOCATION_GROUP.cms_pool_id == poolId
                                   select av;
                }
                else
                {
                    var regionId = int.Parse(Parameters[DictionaryParameter.Region]);
                    availability = from av in availability
                                   where av.LOCATION.OPS_AREA.ops_region_id == regionId
                                   select av;
                }
            }
            else if (Parameters.ContainsValueAndIsntEmpty(DictionaryParameter.LocationCountry))
            {
                var locationCountry = Parameters[DictionaryParameter.LocationCountry];
                availability = from av in availability
                               where av.LOCATION.CMS_LOCATION_GROUP.CMS_POOL.country == locationCountry
                               select av;
            }

            return(availability);
        }