Exemplo n.º 1
0
        private void MonthUseListFill()
        {
            using (db = new MyDBContext())
            {
                db.ViewResults.Load();
                var qrySource = from o in db.ViewResults.ToList()
                                where o.Year * 100 + o.Month >= StartYear * 100 + StartMonth
                                where o.Year * 100 + o.Month <= EndYear * 100 + EndMonth
                                where o.IdEnergyResource == SelectedER
                                where SelectedCostCenter == 0 ? true : o.IdCostCenter == SelectedCostCenter
                                group o by new { o.IdEnergyResource, o.Period } into gr
                orderby gr.Max(m => m.Year), gr.Max(m => m.Month)
                select new ViewResult
                {
                    IdEnergyResource = gr.Key.IdEnergyResource,
                    Period           = gr.Key.Period,
                    ResourceName     = gr.Max(m => m.ResourceName),
                    Year             = gr.Max(m => m.Year),
                    Month            = gr.Max(m => m.Month),
                    UnitName         = gr.Max(m => m.UnitName),
                    Plan             = gr.Sum(m => m.Plan),
                    Fact             = gr.Sum(m => m.Fact),
                    Difference       = gr.Sum(m => m.Difference),
                    PlanCost         = gr.Sum(m => m.PlanCost),
                    FactCost         = gr.Sum(m => m.FactCost),
                    DifferenceCost   = gr.Sum(m => m.DifferenceCost),
                    IsMain           = gr.Max(m => m.IsMain)
                };
                MonthUseList.Clear();
                MonthUseList = Global.ObservableCollection <ViewResult>(qrySource);

                MonthUseTotalList.Clear();
                MonthUseTotalList.Add(new ViewResult()
                {
                    Period         = "ИТОГО:",
                    Plan           = MonthUseList.Sum(n => n.Plan),
                    Fact           = MonthUseList.Sum(n => n.Fact),
                    Difference     = MonthUseList.Sum(n => n.Difference),
                    PlanCost       = MonthUseList.Sum(n => n.PlanCost),
                    FactCost       = MonthUseList.Sum(n => n.FactCost),
                    DifferenceCost = MonthUseList.Sum(n => n.DifferenceCost)
                });
            }
        }
Exemplo n.º 2
0
        private void MonthUseListFill()
        {
            using (db = new MyDBContext())
            {
                db.ViewResults.Load();
                var qrySource = from o in db.ViewFabricateUses.ToList()
                                where o.Year * 100 + o.Month >= StartYear * 100 + StartMonth
                                where o.Year * 100 + o.Month <= EndYear * 100 + EndMonth
                                where o.IdProduct == SelectedER
                                group o by new { o.IdProduct, o.Period } into gr
                orderby gr.Max(m => m.Year), gr.Max(m => m.Month)
                select new ViewFabricateUse
                {
                    IdProduct = gr.Key.IdProduct,
                    Period    = gr.Key.Period,
                    ERName    = gr.Max(m => m.ERName),
                    Year      = gr.Max(m => m.Year),
                    Month     = gr.Max(m => m.Month),
                    UnitName  = gr.Max(m => m.UnitName),
                    Fabricate = gr.Sum(m => m.Fabricate),
                    Fact1     = gr.Sum(m => m.Fact1),
                    Fact0     = gr.Sum(m => m.Fact0),
                    Loss      = gr.Sum(m => m.Loss)
                };
                MonthUseList.Clear();
                MonthUseList = Global.ObservableCollection <ViewFabricateUse>(qrySource);

                FabricateUseTotalList.Clear();
                FabricateUseTotalList.Add(new ViewFabricateUse()
                {
                    Period    = "ИТОГО:",
                    Fabricate = MonthUseList.Sum(n => n.Fabricate),
                    Fact1     = MonthUseList.Sum(n => n.Fact1),
                    Fact0     = MonthUseList.Sum(n => n.Fact0),
                    Loss      = MonthUseList.Sum(n => n.Loss)
                });
            }
        }
Exemplo n.º 3
0
        private void MonthUseListFill()
        {
            using (db = new MyDBContext())
            {
                db.ViewResults.Load();
                db.EnergyResources.Load();
                db.ViewLossesFacts.Load();

                var qrySource = from o in db.ViewResults.Local.ToList()
                                where o.Year * 100 + o.Month >= StartYear * 100 + StartMonth
                                where o.Year * 100 + o.Month <= EndYear * 100 + EndMonth
                                join a in db.EnergyResources.ToList() on o.IdEnergyResource equals a.Id
                                where a.IsPrime == 1
                                group o by new { o.IdEnergyResource } into gr
                //orderby gr.Sum(m => m.FactCost) descending
                    select new
                {
                    IdEnergyResource = gr.Key.IdEnergyResource,
                    ResourceName     = gr.Max(m => m.ResourceName),
                    Year             = gr.Max(m => m.Year),
                    Month            = gr.Max(m => m.Month),
                    UnitName         = gr.Max(m => m.UnitName),
                    Plan             = gr.Sum(m => m.Plan),
                    Fact             = gr.Sum(m => m.Fact),
                    Difference       = gr.Sum(m => m.Difference),
                    PlanCost         = gr.Sum(m => m.PlanCost),
                    FactCost         = gr.Sum(m => m.FactCost),
                    DifferenceCost   = gr.Sum(m => m.DifferenceCost),
                };
                var qry1 = from o in db.ViewLossesFacts
                           where o.Year * 100 + o.Month >= StartYear * 100 + StartMonth
                           where o.Year * 100 + o.Month <= EndYear * 100 + EndMonth
                           group o by new { o.IdEnergyResource } into gr
                    select new
                {
                    IdEnergyResource = gr.Key.IdEnergyResource,
                    Year             = gr.Max(m => m.Year),
                    Month            = gr.Max(m => m.Month),
                    Loss             = gr.Sum(m => m.FactLoss),
                    Total            = gr.Sum(m => m.FactTotal),
                };


                var qry = from o in qrySource.ToList()
                          join b in qry1.ToList() on new { o.IdEnergyResource, o.Year, o.Month } equals new { b.IdEnergyResource, b.Year, b.Month }
                select new PrimeERFull
                {
                    IdEnergyResource = o.IdEnergyResource,
                    ResourceName     = o.ResourceName,
                    Year             = o.Year,
                    Month            = o.Month,
                    UnitName         = o.UnitName,
                    Plan             = o.Plan,
                    Fact             = o.Fact,
                    Difference       = o.Difference,
                    PlanCost         = o.PlanCost,
                    FactCost         = o.FactCost,
                    DifferenceCost   = o.DifferenceCost,
                    Loss             = b.Loss,
                    Total            = b.Total,
                    LossCost         = b.Loss * o.FactCost / o.Fact,
                    TotalCost        = b.Total * o.FactCost / o.Fact
                };

                MonthUseList.Clear();
                MonthUseList = Global.ObservableCollection <PrimeERFull>(qry);


                MonthUseTotalList.Clear();
                MonthUseTotalList.Add(new PrimeERFull()
                {
                    Period         = "ИТОГО:",
                    PlanCost       = MonthUseList.Sum(n => n.PlanCost),
                    FactCost       = MonthUseList.Sum(n => n.FactCost),
                    DifferenceCost = MonthUseList.Sum(n => n.DifferenceCost),
                    TotalCost      = MonthUseList.Sum(n => n.TotalCost),
                    LossCost       = MonthUseList.Sum(n => n.LossCost)
                });
            }
        }