public List <ForecastedFleetSizeEntity> AttachAdditionPlans(List <SummedByWeekForecastHolder> forecast
                                                                    , int additionPlanId)
        {
            var minMaxData   = AdditionPlanMinMaxValueFilter.GetAdditionPlanMinMaxValues(DataContext, Parameters);
            var additionData = AdditionPlanEntryFilter.GetAdditionPlanEntries(DataContext, Parameters);

            var groupedMinMaxData = from apd in minMaxData
                                    where apd.AdditionPlanId == additionPlanId
                                    group apd by new { apd.Week, apd.Year }
            into groupedData
                select new
            {
                groupedData.Key.Year,
                groupedData.Key.Week,
                Max = groupedData.Sum(d => d.MaxFleet),
                Min = groupedData.Sum(d => d.MinFleet),
            };

            var groupedAdditionData = from apd in additionData
                                      where apd.AdditionPlanId == additionPlanId
                                      group apd by new { apd.Week, apd.Year }
            into groupedData
                select new
            {
                groupedData.Key.Year,
                groupedData.Key.Week,
                Additions = groupedData.Sum(d => d.Additions),
            };

            var localAdditionData = groupedAdditionData.ToList();

            var groupedForecast = from fe in forecast
                                  join mmd in groupedMinMaxData on
                                  new { fe.Year, fe.Week }
            equals new { mmd.Year, mmd.Week }
            into joinedMmd
            from jMmd in joinedMmd.DefaultIfEmpty()
            orderby fe.Year, fe.Week
                select new ForecastedFleetSizeEntity
            {
                Year                     = fe.Year,
                Week                     = fe.Week,
                ExpectedFleet            = fe.ExpectedFleet,
                Nessesary                = fe.NessesaryFleet,
                UnConstrained            = fe.Unconstrained,
                ExpectedWithAdditionPlan = fe.ExpectedFleet
                                           + localAdditionData.Where(d => d.Year < fe.Year || (d.Year == fe.Year && d.Week <= fe.Week)
                                                                     ).Sum(d => d.Additions),
                MaxFleet = jMmd == null ? 0 : jMmd.Max,
                MinFleet = jMmd == null ? 0 : jMmd.Min
            };

            var returned = groupedForecast.ToList();

            return(returned);
        }
Exemple #2
0
        public IQueryable <AdttionPlanHolder> GetQuerysFromPlan(int queryPlanId)
        {
            var additionData        = AdditionPlanEntryFilter.GetAdditionPlanEntries(DataContext, Parameters);
            var additionPlanEntries = from apd in additionData
                                      join wtm in DataContext.IsoWeekToMonths on
                                      new { apd.Week, apd.Year } equals new
            { Week = wtm.IsoWeekNumber, wtm.Year }
            where apd.AdditionPlanId == queryPlanId
            group apd by new { wtm.Month, apd.Year, apd.CarGroupId, apd.LocationId }
            into groupedData
                select new AdttionPlanHolder
            {
                Year       = groupedData.Key.Year,
                Month      = groupedData.Key.Month,
                CarGroupId = groupedData.Key.CarGroupId,
                LocationId = groupedData.Key.LocationId,
                Additions  = groupedData.Sum(d => d.Additions),
            };

            return(additionPlanEntries);
        }
        public List <SiteComparisonEntity> GetComparisonEntities(int additionPlanId, int weeksInFuture)
        {
            var additions = AdditionPlanEntryFilter.GetAdditionPlanEntries(DataContext, Parameters);


            var currentDate  = DataContext.FleetHistories.Max(d => d.Timestamp);
            var futureTarget = currentDate.AddDays(weeksInFuture * 7);
            var targetWeek   = DataContext.IsoWeekOfYears.First(d => d.Day == futureTarget).WeekOfYear;
            var targetYear   = futureTarget.Year;


            additions = additions.Where(d => d.AdditionPlanId == additionPlanId &&
                                        ((d.Week <= targetWeek && d.Year == targetYear) ||
                                         d.Year < targetYear));


            IQueryable <SiteComparisonEntity> comparisonEntites;

            if (Parameters.ContainsValueAndIsntEmpty(DictionaryParameter.Location) ||
                Parameters.ContainsValueAndIsntEmpty(DictionaryParameter.LocationGroup))
            {
                comparisonEntites = from mmd in additions
                                    group mmd by new { LocGrouping = mmd.LOCATION.location1, mmd.Week, mmd.Year }
                into groupedData
                    select new SiteComparisonEntity
                {
                    Location  = groupedData.Key.LocGrouping,
                    Year      = groupedData.Key.Year,
                    Week      = groupedData.Key.Week,
                    Additions = groupedData.Sum(d => d.Additions),
                };
            }
            else if (Parameters.ContainsValueAndIsntEmpty(DictionaryParameter.Pool))
            {
                comparisonEntites = from mmd in additions
                                    group mmd by
                                    new { LocGrouping = mmd.LOCATION.CMS_LOCATION_GROUP.cms_location_group1, mmd.Week, mmd.Year }
                into groupedData
                    select new SiteComparisonEntity
                {
                    Location  = groupedData.Key.LocGrouping,
                    Year      = groupedData.Key.Year,
                    Week      = groupedData.Key.Week,
                    Additions = groupedData.Sum(d => d.Additions),
                };
            }
            else if (Parameters.ContainsValueAndIsntEmpty(DictionaryParameter.LocationCountry))
            {
                comparisonEntites = from mmd in additions
                                    group mmd by
                                    new { LocGrouping = mmd.LOCATION.CMS_LOCATION_GROUP.CMS_POOL.cms_pool1, mmd.Week, mmd.Year }
                into groupedData
                    select new SiteComparisonEntity
                {
                    Location  = groupedData.Key.LocGrouping,
                    Year      = groupedData.Key.Year,
                    Week      = groupedData.Key.Week,
                    Additions = groupedData.Sum(d => d.Additions),
                };
            }
            else
            {
                comparisonEntites = from mmd in additions
                                    group mmd by
                                    new
                {
                    LocGrouping = mmd.LOCATION.CMS_LOCATION_GROUP.CMS_POOL.COUNTRy1.country_description,
                    mmd.Week,
                    mmd.Year
                }
                into groupedData
                    select new SiteComparisonEntity
                {
                    Location  = groupedData.Key.LocGrouping,
                    Year      = groupedData.Key.Year,
                    Week      = groupedData.Key.Week,
                    Additions = groupedData.Sum(d => d.Additions),
                };
            }

            var returned = comparisonEntites.ToList();

            return(returned);
        }
        public List <FleetComparisonEntity> GetComparisonEntities(int additionPlanId, int weeksInFuture)
        {
            var additions = AdditionPlanEntryFilter.GetAdditionPlanEntries(DataContext, Parameters);

            var currentDate  = DataContext.FleetHistories.Max(d => d.Timestamp);
            var futureTarget = currentDate.AddDays(weeksInFuture * 7);
            var targetWeek   = DataContext.IsoWeekOfYears.First(d => d.Day == futureTarget).WeekOfYear;
            var targetYear   = futureTarget.Year;


            additions = additions.Where(d => d.AdditionPlanId == additionPlanId &&
                                        ((d.Week <= targetWeek && d.Year == targetYear) ||
                                         d.Year < targetYear));
            IQueryable <FleetComparisonEntity> comparisonEntites;



            if (Parameters.ContainsValueAndIsntEmpty(DictionaryParameter.CarGroup) ||
                Parameters.ContainsValueAndIsntEmpty(DictionaryParameter.CarClass))
            {
                comparisonEntites = from mmd in additions
                                    group mmd by new { FleetGroup = mmd.CAR_GROUP.car_group1, mmd.Week, mmd.Year }
                into groupedData
                    select new FleetComparisonEntity
                {
                    FleetGroupName = groupedData.Key.FleetGroup,
                    Year           = groupedData.Key.Year,
                    Week           = groupedData.Key.Week,
                    Additions      = groupedData.Sum(d => d.Additions),
                };
            }
            else if (Parameters.ContainsValueAndIsntEmpty(DictionaryParameter.CarSegment))
            {
                comparisonEntites = from mmd in additions
                                    group mmd by new { FleetGroup = mmd.CAR_GROUP.CAR_CLASS.car_class1, mmd.Week, mmd.Year }
                into groupedData
                    select new FleetComparisonEntity
                {
                    FleetGroupName = groupedData.Key.FleetGroup,
                    Year           = groupedData.Key.Year,
                    Week           = groupedData.Key.Week,
                    Additions      = groupedData.Sum(d => d.Additions),
                };
            }
            else if (Parameters.ContainsValueAndIsntEmpty(DictionaryParameter.OwningCountry))
            {
                comparisonEntites = from mmd in additions
                                    group mmd by new { FleetGroup = mmd.CAR_GROUP.CAR_CLASS.CAR_SEGMENT.car_segment1, mmd.Week, mmd.Year }
                into groupedData
                    select new FleetComparisonEntity
                {
                    FleetGroupName = groupedData.Key.FleetGroup,
                    Year           = groupedData.Key.Year,
                    Week           = groupedData.Key.Week,
                    Additions      = groupedData.Sum(d => d.Additions),
                };
            }
            else
            {
                comparisonEntites = from mmd in additions
                                    group mmd by new { FleetGroup = mmd.CAR_GROUP.CAR_CLASS.CAR_SEGMENT.COUNTRy1.country_description, mmd.Week, mmd.Year }
                into groupedData
                    select new FleetComparisonEntity
                {
                    FleetGroupName = groupedData.Key.FleetGroup,
                    Year           = groupedData.Key.Year,
                    Week           = groupedData.Key.Week,
                    Additions      = groupedData.Sum(d => d.Additions),
                };
            }

            var returned = comparisonEntites.ToList();

            return(returned);
        }