Exemplo n.º 1
0
        /// <summary>
        /// Spočítá veškeré parametry pro vyhodnocení statistiky za měsíc či rok - denní útrata, měsíční výdaje - příjmy apod
        /// </summary>
        /// <param name="month">Měsíc pro který se počítá statistika</param>
        /// <param name="year">Rok pro který se počítá statistika, vyplnit vždy i pro měsíc</param>
        /// <param name="type">0 - Výpočet dat pro MĚSÍC *** 1 - Výpočet dat pro ROK</param>
        /// <returns>Měsíc 10 hodnot ** Rok 17 hodnot ** Příjmy, Výdaje, Rozdíl, Denní a Týdenní
        /// ,* Výdaje dle týdnů 5,* Výdajů dle měsíce 12</returns>
        public List <double> CalculateStatisticParametres(Month month, int year, byte type)
        {
            List <double> ResultReport = new List <double>();
            // Roční parametry
            double YearIncome    = 0;
            double YearCosts     = 0;
            double YearDifferent = 0;
            // Měsíční parametry
            double MonthIncome    = 0;
            double MonthCost      = 0;
            double MonthDifferent = 0;
            // Roční ukazatele - denní útrata, průměrná týdení útrata, měsíční útrata
            double Year_DayAverageCosts  = 0;
            double Year_WeekAverageCosts = 0;
            // Měsíční ukazatele - denní útrata, týdenní průměrná útrata
            double Month_DayAverageCosts  = 0;
            double Month_WeekAverageCosts = 0;

            // Výdaje v konkrétních týdnech
            double[]        WeekCosts  = new double[5];
            double[]        MonthCosts = new double[12];
            List <DateTime> weeks      = new List <DateTime>();

            if (type == 0)
            {
                weeks = Week.GetWeek(((int)month + 1), year);
            }
            // Prochází se všechny finanční záznamy
            foreach (FinanceRecord record in Records)
            {
                // Požadavek na výpočet pro měsíc, a měsíc záznamu je shodný s počítaným
                if (type == 0 && record.Date.Year == year)
                {
                    // Příjmy
                    if (record.Date.Month == (int)month + 1 && record.TypeRecord == TypeRecord.Income)
                    {
                        MonthIncome += record.Price;
                    }
                    // Výdaje
                    else if (record.Date.Month == (int)month + 1 && record.TypeRecord == TypeRecord.Costs)
                    {
                        MonthCost += record.Price;
                    }
                    DateTime day = record.Date;
                    // Jedná se o výdaj a měsíc je buď ten vybraný nebo předchozí, nebo budoucí (kvůli tomu, že ve výpisu je první týden od minulého měsíce a poslední zasahuje
                    // někdy do dalšího měsíce)                                 Aktuální měsíc                  Předchozí měsíc                     Budoucí měsíc
                    if (record.TypeRecord == TypeRecord.Costs && (record.Date.Month == (int)month + 1 || record.Date.Month == (int)month) || record.Date.Month == (int)month + 2)
                    {
                        // Výdaje pro každý konkrétní týden v měsíci
                        if (day >= weeks[0] && day <= weeks[1])
                        {
                            WeekCosts[0] += record.Price;
                        }
                        else if (day >= weeks[2] && day <= weeks[3])
                        {
                            WeekCosts[1] += record.Price;
                        }
                        else if (day >= weeks[4] && day <= weeks[5])
                        {
                            WeekCosts[2] += record.Price;
                        }
                        else if (day >= weeks[6] && day <= weeks[7])
                        {
                            WeekCosts[3] += record.Price;
                        }
                        // Ošetření pro případ kdy budou v měsíci pouze 4 týdny
                        if (weeks.Count == 10)
                        {
                            if (day >= weeks[8] && day <= weeks[9])
                            {
                                WeekCosts[4] += record.Price;
                            }
                        }
                    }
                }
                // Výpočet parametrů pro ROK
                else if (record.Date.Year == year && type == 1)
                {
                    if (record.TypeRecord == TypeRecord.Income)
                    {
                        YearIncome += record.Price;
                    }
                    else if (record.TypeRecord == TypeRecord.Costs)
                    {
                        YearCosts += record.Price;
                        MonthCosts[record.Date.Month - 1] += record.Price;
                    }
                }
            }
            // Průměrné výdaje - den, týden a měsíc pro roční výpočty
            if (type == 0 && MonthIncome != 0 && MonthCost != 0)
            {
                MonthDifferent         = MonthIncome - MonthCost;
                Month_DayAverageCosts  = Math.Round(MonthCost / DateTime.DaysInMonth(year, (int)month + 1));
                Month_WeekAverageCosts = Math.Round(MonthCost / 4.35);
            }
            // Průměrné výdaje - den, týden pro měsíční výpočty
            else if (type == 1 && YearIncome != 0 && YearCosts != 0)
            {
                YearDifferent         = YearIncome - YearCosts;
                Year_DayAverageCosts  = Math.Round(YearCosts / 365.25);
                Year_WeekAverageCosts = Math.Round(YearCosts / 52.18);
            }
            // Uložení všech získaných hodnot do kolekce, podle toho zda se počítá ROK či Měsíc
            // Měsíc - kolekce obsahuje 10 záznamů
            // Rok - kolekce obsahuje 6 hodnot
            if (type == 0)
            {
                ResultReport.Add(MonthIncome);
                ResultReport.Add(MonthCost);
                ResultReport.Add(MonthDifferent);


                ResultReport.Add(Month_DayAverageCosts);
                ResultReport.Add(Month_WeekAverageCosts);
                foreach (double d in WeekCosts)
                {
                    ResultReport.Add(d);
                }
            }

            if (type == 1)
            {
                ResultReport.Add(YearIncome);
                ResultReport.Add(YearCosts);
                ResultReport.Add(YearDifferent);
                ResultReport.Add(Year_DayAverageCosts);
                ResultReport.Add(Year_WeekAverageCosts);
                foreach (double cost in MonthCosts)
                {
                    ResultReport.Add(cost);
                }
            }
            return(ResultReport);
        }
Exemplo n.º 2
0
        /// <summary>
        /// Metoda najde ve třídní kolekci záznamy, které odpovídají volbě
        /// </summary>
        /// <param name="selectProjectID">ID projektu</param>
        /// <param name="choice">TRUE - Měsíční bloky (rok), FALSE - Týdenní bloky (mesic)</param>
        /// <param name="month">Měsíc 1 - LEDEN</param>
        /// <param name="year">Rok -- první je 2020</param>
        /// <returns>Projekt k zobrazení</returns>
        public List <WorkMonthWeekOverview> CalculateOverview(int selectProjectID, int year, int month, bool choice)
        {
            // Kolekce pro uložení grafických záznamů přehledu
            List <WorkMonthWeekOverview> records = new List <WorkMonthWeekOverview>();

            string[] monthName = new string[] { "Leden", "Únor", "Březen", "Duben", "Květen", "Červen",
                                                "Červenec", "Srpen", "Září", "Říjen", "Listopad", "Prosinec" };
            // Pracovních dní
            int[] workDays;
            // Odpracováno hodin
            decimal[] realHours;
            // Plánováno hodin
            decimal[] planHours;
            // Průměrná pracovní doba
            int[] average;
            // Kolekce obsahující první konečný den pro každý týden v daném měsíci
            List <DateTime> weeks = Week.GetWeek(month, year);

            // FALSE - měsíční přehled * týdenní bloky
            if (!choice)
            {
                // Pole pro uložení pracovních dní -- počet prvků pole jako počet týdnů -- [0] - 1. týden atd
                workDays = new int[weeks.Count / 2];
                // Pole pro uložení pracovních hodin
                realHours = new decimal[weeks.Count / 2];
                // Pole pro uložení plánovaných hodin
                planHours = new decimal[weeks.Count / 2];
                // Průměrná doba práce
                average = new int[weeks.Count / 2];

                foreach (WorkProject project in Projects)
                {
                    foreach (WorkRecord record in project.Records)
                    {
                        DateTime day = record.Date;
                        // Prochází se všechny záznamy, všech projektů
                        //      - pro každý týden se uloží daná hodnota
                        //      - [0] - 1. týden, [1] - 2. týden až [4] - 5. týden měsíce
                        if (day >= weeks[0] && day <= weeks[1])
                        {
                            workDays[0]++;
                            realHours[0] += record.RealTime;
                            planHours[0] += record.PlanTime;
                        }
                        else if (day >= weeks[2] && day <= weeks[3])
                        {
                            workDays[1]++;
                            realHours[1] += record.RealTime;
                            planHours[1] += record.PlanTime;
                        }
                        else if (day >= weeks[4] && day <= weeks[5])
                        {
                            workDays[2]++;
                            realHours[2] += record.RealTime;
                            planHours[2] += record.PlanTime;
                        }
                        else if (day >= weeks[6] && day <= weeks[7])
                        {
                            workDays[3]++;
                            realHours[3] += record.RealTime;
                            planHours[3] += record.PlanTime;
                        }
                        // Měsíc obsahuje 5 týdnů
                        if (weeks.Count == 10)
                        {
                            if (day >= weeks[8] && day <= weeks[9])
                            {
                                workDays[4]++;
                                realHours[4] += record.RealTime;
                                planHours[4] += record.PlanTime;
                            }
                        }
                    }
                }
            }
            // TRUE - roční přehled * měsíční bloky
            else
            {
                // Pole o velikosti 12 - každé id pole je jeden měsíc [0] - LEDEN až [11] - PROSINEC
                workDays  = new int[12];
                realHours = new decimal[12];
                planHours = new decimal[12];
                average   = new int[12];
                int[] monthsId = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 };

                foreach (WorkProject project in Projects)
                {
                    foreach (WorkRecord record in project.Records)
                    {
                        if (record.Date.Year == year)
                        {
                            int id = Array.IndexOf(monthsId, record.Date.Month);

                            workDays[id]++;
                            realHours[id] += record.RealTime;
                            planHours[id] += record.PlanTime;
                        }
                    }
                }
            }
            // Měsíční přehled
            if (!choice)
            {
                int k = 0;
                for (int i = 0; i < 5; i++)
                {
                    // Datum týdne Od - Do
                    string weekText = weeks[k].ToString("dd.MM") + " - " + weeks[k + 1].ToString("dd.MM");
                    // Průměrná délka pracovní doby
                    if (workDays[i] != 0)
                    {
                        average[i] = (int)Math.Round((realHours[i] * 60) / workDays[i]);
                    }
                    WorkMonthWeekOverview graphic = new WorkMonthWeekOverview(workDays[i], (int)Math.Round(realHours[i])
                                                                              , (int)Math.Round(planHours[i]), new TimeSpan(0, average[i], 0)
                                                                              , weekText, year.ToString());

                    records.Add(graphic);
                    k += 2;
                }
            }
            // Roční přehled
            else
            {
                for (int i = 0; i < 12; i++)
                {
                    if (workDays[i] != 0)
                    {
                        average[i] = (int)Math.Round((realHours[i] * 60) / workDays[i]);
                    }
                    WorkMonthWeekOverview graphic = new WorkMonthWeekOverview(workDays[i], (int)Math.Round(realHours[i])
                                                                              , (int)Math.Round(planHours[i]), new TimeSpan(0, average[i], 0)
                                                                              , monthName[i], year.ToString());

                    records.Add(graphic);
                }
            }
            // Stanovení stran pro každý jednotlivý záznam přehledu
            UpdateSetPage(records, null);
            return(records);
        }
Exemplo n.º 3
0
        /// <summary>
        /// Spočítá veškeré parametry pro vyhodnocení statistiky za měsíc či rok - denní útrata, měsíční výdaje - příjmy apod
        /// </summary>
        /// <param name="month">Měsíc ve kterém se spočítá statistika</param>
        /// <param name="yearString">Rok ve kterém se spočítá statistika</param>
        /// <param name="type">0 - Výpočet pro měsíc ** 1 - Výpočet pro rok</param>
        public void CalculateStatisticParametres(int month, string yearString, byte type)
        {
            int.TryParse(yearString, out int year);
            // Získám měsíc ve výčtovém typu
            Month monthType = Month.Other;

            if (month >= 0 && month <= 12)
            {
                monthType = (Month)month;
            }
            // Kolekce, která obsahuje první a konečný den zkoumaných týdnů
            List <DateTime> weeks  = Week.GetWeek(month + 1, year);
            List <double>   result = new List <double>();

            // Data pro měsíc nebo pro rok
            if (monthType != Month.Other && type == 0)
            {
                result = admin.CalculateStatisticParametres(monthType, year, type);
            }
            else if (type == 1)
            {
                result = admin.CalculateStatisticParametres(Month.Other, year, type);
            }
            // Vzdálenosti záznamů od sebe
            int headHeight = 35;
            // Výška jednoho řádků
            int heightChange = 22;
            // Pomocná proměnná, která obsahuje pozici pro vykreslení nového objektu
            int sumHeight = 0;
            // Výška předělů ve vykreslení - tmavě zelené bloky
            int splitHeight = 0;
            // Pomocné incrementy
            int n        = 0;
            int monthInc = 0;
            int inc      = 0;

            canvas.Children.Clear();
            string[] names = new string[] { "Příjmy", "Výdaje", "Bilance", "Den", "Týden", "Týden", "Týden", "Týden", "Týden", "Týden",
                                            "Leden", "Únor", "Březen", "Duben", "Květen", "Červen", "Červenec", "Srpen", "Září", "Říjen", "Listopad", "Prosinec" };
            // Pro každou získanou honotu ze správce se vykreslí řádek - modrý a bílý obdelník + název a suma
            for (int i = 0; i < result.Count; i++)
            {
                sumHeight = i * headHeight;
                if (i > 4)
                {
                    if (type == 0)
                    {
                        heightChange = 50;
                        sumHeight    = 5 * 35 + ((i - 5) * 55);
                    }
                    else if (type == 1)
                    {
                        heightChange = 22;
                        sumHeight    = i * 35;
                    }
                }

                if (type == 1 && i == 5)
                {
                    monthInc += 5;
                }
                // Získání grafických objektů pro vykreslení na plátno - generuje je statická třída GRAPHIC
                (Rectangle left, Rectangle right, TextBlock name, TextBlock price) =
                    Graphic.BlueWhitePanel(names[i + monthInc], result[i].ToString(), new int[] { 200, 100 }, new int[] { heightChange, 22 }, new int[] { 3, 3 });
                // Přiřezení objektů na plátno
                canvas.Children.Add(left);
                canvas.Children.Add(right);
                canvas.Children.Add(name);
                canvas.Children.Add(price);
                // Vykreslení tmavě zeleného předělů v definovaných místech plátna
                if (i == 0 || i == 3 || i == 5)
                {
                    string[] splitNames = new string[] { "Základní informace", "Průměrné výdaje", "Týdení výdaje", "Měsíční výdaje" };
                    (Rectangle split_rectangle, TextBlock split_text) =
                        Graphic.SplitPanel(30, 425, 3, new SolidColorBrush(Color.FromArgb(255, 20, 82, 87)), splitNames[n]);
                    n++;
                    // Pro vykreslení ROKU - přeskočí název Týdenní výdaje a použije Měsíční výdaje
                    if (type == 1 && n == 2)
                    {
                        n++;
                    }

                    canvas.Children.Add(split_rectangle);
                    canvas.Children.Add(split_text);
                    // Tmavě zelený obdelník, který odděluje bloky
                    Canvas.SetLeft(split_rectangle, 5); Canvas.SetTop(split_rectangle, 8 + sumHeight + splitHeight);
                    // Popis předělovacího bloku - NADPIS SEKCE
                    Canvas.SetLeft(split_text, 150); Canvas.SetTop(split_text, 10 + sumHeight + splitHeight);
                    splitHeight += 35;
                }
                // Podmínka pro vykreslení datumů pro týdny
                if (type == 0 && i > 4)
                {
                    TextBlock weekDate = new TextBlock
                    {
                        FontSize   = 15,
                        FontWeight = FontWeights.Bold,
                        Foreground = Brushes.Black,
                        Text       = "- " + weeks[inc].ToShortDateString() + " - " + weeks[inc + 1].ToShortDateString()
                    };

                    canvas.Children.Add(weekDate);
                    Canvas.SetLeft(weekDate, 20); Canvas.SetTop(weekDate, 35 + sumHeight + splitHeight);
                    if (inc < result.Count - 1)
                    {
                        inc += 2;
                    }
                }

                // Obdelnik pod typem zůstatku -- Světle modrá
                Canvas.SetLeft(left, 10); Canvas.SetTop(left, 10 + sumHeight + splitHeight);
                // Obdelnik pod hodnotou zůstatku -- bílý
                Canvas.SetLeft(right, 230); Canvas.SetTop(right, 10 + sumHeight + splitHeight);
                // Typ zůstatku Bankovní účet nebo Hotovost
                Canvas.SetLeft(name, 15); Canvas.SetTop(name, 10 + sumHeight + splitHeight);
                // Hodnota zůstatku v dané platformě
                Canvas.SetLeft(price, 290); Canvas.SetTop(price, 10 + sumHeight + splitHeight);
            }
        }