Esempio n. 1
0
        //public FinanceGraphicRecord GraphicRecord { get; set; }

        /// <summary>
        /// Základní konstruktor s povinnými údaji
        /// </summary>
        /// <param name="price">Utracená / získaná částka</param>
        /// <param name="name">Název transakce</param>
        /// <param name="date">Datum uskutečnění transakce</param>
        /// <param name="type">Výdaj / příjem</param>
        /// <param name="category">Kategorie výdaje</param>
        public FinanceRecord(int price, string name, DateTime date, TypeRecord type, Category category
                             , TypeBalance balance)
        {
            Price       = price;
            Name        = name;
            Date        = date;
            TypeRecord  = type;
            Category    = category;
            TypeBalance = balance;
            ID          = Id;
            Id++;
        }
Esempio n. 2
0
        /// <summary>
        /// Validace zadaných údajů do formuláře, tak aby bylo možné vytvořit nový záznam v databázi
        /// </summary>
        /// <param name="price">Částka</param>
        /// <param name="name">Název transakce</param>
        /// <param name="date">Datum transakce</param>
        /// <param name="description">Popis transakce</param>
        /// <param name="place">Místo transakce</param>
        /// <param name="type">Výdaj / příjem</param>
        /// <param name="category">Kategorie výdajů</param>
        public void EnterFinanceRecord(string price, string name, string date, string description, string place, TypeRecord type,
                                       Category category, FinanceRecord record, TypeBalance balance)
        {
            // Pomocné proměnné pro výstup z parsování INT a DATETIME
            DateTime helpDate  = DateTime.Today.Date;
            int      helpPrice = 0;

            // Ošetření vyjímek, tedy pokud uživatel zadá nesmysl, aby byl upozorněn a program nespadl
            if (int.TryParse(price, out helpPrice))
            {
                if (helpPrice < 0)
                {
                    throw new ArgumentException("Zadal jsi částku menší než 0!");
                }
            }
            else
            {
                throw new ArgumentException("Zadal jsi částku ve špatném formátu.");
            }

            if (DateTime.TryParse(date, out helpDate))
            {
                if (helpDate > DateTime.Now)
                {
                    throw new ArgumentException("Zadal jsi datum z budoucnosti");
                }
            }
            else
            {
                throw new ArgumentException("Zadal jsi datum ve špatném formátu. Má vypadat jako 12.10.2020");
            }

            if (name.Count() < 3)
            {
                throw new ArgumentException("Zadal jsi název transakce kratší než 3, jsi si jist ?");
            }

            if (record == null)
            {
                if (description == "" && place == "")
                {
                    admin.EnterEditRecord(0, helpPrice, name, helpDate, "", "", type, category, balance, false, null);
                }
                else
                {
                    admin.EnterEditRecord(0, helpPrice, name, helpDate, place, description, type, category, balance, true, null);
                }
            }
            else
            {
                admin.EnterEditRecord(1, helpPrice, name, helpDate, place, description, type, category, balance, true, record);
            }
        }
Esempio n. 3
0
        EnumValidator(int idCategory, int idType, int idBalance, int idMonth)
        {
            Category    selectCategory = Category.Other;
            TypeRecord  selectType;
            TypeBalance balance;
            Month       selectMonth;

            if (idCategory != -1 && idType != 1)
            {
                selectCategory = (Category)idCategory;
            }
            else
            {
                selectCategory = Category.Other;
            }

            if (idMonth >= 0 && idMonth <= 11)
            {
                selectMonth = (Month)idMonth;
            }
            else
            {
                selectMonth = Month.Other;
            }

            if (idType == 0)
            {
                selectType = TypeRecord.Costs;
            }
            else if (idType == 1)
            {
                selectType = TypeRecord.Income;
            }
            else
            {
                selectType = TypeRecord.Other;
            }

            if (idBalance == 0)
            {
                balance = TypeBalance.BankAccount;
            }
            else if (idBalance == 1)
            {
                balance = TypeBalance.Cash;
            }
            else
            {
                balance = TypeBalance.Other;
            }

            return(selectType, selectCategory, balance, selectMonth);
        }
Esempio n. 4
0
        /// <summary>
        /// Obrácený type EnumValidator - na základě zadaných Enums vytvoří pole ID daných prvků
        /// </summary>
        /// <param name="type">Type transakce Výdaj - Příjem</param>
        /// <param name="category">Kategorie výdajů</param>
        /// <param name="balance">Typ zůstatku Bankovní účet - Hotovost</param>
        /// <returns>[Typ transakce, Kategorie, Typ zůstatku pro platbu]</returns>
        public int[] EnumValidatorReverse(TypeRecord type, Category category, TypeBalance balance)
        {
            int[] ids = new int[3];

            if ((int)category >= 0 && (int)category <= 6)
            {
                ids[0] = (int)category;
            }
            else
            {
                ids[0] = 7;
            }

            if (type == TypeRecord.Costs)
            {
                ids[1] = 0;
            }
            else if (type == TypeRecord.Income)
            {
                ids[1] = 1;
            }
            else
            {
                ids[1] = -1;
            }

            if (balance == TypeBalance.BankAccount)
            {
                ids[2] = 0;
            }
            else if (balance == TypeBalance.Cash)
            {
                ids[2] = 1;
            }
            else
            {
                ids[2] = -1;
            }

            return(ids);
        }
Esempio n. 5
0
        /// <summary>
        /// Metoda pro zadání nového finančního záznamu nebo jeho úpravu, při zadání nového umožňuje zadání všech parametrů nebo pouze povinných
        /// </summary>
        /// <param name="operation">0 - Nový záznam, 1 - upravit stávající</param>
        /// <param name="price">Částka</param>
        /// <param name="name">Název transakce</param>
        /// <param name="date">Datum transakce</param>
        /// <param name="place">Místo uskutečnění transakce</param>
        /// <param name="description">Popis</param>
        /// <param name="type">Výdaj / příjem</param>
        /// <param name="category">Kategorie výdaje</param>
        /// <param name="full">Zda se zadávají všechny parametry</param>
        /// <param name="record">Stávající záznam k upravení</param>
        public void EnterEditRecord(byte operation, int price, string name, DateTime date, string place, string description, TypeRecord type,
                                    Category category, TypeBalance balance, bool full, FinanceRecord record)
        {
            // Zapsání nové transakce v plné výši, uživatel vyplnil všechna pole
            if (operation == 0 && full)
            {
                Records.Add(new FinanceRecord(price, name, date, place, description, type, category, balance));
            }
            // Zapsání nové transakce v nekompletní podobě, uživatel nezadal všechna pole
            else if (operation == 0 && !full)
            {
                Records.Add(new FinanceRecord(price, name, date, type, category, balance));
            }
            // Úpravy zůstatků podle nově zadané transakce
            if (operation == 0 && type == TypeRecord.Costs)
            {
                if ((Balance[(int)balance] - price) > 0)
                {
                    Balance[(int)balance] -= price;
                }
            }
            else if (operation == 0 && type == TypeRecord.Income)
            {
                if ((Balance[(int)balance] + price) > 0)
                {
                    Balance[(int)balance] += price;
                }
            }

            // Úprava stávající transakce
            if (operation == 1)
            {
                // Získání hodnoty v ENUM, tedy pozici v daném enumu 0 - bankovní účet / 1 - hotovost
                int typeBalance_old = (int)record.TypeBalance;
                int typeBalance_new = (int)balance;
                // Původní záznam je výdaj
                if (record.TypeRecord == TypeRecord.Costs)
                {
                    // Přičte se původní suma ke starému zůstaku
                    Balance[typeBalance_old] += record.Price;
                    // Podle toho zda se změnil i typ (Výdaj , příjem) tak se podle toho přičte / odečte
                    if (type == TypeRecord.Costs)
                    {
                        Balance[typeBalance_new] -= price;
                    }
                    else
                    {
                        Balance[typeBalance_new] += price;
                    }
                }
                // Původní záznam je příjem
                else if (record.TypeRecord == TypeRecord.Income)
                {
                    // Odečte se od původního zůstatku
                    Balance[typeBalance_old] -= record.Price;
                    if (type == TypeRecord.Costs)
                    {
                        Balance[typeBalance_new] -= price;
                    }
                    else
                    {
                        Balance[typeBalance_new] += price;
                    }
                }
                // Změním všechny atribity podle nově zadaných hodnot
                record.Price       = price;
                record.Name        = name;
                record.Date        = date;
                record.Place       = place;
                record.Description = description;
                // Změním všechny ENUM členy na nové zadání
                record.TypeRecord  = type;
                record.Category    = category;
                record.TypeBalance = balance;
            }
            SaveFinance(pathFinance);
            SaveBalance(pathBalance);

            SaveFinance(pathFinancePraceD);
            SaveBalance(pathBalancePraceD);
        }
Esempio n. 6
0
        /// <summary>
        /// Metoda, která vyhledá záznamy podle zadaných parametrů, buď podle jedno nebo až tří
        /// </summary>
        /// <param name="category">Kategorie výdajů</param>
        /// <param name="balance">Typ zůstatku bankovní účet nebo hotovost</param>
        /// <param name="month">Měsíc kdy byla transakce uskutečněna</param>
        public void FindRecords(TypeRecord type, Category category, TypeBalance balance, Month month)
        {
            // Nalezené záznamy
            ObservableCollection <FinanceRecord> findRecords = new ObservableCollection <FinanceRecord>();
            // Pomocná kolekce pro uložení mezivýsledku
            ObservableCollection <FinanceRecord> helpRecords = new ObservableCollection <FinanceRecord>();

            // Uživatel zadal měsíc pro vyhledávání
            if (month != Month.Other)
            {
                // Prochází záznamy a ukládá ty, které se shodují v měsící
                foreach (FinanceRecord record in Records)
                {
                    if (record.Date.Month == (int)month + 1)
                    {
                        findRecords.Add(record);
                    }
                }
            }
            // Uživatel zadal kategorii - pokud zadal i měsíc, vezmou se výsledky z toho hledání a v nich se hledá shoda s kategoriíí
            // v opačném případě se prochází kompletní kolekce záznamů
            if (category != Category.Other)
            {
                // Získaná kolekce z předchozí podmínky je uložena do jiné proměnné a původní se naváže na prázdnou kolekci
                if (findRecords.Count != 0)
                {
                    helpRecords = findRecords;
                    findRecords = new ObservableCollection <FinanceRecord>();
                }

                else
                {
                    helpRecords = Records;
                }
                // Pokud se shoduje kategorie záznamu, přidá se do kolekce
                foreach (FinanceRecord record in helpRecords)
                {
                    if (record.Category == category)
                    {
                        findRecords.Add(record);
                    }
                }
            }
            // Uživatel zadal typ balancu - Bankovní účet nebo hotovost
            if (balance != TypeBalance.Other)
            {
                if (findRecords.Count != 0)
                {
                    helpRecords = findRecords;
                    findRecords = new ObservableCollection <FinanceRecord>();
                }
                else
                {
                    helpRecords = Records;
                }

                foreach (FinanceRecord record in helpRecords)
                {
                    // Shoduje se typ zůstatku podle nastavení filtru
                    if (record.TypeBalance == balance)
                    {
                        findRecords.Add(record);
                    }
                }
            }
            // Výdaje nebo příjmy
            if (type != TypeRecord.Other)
            {
                if (findRecords.Count != 0)
                {
                    helpRecords = findRecords;
                    findRecords = new ObservableCollection <FinanceRecord>();
                }
                else
                {
                    helpRecords = Records;
                }

                foreach (FinanceRecord record in helpRecords)
                {
                    // Porovnání podle toho zda se jedná o Výdaj nebo o Příjem
                    if (record.TypeRecord == type)
                    {
                        findRecords.Add(record);
                    }
                }
            }
            findRecord = findRecords;
        }
Esempio n. 7
0
 /// <summary>
 /// Metoda, která vyhledá záznamy podle zadaných parametrů, buď podle jedno nebo až tří
 /// </summary>
 /// <param name="category">Kategorie výdajů</param>
 /// <param name="balance">Typ zůstatku bankovní účet nebo hotovost</param>
 /// <param name="month">Měsíc kdy byla transakce uskutečněna</param>
 public void FindFinanceRecords(TypeRecord type, Category category, TypeBalance balance, Month month)
 {
     admin.FindRecords(type, category, balance, month);
     ViewGraphicFinance(3, true, false);
 }