VYSOKÁ ŠKOLA POLYTECHNICKÁ JIHLAVA Katedra technických studií Obor Počítačové systémy
I m p l e m e n t a c e ú č e t n í h o p ro g r a m u p ro ú č e l y SDH Česká Bělá bakalářská práce
Autor: David Kubát Vedoucí práce: Ing. Marek Musil Jihlava 2016
Abstrakt Bakalářská práce Implementace účetního programu pro účely SDH Česká Bělá se zabývá analýzou a implementací účetního systému pro potřeby spolku. Popisuje důvody pro tvorbu vlastního systému a porovnává podobné systémy dostupné na trhu. Následně analyzuje dostupné možnosti pro implementaci jednotlivých částí výsledné aplikace a zdůvodňuje jejich výběr. Další kapitoly popisují a hodnotí možnosti kolekcí v jazyce C#.NET a jejich využití v navržené aplikaci. Závěr je věnován stručné demonstraci práce s aplikací.
Klíčová slova .Net Framework, C#, databáze, kolekce, LINQ, účetní systém
Abstract The bachelor thesis Implementation of accounting system for the needs of SDH Česká Bělá deals with an analysis and implementation of accounting software for the needs of an association. The reasons for the creation of own system are described along with the comparison with similar product available on the market. The work further analyzes available options for implementation of individual parts of the designed application and rationalizes their selection. Next parts of the text describe and evaluate general possibilities to use collections in C#.NET programming language and their use in the application. In the conclusion, the work with the application is briefly demonstrated.
Key words . Net Framework, accounting system, C#, collection, database, LINQ
Prohlašuji, že předložená bakalářská práce je původní a zpracoval jsem ji samostatně. Prohlašuji, že citace použitých pramenů je úplná, že jsem v práci neporušil autorská práva (ve smyslu zákona č. 121/2000 Sb., o právu autorském, o právech souvisejících s právem autorským a o změně některých zákonů, v platném znění, dále též „AZ“). Souhlasím s umístěním bakalářské práce v knihovně VŠPJ a s jejím užitím k výuce nebo k vlastní vnitřní potřebě VŠPJ. Byl jsem seznámen s tím, že na mou bakalářskou práci se plně vztahuje AZ, zejména § 60 (školní dílo). Beru na vědomí, že VŠPJ má právo na uzavření licenční smlouvy o užití mé bakalářské práce a prohlašuji, že s o u h l a s í m s případným užitím mé bakalářské práce (prodej, zapůjčení apod.). Jsem si vědom/a toho, že užít své bakalářské práce či poskytnout licenci k jejímu využití mohu jen se souhlasem VŠPJ, která má právo ode mne požadovat přiměřený příspěvek na úhradu nákladů, vynaložených vysokou školou na vytvoření díla (až do jejich skutečné výše), z výdělku dosaženého v souvislosti s užitím díla či poskytnutí licence. V Jihlavě dne
............................................... Podpis
Poděkování Děkuji vedoucímu práce, Ing. Marku Musilovi, za vedení bakalářské práce, asistenci s výběrem vhodného tématu, cenné konzultace a trpělivost.
Obsah 1.
Úvod.......................................................................................................................... 8
2.
Současný stav a důvod tvorby .................................................................................. 9
3.
2.1
Používaný program ............................................................................................ 9
2.2
Rešerše ............................................................................................................. 11
Vývojové prostředí ................................................................................................. 13 3.1
4.
Visual studio 2015............................................................................................ 14
3.1.1
Rozšíření ................................................................................................... 14
3.1.2
Kompilace ................................................................................................. 15
3.1.3
Prvky ......................................................................................................... 15
3.1.4
Zálohování a verzování ............................................................................. 16
3.2
C# ..................................................................................................................... 16
3.3
.NET Freamework ............................................................................................ 17
3.4
LINQ ................................................................................................................ 18
3.4.1
LINQ dotazy ............................................................................................. 18
3.4.2
LINQ provideři ......................................................................................... 19
Rozbor problému .................................................................................................... 21 4.1
Agendy účetního systému ................................................................................ 21
4.1.1
Pokladna.................................................................................................... 21
4.1.2
Faktura ...................................................................................................... 22
4.1.3
Evidence majetku ...................................................................................... 23
4.1.4
Bankovní účet ........................................................................................... 23
4.1.5
Bankovní výpis ......................................................................................... 24
4.1.6
Systém třetí strany pro evidenci osob ....................................................... 24
4.2
Model databáze ................................................................................................ 24
4.3
Prezentační vrstva ............................................................................................ 26
4.3.1
Dialogová okna ......................................................................................... 26
4.3.2
Menu Strip ................................................................................................ 27
4.3.3
Tab Control ............................................................................................... 27
4.3.4
Data Grid View ......................................................................................... 28
4.3.5
Práce se soubory ....................................................................................... 28
4.3.6
Ostatní používané komponenty ................................................................ 29
4.4
Aplikační vrstva ............................................................................................... 30
4.4.1
Validace vstupů......................................................................................... 30
4.4.2
Použité datové typy ................................................................................... 30
4.4.3
Nastavení .................................................................................................. 31
5.
6.
4.4.4
Logování neošetřených chybových stavů ................................................. 31
4.4.5
Zálohování dat .......................................................................................... 31
Kolekce ................................................................................................................... 32 5.1
System.Collections.Generic ............................................................................. 33
5.2
System.Collections ........................................................................................... 34
5.3
Kolekcemi používaná rozhraní ........................................................................ 34
5.3.1
Rozhraní pro procházení ........................................................................... 35
5.3.2
Rozhraní pro řazení ................................................................................... 35
Implementace .......................................................................................................... 36 6.1
Založení databáze ............................................................................................. 36
6.1.1
Vložení nové databáze .............................................................................. 36
6.1.2
Založení tabulek ........................................................................................ 36
6.1.3
Propojení tabulek pomocí cizího klíče...................................................... 37
6.2
Ovládání databáze ............................................................................................ 38
6.2.1
Zapisování do databáze ............................................................................. 38
6.2.2
Zobrazování a úprava záznamů ................................................................ 38
6.2.3
Mazání záznamů ....................................................................................... 40
6.3
Grafické rozhraní ............................................................................................. 41
6.4
Zobrazování záznamů ...................................................................................... 41
6.5
Filtrování .......................................................................................................... 42
Závěr ............................................................................................................................... 43 Seznam použité literatury ............................................................................................... 45 Seznam obrázků .............................................................................................................. 46 Seznam Tabulek .............................................................................................................. 46 Seznam použitých zkratek .............................................................................................. 47 Přílohy............................................................................................................................. 48 1.
Obsah přiloženého CD ............................................................................................ 48
1. Úvod Inspirací pro implementaci účetního programu pro účely SDH Česká Bělá bylo zjištění, že aplikace používaná v současnosti obsahuje větší počet nedostatků a práce s ní je pro běžného uživatele náročná. Aplikaci chybí řada užitečných funkcí, které jsou společně s požadavky na ně podrobněji popsány ve vybraných kapitolách. Práce v programu je dále časově náročná, především z důvodu častého a pomalého otevírání nových pracovních oken nebo například z důvodu nepřehledného uživatelského rozhraní. Vzhledem k výše identifikovaným důvodům je aplikace pro potřeby SDH Česká Bělá nevyhovující. Analýzou jiných aplikací na trhu se nepodařilo docílit výběru takové s optimálním poměrem požadovaných vlastností k ceně. Na trhu existuje vysoký počet freeware aplikací, které však obsahují příliš mnoho nedostatků. Na druhou stranu aplikace, které požadované vlastnosti splňují, jsou vzhledem k potenciálnímu využití pro dobrovolný spolek neúměrně drahé. Aplikace, která alespoň částečně splňovala podmínku na potřebné funkce a nízkou cenou, neobsahovala potřebné návody pro její ovládání a při jejím testování byly odhaleny chyby ve funkčnosti. Cílem celé práce je navrhnout a implementovat vlastní účetní program dle potřeb SDH Česká Bělá. Základním požadavkem je obsah pouze nezbytných funkcí, přehlednost a snadná ovladatelnost. Program bude umožňovat evidenci majetku, třídění a přehled uložených dokladů, kalkulaci stavu pokladny za vybrané období a postupný tisk uložených dokladů ve vhodném formátu pro pokladní knihu. Součástí práce bude i prezentace možností kolekcí, které budou použity pro práci s daty. Pro realizaci projektu bude použit framework C#.NET ve vývojovém prostředí Visual Studio ve verzi Express 2015 staženém ze stránek Microsoft DreamSpark, který je velmi uznávaný a moderní IDE (Integrated Development Environment). Framework .NET bude použit, protože je vhodný na tvorbu formulářových aplikací a má širokou nabídku knihoven.
8
2. Současný stav a důvod tvorby Pro spolek ze zákona o účetnictví (č. 563/1991 Sb) vyplývá povinnost vést podvojné účetnictví. Tato povinnost se vztahuje i na sbor dobrovolných hasičů s členskou základnou vyšší než 50 členů. Na trhu existuje celá řada účetních aplikací, které jsou přizpůsobeny k různým požadavkům firem. U většiny nabízených programů je možno zakoupit licenci podle přesných potřeb firmy. Licence se zakupuje podle verze zvoleného účetního systému. Zde je většinou možné zakoupit malé licence pro neziskové organizace, střední licence pro běžné firmy a velké komplexní balíčky pro potřeby velkých podniků. Střední a veliké licence nejsou pro potřeby spolku vhodné, jsou poskytovány za vyšší cenu a obsahují řadu funkcí, které se pro účetnictví spolku ani nevyužijí. Pro potřeby spolku postačují základní licence, jelikož spolek není plátcem DPH. Také nepotřebuje aplikaci, která by komunikovala se sítí a není vyžadována ani licence pro více uživatelů. Kapitola 2.1 popisuje funkce a nedostatky právě používaného účetního systému. V kapitole 2.3 jsou porovnány aplikace nabízené na trhu, volené převážně podle rozsahu licence.
2.1 Používaný program V současné době je u aplikace používána licence pro malé firmy. Je možno zadat do 150 dokladů za účtovací období. Program je rozdělen na moduly s vyšší či nižší relevancí pro potřeby spolku:
Modul pro účetní základ, ve kterém je možno zakládání účetních dokladů. Lze pořizovat doklady pro banku a pokladnu, převod účetních dat a tvroby sestav pro práci s daty,
Modul pro správu faktur umožňuje evidenci vydaných a přijatých faktur. V tomto modulu je možno tyto údaje procházet a tisknout jako sestavy budoucích plateb,
Evidence dlouhodobého majetku,
Saldokonto odběratelů a dodavatelů,
Tato licence je nevyhovující, jak je popsáno v rešerši. 9
Na následujícím obrázku je zobrzeno okno pro přidávání a opravy účetních dokladů. Přepínání mezi možností opravy a přidáním je pomocí funkce režim, u které jsou dvě volby přepínané pomocí radio button. Tento způsob úpravy dat je podle slov účetního „Nepřehledný a pomalý“.
Obrázek 1 Přidání dat do účetního systému DeCe 2011 (Zdroj: vlastní) Při zvolení přidání je potřeba zadat číslo dokladu, pokud toto číslo nemáme zaznamenané, musí se vyhledat z přehledu nazývaného „listování“ dle záznamu (viz. Obrázek 2). Pro jednodušší a rychlejší přídání bude u nového programu funkce, která bude automaticky nabízet číslování nových dokladů. Tato funkce zkrátí čas přidávání záznamů, který byl vynaložen na vyhledevání posledního zadaného záznamu.
10
Obrázek 2 Přehled účetních dokladů za vybrané období. (Zdroj: vlastní)
2.2 Rešerše Na trhu je nabízena celá řada účetních aplikací. Podle nabízených licencí se dělí podle množství vkládaného obsahu na veliké, střední a malé. Tyto účetní systémy často nabízejí stejné funkce a jsou pouze limitovány maximálním množstvím zadaných údajů za účetní období. Podle velikosti licence je i určena cena produktu. Pro účetnictví spolku postačuje malá licence a zadávání do stovek záznamů za účetní období. Přestože je vybíráno převážně z malých účetních aplikací, jejich cena je často větší než 5 000 Kč. Jelikož se hledá účetní systém pro neziskovou organizaci, tak by spolek za takovouto aplikaci mohl zaplatit do 2 000 Kč. Přestože prodejci často nabízejí neziskovým organizacím slevy, na požadovanou částku se u většiny aplikací nedostaneme. Nabízené aplikace splňují všechny kladené požadavky jen z jisté části. Pokud splňují požadavek na nízkou cenu, mívají nějaký nedostatek v podobě chybějící agendy (většinou evidence majetku). Dále jsou na trhu takové aplikace, které požadované vlastnosti splňují, ale jsou drahé a často i zbytečně komplikované. Pro požadovanou aplikaci je potřebná i podpora ze strany výrobců a včasné reakce na požadavky zákazníka. Tato podpora je zdarma jen u dražších aplikací, často až od vyšších verzí. U levnějších aplikací je podpora placená, častou jsou placeny i aktualizace.
11
Program
Verze
Cena[Kč]
Poznámka
AdmWin
PU
7.900
Vysoká cena
ATMA
10.36
2.999
Vysoká cena
DeCe
Basic+
1.000
Neobsahuje všechny požadované funkce
DeCe
Standard
5.500
Vysoká cena
Kel EXPRESS
BASIC
3.108 ročně
Vysoká cena - roční paušál
Money
S3 start
2.000
Neobsahuje všechny požadované funkce
Money
S4
Přes 10.000
Vysoká cena
Pohoda
Mini
2.280
Vysoká cena
WinDUO
Benefit
899
Neobsahuje všechny požadované funkce
Tabulka 1 Porovnání účetních aplikací nabízených na trhu
12
3. Vývojové prostředí Při výběru vhodného vývojového prostředí a programovacího jazyka je třeba zvážit požadavky na běh aplikace. Uživatel současného systému je zvyklý na účetní systém, který je řešen jako formulářová aplikace. Z tohoto důvodu bude aplikace programována „ve stejném duchu“, za použití jazyka C# .NET. Účetní systém by také mohl být vytvořen jako webová aplikace (programovací jazyk ASP.NET), která by se spouštěla v prohlížeči. Aplikace si musí ukládat data o své činnosti, pro ukládání dat bude použit databázový systém MSSQL od společnosti Microsoft. Systém MSSQL nabízí moderní databázi s řadou funkcí, které od vyvíjené aplikace požadujeme. Pro zvolený databázový systém potřebujeme metodu pro přístup k datům. Jako možnost ovládání databáze se nabízí ADO.NET, LINQ a Entity Framework. ADO.NET je sada tříd pro práci s relační databází. Je integrovaný do prostředí .NET Framework a podporuje různé potřeby vývojáře, jako například tvorbu front-end databází. Jde o dotazovací jazyk, který pomocí metod poskytnutých v třídách vykonává SQL dotazy. LINQ jde o dotazovací jazyk, integrovaný do prostředí C#.NET, který nabízí objektovou práci s databází. V porovnání s SQL je LINQ jednodušší, úhlednější a na vyšší úrovni. V mnoha případech je (však) práce v moderním uhlazeném jazyce bez nutnosti braní ohledů na detaily nízkých úrovní velkou výhrou. [4] Entity Framework jde o tzv. ORM (objektově-relační mapování). Ve zdrojovém kódu se pracuje pouze s objekty a SQL dotazy jsou generovány Frameworkem. S Entity Frameworkem je možno pracovat dvěma způsoby, Code First (vytvoříme třídu, podle které je následně vygenerována tabulka) a Database First (Databázové tabulky se mapují na C# třídy). [9]
13
3.1 Visual studio 2015 Microsoft Visual Studio je integrované vývojové prostředí (IDE = Integrated Development Environment), tedy aplikace, ve které lze zdrojový kód jak psát a testovat, tak ladit. Může být použito pro vývoj konzolových aplikací a aplikací s grafickým rozhraním spolu s aplikacemi Windows Forms, webovými stránkami, webovými aplikacemi a webovými službami jak ve strojovém kódu, tak v řízeném kódu na platformách Microsoft Windows, Windows Mobile, Windows CE, .NET, .NET Compact Framework a Microsoft Silverlight.
3.1.1 Rozšíření Samo o sobě nepodporuje Visual Studio mnoho programovacích jazyků nebo nástrojů. Funkčnost a její rozšíření funguje na základě systému balíčků a služeb. Veškeré editory, designery, typy projektů a další nástroje jsou tedy implementovány jako balíčky. Mezi vestavěné jazyky patří C/C++ (použitím Visual C++), VB.NET (použitím Visual Basic .NET) a C# (použitím Visual C#). Podpora dalších jazyků může být přidána balíčkem zvaným Language Service (jazyková služba). Také je podporováno XML(Extensible
Markup
Language,
česky
rozšiřitelný
značkovací
jazyk)/XSLT((Extensible Stylesheet Language Transformations), HTML(HyperText Markup Language)/XHTML(extensible hypertext markup language), JavaScript a CSS(Cascading Style Sheets). Existují i verze Visual Studia pro určitý jazyk, které uživateli poskytují omezenější jazykové služby. Tyto individuální balíčky jsou Microsoft Visual Basic, Visual J#, Visual C# a Visual C++. [1] Jazykové služby mohou být implementovány jak ve strojovém kódu, tak v řízeném kódu. Pro strojový kód mohou být použity jak rozhraní COM, tak Babel Framework (součást SDK). Pro spravovaný kód obsahuje MPF obaly pro psaní spravovaných jazykových služeb. [10] Další funkce, které mohou být takto přidány, zahrnují například zvýraznění syntaxe, doplňování příkazů, zvýrazňování párů závorek, typy parametrů informací, seznamy členů a chybové značky pro kompilaci na pozadí apod.
14
IDE je pak odpovědné za koordinaci jednotlivých služeb a zprostředkování komunikace mezi nimi.[1]
3.1.2 Kompilace Visual Studio umožňuje kompilaci na pozadí (někdy zvaná přírůstková kompilace). Během psaní kódu jej Visual Studio na pozadí kompiluje, aby poskytlo informace o syntaktických a kompilačních chybách, které jsou podtrženy červenou vlnovkou. Varování jsou podtržena zelenou vlnovkou. Kompilace na pozadí negeneruje spustitelný kód, protože používá jiný kompilátor než ten, který spustitelný kód generuje.
3.1.3 Prvky 3.1.3.1 Editor kódu Editor kódu podporuje zvýraznění syntaxe a automatické dokončování za použití IntelliSense nejen pro proměnné, funkce a metody, ale také konstrukce jako cykly a dotazy (IntelliSense) a refaktorování včetně změny pořadí parametrů, přejmenování proměnných a metod, extrakci rozhraní a zabalení členů třídy uvnitř vlastností mezi ostatní., dále pak nastavování záložek v kódu pro rychlou navigaci; sbalování bloků kódu (#region jméno); přírůstkové i normální hledání s podporou regulárních výrazů; nebo vícepoložkovou schránku a seznam úkolů. [11] Podporuje snippety, což jsou uložené šablony opakujícího se kódu, které mohou být do kódu vloženy a přizpůsobeny aktuálnímu projektu. Nástroj pro správu snippetů je v podstatě plovoucí okno, které může být ukotveno nebo schováno, není-li používáno. 3.1.3.2 Debugger Debugger pracuje jak se spravovaným kódem, tak se strojovým kódem a může být použit pro debugování (odstranění chyb) aplikací psaných v jakémkoliv podporovaném jazyce. Může být přiřazen i běžícím procesům. Pokud je dostupný kód běžícího procesu, zobrazí se. Pokud není, zobrazí se kód v Assembleru. Debugger také umí vytvořit obsahy paměti a později je nahrát pro debugging. Jsou podporovány více jádrové programy. Debugger může být nakonfigurován, aby byl spuštěn, když spadne aplikace běžící mimo Visual Studio.
15
Debugger povoluje nastavování breakpointů (umožňujících zastavit běh programu na určité pozici) a watche (které sledují hodnoty proměnných během procesu). Breakpointy mohou být podmíněné a aktivovat se pouze, je-li splněna zadaná podmínka. Kód lze krokovat, tedy provádět příkazy kódu po jednom řádku. Může také vstoupit do funkcí, aby je debugoval uvnitř, nebo je přejít. Debugger podporuje funkci Edit and Continue, takže je možné kód upravovat během debuggingu. Pokud během debuggingu přejedete přes proměnnou, její aktuální hodnota je zobrazena v tipu, kde může být modifikována. Během kódování umožňuje debugger manuálně zavolat funkci pomocí okna Immediate. V tomto okně jsou také k dispozici parametry funkce. 3.1.1.1 Příklady dalších prvků
Designer formulářů pro tvorbu aplikací s GUI,
Designer webu,
Designer tříd,
Designer databázových schémat.
3.1.4 Zálohování a verzování Zálohování a verzování (zachování změn v čase) programu by mělo být zažitým zvykem programátora zabraňujícím ztrátě několikadenní až týdenní práce. Visual Studio neobsahuje žádnou vestavěnou podporu verzování, ale definuje MSSCCI (Microsoft Source Code Control Interface) implementováním toho, které verzovací systémy mohou být integrovány s IDE.[7] MSSCCI definuje sadu funkcí, které jsou použity pro implementaci různé funkčnosti verzování. Možností je použití jednoduchých programů, například programu DropBox, který soubory sám verzuje a zároveň synchronizuje s webovým úložištěm.
3.2 C# „C Sharp“ je programovací jazyk vyvinutý firmou Microsoft. V mnoha rysech vychází C# z programovacích jazyků C/C++ a Java. Byl vydán v roce 1999 spolu s platformou .NET.
16
C# je čistě objektově orientovaný jazyk s jednoduchou dědičností a násobnou implementací rozhraní. Má automatickou správu paměti, ve které se o uvolňování stará garbage collector. Obsahuje chybové ošetření pomocí výjimek. Pro spojení souvisejících typů využívá jmenných prostorů (tzv. namespace). Pokud chceme používat nějaký namespace, použijeme klíčové slovo using.
3.3 .NET Freamework Microsoft .NET Framework je rozsáhlé softwareové prostředí určené pro vývoj aplikací jak klasických pro Windows, tak mimo jiné i webových aplikací a služeb, aplikací pro mobilní zařízení a další. Ke spuštění potřebují mít aplikace nainstalované knihovny v příslušné verzi. [7] Jedná se o modulární technologii COM (Component Object Model), která má pro své komponenty definovaná rozhraní, přes která komunikuje mezi klientem a komponentou. Jádro je založené na principech objektově orientovaného programování. .NET Framework podporuje třídy, metody, vlastnosti, polymorfismus a další. Dále řeší problémy s bezpečností a také s nasazováním a instalací aplikací.
Obrázek 3 Architektura .NET Framework (Zdroj: http://www.cs.vsb.cz [12])
17
Aplikace postavené na .NET platformě mají stejné rysy a stejný model návrhu nezávisle na typu zařízení. Platforma .NET již sahá prakticky do všech oblastí programování softwarových řešení Microsoftu. Srdcem platformy .NET je jádro nazvané .NET framework. Toto jádro se stará o tři základní úkoly: [2]
Je run-time prostředím pro běh aplikací, tzn. že aplikace pro něj napsané jsou s ním pevně spjaty a bez tohoto prostředí je nelze spustit,
Poskytuje možnosti pro tvorbu ASP.NET stránek i webových služeb,
Obsahuje velmi širokou řadu knihoven, objektově orientovaných tříd usnadňujících řadu úkolů (bezpečnost, komunikaci, práce s databázemi a datovými zdroji).
3.4 LINQ LINQ (Language Integrated Query) je významných přínosem pro platformu .NET, jde o univerzální dotazovací jazyk, který je integrovaný do C# od verze 3.0 a .NET frameworku 3.5. Výhodou integrace do C# je syntaktická kontrola dotazů při překladu. Univerzálnost dotazování nám umožňuje procházet různé datové zdroje (pole, kolekce, SQL databázi, XML soubor) stejným způsobem. K těmto zdrojům musíme mít poskytnutého LINQ providera (seznam providerů 3.4.2). [4]
3.4.1 LINQ dotazy Při psaní dotazu nejprve určujeme, odkud budeme data vybírat, dále může následovat podmínka a nakonec určíme, co vybíráme. Podobně jako u SQL je možno výsledky dotazů seskupovat (groupby) a řadit (orderby). Pořadí prvků při řazení je možno upravit klíčovým slovem, ascending (výchozí řazení, od nejmenšího po největší) a descending (největšího po nejmenší). Výsledky dotazů se ukládají do speciální proměnné, která se označuje klíčovým slovem var. Datový typ takovéto proměnné je určen kompilátorem za překladu (C# určí datový typ). Tímto způsobem je zaručeno odstínění uživatele od datového typu, což zaručuje univerzálnost (při změně kolekce by se změnil i její datový typ). [4]
18
Obrázek 4 Vykonání LINQ dotazu nad databází MSSQL (Zdroj: msdn.microsoft.com)
3.4.2 LINQ provideři Jde o implementace metod, díky kterým je možno volat dotazy LINQ nad datovým zdrojem. .NET Framework nabízí několik providerů:
LINQ to SQL – provider, který mapuje LINQ příkazy na dotazy SQL a tím nám umožňuje práci s databází MSSQL,
LINQ to Object – provider umožňující dotazování nad základními kolekcemi ze System.Collections, System.Collections.Generic a nad dalšími typy, které implementují rozhraní IEnumerable,
LINQ to XML – Provider, který umožňuje dotazy nad XML souborem,
LINQ to DataSet – Provider, který umožňuje dotazy na DataSet. 19
K těmto základním providerům existuje i možnost napsání vlastního providera, proto existuje i mnoho dalších providerů třetích stran, například:
LINQ to Excel – Provider umožní pracovat s tabulkou v dokumentu Excel jako s databází,
LINQ to Amazon – Pomocí tohoto provideru můžeme vyhledávat v internetovém obchodě,
LINQ to JSON – Dotazování nad souborem JSON.
20
4. Rozbor problému Tato kapitola se zabývá požadavky na funkčnost jednotlivých částí aplikace z pohledu zadavatele práce. Jednotlivé úlohy jsou rozděleny na několik základních částí, které mezi sebou budou vzájemně propojeny. Dále zde je popsána analýza požadavků na účetní systém. V případě větších projektů může být analýza náročný a zdlouhavý proces. Pro tuto analýzu bylo využito několik základních postupů, díky kterým byly identifikovány požadavky na funkčnost celého systému. Hlavním účelem aplikace z pohledu uživatele bude udržování záznamů o finančních pohybech, zobrazování aktuálního finančního stavu a usnadněné ovládání oproti dříve používanému systému. Záznamy budou udržovány v různých agendách, dále rozebraných v kapitole 4.1.
4.1 Agendy účetního systému 4.1.1 Pokladna Práce s pokladnou bude nejčastěji používaná část aplikace. Tato funkce bude představovat změny hotovosti pokladně, kterou u sebe drží pokladní (zároveň účetní) spolku. K pokladně musí být veden pokladní deník, do kterého se zaznamenávají veškeré pohyby hotovosti. Z důvodů nutnosti podvojného účetnictví, které vyplývá ze zákona, musí být tyto údaje vedeny i elektronicky. Proto je žádáno, aby aplikace umožňovala tisk pokladních záznamů ve formátu vhodném pro pokladní knihu. K této části musí kromě přidávání také patřit náhled na uložená data, který bude umožňovat dodatečnou práci s daty. Přidaný záznam musí být možno editovat, mazat a upravovat. Na náhled je kladen nárok z pohledu filtrace záznamů, kdy je požadavkem záznamy filtrovat jak podle data, tak i cenového rozsahu a osoby, která vystavila doklad. Zobrazená data musí být možno řadit podle různých specifikací. Pokladna bude ukládat pokladní doklady, které představují jednotlivé transakce. Přidání příjmového dokladu znamená vklad hotovosti, výdajový doklad pak bude znamenat vybrání hotovosti. Z tohoto pohledu je potřeba evidovat
21
Cena položky,
Cena slovy,
Číslo položky – pro evidování v pokladním deníku a pro řazení,
Datum pořízení dokladu,
Vystavil,
Schválil,
Přijato od.
Jako nečastější příjmové záznamy zde budou uváděny např. výběry členských příspěvků, zisky z tanečních zábav a podobných kulturních akcí, zisky z pořádání soutěží či za účast na brigádách. Jako výdajové pokladní doklady se bude nejčastěji evidovat platba startovného na soutěžích a proplacení nákladů na dopravu a stravu. Méně časté budou dary členům k příležitosti životního jubilea, v neposlední řadě pak například příspěvek pro členy na pořízení hasičské uniformy.
4.1.2 Faktura Aplikace bude udržovat záznamy o uložených fakturách. Všechny přidané faktury budou prvně vedeny jako neuhrazené. Jejich uhrazení bude provedeno jako spojení záznamu v tabulkách pomocí cizího klíče, propojení může být se záznamem z pokladny nebo nějakého bankovního účtu. Faktura pro svůj vznik bude potřebovat údaje o platbě, jako jsou:
Částka,
Variabilní symbol,
Typ faktury,
Dodavatel – propojený do evidence třetích stran,
Datum (vystavení a splatnosti),
Forma úhrady,
Předmět dodávky – krátký popis události.
22
4.1.3 Evidence majetku Pro spolek je důležité evidovat veškerý majetek. Do evidovaného majetku se řadí mnoho zakoupených věcí - stroje pro práci (plovoucí čerpadlo, benzínový generátor proudu a sportovní stroj), sportovní vybavení, nářadí, stoly v klubovně, náhradní díly a další položky. Pro řádnou evidenci majetku je nezbytné vyplnit následující informace
Inventární číslo,
Název,
Pořizovací cena,
Umístění – ve které je to budově a místnosti,
Datum (dodání a životnosti),
Výrobce – vybraný z evidovaného seznamu,
Dodavatel – s možností jeho prohlížení.
4.1.4 Bankovní účet Spolu s vedením pokladny, která bude pouze jedna, musí aplikace umožňovat sledování stavu bankovních účtů. Tato funkce musí poskytnout možnost k přidávání záznamů do jednotlivých bankovních účtů, kterých může být více a u různých bank. Proto je nutné evidovat
Název banky,
Číslo účtu,
Počáteční stav – počáteční vklad na účet (nebo stav účtu před přechodem z jiné aplikace),
Preferované pořadí při výběru – položka pro komfortnější zadávání, určuje, v jakém pořadí se bude vybírat ze založených účtů
V přehledu účtu bude možnost nahlédnout na částku a porovnat jí se skutečným stavem účtu. Bankovní výpisy bude možno řadit a filtrovat podle podobných kritérií jako pokladní doklady.
23
4.1.5 Bankovní výpis Slouží pro řádné evidování pohybů na bankovních účtech. O bankovních transakcích je třeba vést základní údaje
Velikost převodu,
Datum převodu,
Druh platby,
Forma.
Do bankovních výpisů se nebude přidávat nijak veliké množství údajů (pár desítek ročně), v těchto výpisech jsou zahrnuty především úhrady faktur, dotace, příspěvky, bankovní poplatky a připsané kladné úroky.
4.1.6 Systém třetí strany pro evidenci osob Pro rychlé přidávání záznamů bude aplikace umožňovat evidování údajů o spolupráci se třetí stranou. Toto spojení ušetří čas při zadávání opakujících se účastníků a při vyhledávání jejich kontaktních informací. Spojení bude volitelné (výběr ze seznamu nebo zadání textu) a o účastnících bude udržovat základní údaje
Jméno,
Adresa,
Kontaktní informace,
IČO,
Poznámka – pro doplňkové informace
4.2 Model databáze Pro každou agendu bude databáze obsahovat tabulka, která bude mít všechny potřebné sloupce podle rozboru požadavků (kapitola 4.1.). Skutečný model databáze se po implementaci může od plánovaného modelu (Obrázek 5) částečně lišit. Pro uchování záznamů se bude používat celých čísel, řetězce znaků, data a booleovské hodnoty (pravda / nepravda). Celé číslo se v databázi ukládá jako int, řetězec je nvarchar(), datum datetime2 a booleovská hodnota jako bit.
24
Obrázek 5 Použitý model databáze (Zdroj: vlastní)
25
4.3 Prezentační vrstva GUI (Graphical user interface / Grafické uživatelské rozhraní) musí být pro uživatele navrhnuto tak, aby bylo přehledné, lehce ovladatelné a nejpoužívanější funkce byly rychle dostupné. Aplikace bude ovládaná pomocí záložek (Tab Control), který bude mít záložky podle potřebných agend a statistický přehled pokladny. Na záložkách bude umožněno přidávání, úprava záznamů, mazání a náhled na uložená data. Zbylé, méně používané a obecné akce, budou spouštěny z lišty menu (Menu Strip), zde se bude nacházet například tisk, účetní uzávěrka, nastavení aplikace a nápověda.
4.3.1 Dialogová okna U většiny nabízených aplikací je ovládání aplikace řešeno používáním různých vyskakovacích oken pro právě potřebnou úlohu. Tento způsob bude vhodný především u rozsáhlejších aplikací pro přidávání dalších agend. Dialogová okna se používají pro dodatečný sběr informací od uživatele nebo pro potvrzení před vykonáním událostí (např. mazání, uzávěrka). Potvrzení události je nejjednodužší použitím třídy MessageBox (Obrázek 6). Pro zjištění dalších informací bude použito vlastní dialogové okno (Obrázek 7). Ve vlastním okně lze upravit již zadaná data, nebo vložit nové údaje, které budou přidány do databáze.
Obrázek 6 Potvrzení události pomocí třídy MessageBox. (Zdroj: vlastní)
26
Obrázek 7 Získání údajů od uživatele ve vlastním dialogovém okně. (Zdroj: vlastní)
4.3.2 Menu Strip Položka určená pro přidání možností menu ve formulářové aplikaci. Umožňuje vytvoření položek menu, položky pak mají podobné ovládání jako například tlačítka (můžeme pro ně spouštět různé události). MenuStrip je možno ukotvit na horní nebo dolní okraj hlavního okna aplikace, ze zvyku se budeme držet horního okraje.
4.3.3 Tab Control Představuje tabulkové rozložení na uživatelském rozhraní. .NET Framework mu poskytuje univerzální a lehce ovladatelné používání. TabControl funguje podobně, jako otvírání záložek v internetovém prohlížeči. Každá ze založených stránek může obsahovat různé ovládací prvky. Na následujícím obrázku (Obrázek 8) je pod položkou MenuStrip zobrazen TabControl, který má připravené základní karty, pro zadávání záznamů, do plánovaných agend aplikace.
27
Obrázek 8 Použití komponent MenuStrip a TabControl v aplikaci (Zdroj: vlastní)
4.3.4 Data Grid View DataGridView je navržen, aby formulářům poskytnul kompletní řešení pro zobrazování tabulkových dat. DataGridView zobrazuje data v přizpůsobitelné mřížce. Základní jednotkou pro zobrazení dat je buňka. Každá buňka může být různě graficky upravena (barva pozadí a popředí, font, formát textu). Výchozím datovým typem pro buňku je Objekt. Data načtená do DataGridView mohou být zpřístupněna buď po sloupcích, použitím kolekce sloupců nebo po řádcích, použitím kolekce řádků. DataGridView podporuje standardní formulářový model na připojení dat. To znamená, že jako zdroj dat může být vše, co má implementováno následující rozhraní:
Rozhraní IList, včetně jednorozměrných polí,
Rozhraní IListSource, jako jsou třídy DataTable a DataSet,
Rozhraní IBindingList, jako třída BindingList
,
Rozhraní IBindingListView, jako třída BindingSource.
4.3.5 Práce se soubory Přestože nebyl zadán požadavek na práci se soubory, aplikace bude umožňovat pouze zálohování a obnovu dat použitím souboru XML. Zálohování bude automatické při startu a ruční. Při ručním zálohování bude potřeba určit, kam se má databáze zálohovat, 28
pro určení bude použit definovaný SaveFileDialog. Při obnově se použije formulář pro načítání OpenFileDialog. 4.3.5.1 OpenFileDialog Zobrazuje standardní dialogový box, ve kterém umožňuje uživatelům procházet složky a vybírat soubory pro čtení. 4.3.5.2 SaveFileDialog Nabídne dialogový box pro procházení složek a zvolení místa pro zápis do souboru. Toto ovládání uživateli umožňuje nastavit jméno souboru pro určitý soubor.
4.3.6 Ostatní používané komponenty
Button (tlačítko) je ve formulářové aplikaci používáno jako interaktivní komponenta, která umožňuje uživateli komunikovat s aplikací. Při potvrzení tlačítka se spustí event (událost), která vykoná požadovanou funkci.
Textbox (textové pole) může být použit pro zobrazení dat nebo čtení vstupů. Základní nastavení je zadávání na jeden řádek, ale při nastavení vlastnosti Multiline, je možno zadávat i rozsáhlejší text. Textbox také umožňuje maskování znaků při zadávání hesla.
DateTimePicker (výběr data a času) je rozhraní po výběr data. Po vybrání nabídne uživateli kalendář, ze kterého se snadno vybere datum, bez následné nutnosti kontroly zadaných údajů.
RadionButton dovoluje uživateli výběr jedné možnosti ze skupiny zadaných. Pokud uživatel vybere nějakou hodnotu, hodnota bude nastavena na true a všechny ostatní hodnoty ve skupině budou nastaveny jako false.
NumericUpDown
umožňuje
zvolit
číselnou
hodnotu
v určeném
rozmezí
(v aplikaci od nuly). Hodnota může být zadána rovnou jako číslo, nebo může být měněna pomocí šipek (nahoru a dolu).
29
4.4 Aplikační vrstva 4.4.1 Validace vstupů Kontrola uživatelem zadaných vstupů bude probíhat pouze jako ověření správnosti formátu zadaných údajů (pro cenu nezáporné číslo) a vyplnění všech povinných údajů (inventární číslo u majetku, názvy). Použitím LINQ to SQL nemusíme řešit „escapování“ potenciálně nebezpečných znaků, které by při použití ADO.NET vyhodily výjimku. Výjimky by v případě nedostatečného ošetření způsobovaly pády aplikace. Právě „escapováním“ znaků je LINQ ze své podstaty ošetřen proti napadení útokem SQL Injection (jde o útok na databázi přes neošetřený vstup). Tento typ útoku by pro aplikaci nebyl nijak hrozivý, protože aplikace nepoběží na webovém serveru, čímž se vytratí možnosti útoku.
4.4.2 Použité datové typy Decimal (desetinné číslo) je při srovnání s datovými typy s plovoucí desetinnou čárkou (například double, který zaokrouhlováním vnáší chybu) přesnější, ale má menší rozsah. Díky větší přesnosti je vhodný pro matematické operace a peněžní kalkulace. V databázi je uložen jako typ money. String (řetězec) bude použit pro všechny textové záznamy. V databázi jsou všechny hodnoty uloženy jako varchar(max). Int (reálné číslo) místo tohoto datového typu by se mohl také používat decimal, ale jelikož je tento typ použit pouze pro ukládání identifikačních údajů o uložených záznamech v tabulkách, bude jeho rozsah (2 147 483 647 / maximální vložitelná hodnota je přes dvě miliardy) dostačující. DateTime (datum a čas) je použit pro evidování všech datových záznamů. Tento datový typ zaznamenává datum jako počet jednotek zvaných „tick“ od půlnoci prvního ledna roku 1 našeho letopočtu. Jednotka „tick“ představuje 100 nanosekund.
30
4.4.3 Nastavení V menu je obsažena položka s nastavením, pomocí které je možné nastavit základní chování aplikace. Dialogové okno (zobrazené na obrázku 7) po úspěšném uzavření uloží data do databáze a při událostech, které se týkají těchto nastavení, přečtením údaje z databáze a vhodnou podmínkou rozhodne, jak bude daná činnost vykonána. Z nastavení bude možno ovládat následující události:
Zapnutí nebo vypnutí automatického zálohování dat při startu.
Upozornění při startu (zobrazení varování a počet událostí, vyžadujících pozornost)
Inicializace aplikace (příprava databáze před prvním spuštěním)
Nastavení účtovacího období (zobrazování jednoho roku)
4.4.4 Logování neošetřených chybových stavů Účelem funkce je ulehčení opravy možných chyb po nasazení aplikace do provozu. Jednoduchá funkce, která při detekci neošetřené výjimky, oznámí uživateli, že nastala chyba a požádá ho o popsání činnosti, kterou vykonával před nastáním této chyby. Funkce poté zapíše do souboru zprávu od uživatele a výjimku. Textový soubor bude mít název podle aktuálního data ve formátu rrrrMMddhhmmss (rok měsíc den hodina minuta sekunda), tento formát zaručí vždy unikátní název chyby a zároveň i ponese údaj o času chyby.
4.4.5 Zálohování dat Přestože zadavatel nepodal žádný požadavek na zálohování dat, aplikace bude umožňovat přepis záznamů do souboru ve formátu CSV. Zálohování bude spouštěno dvěma způsoby. Volitelná záloha změn po práci (ta se provede automaticky při ukončení aplikace) a záloha na povel uživatele (přes openfile dialog se vybere místo a název zálohy).
31
5. Kolekce Existují dva způsoby, jak pracovat se skupinou objektů, vytvořením pole nebo použitím kolekce. Pole je nejvhodnější při práci se záznamy s předem známým počtem, oproti tomu kolekce je dynamická a mění velikost podle potřeby aplikace. Kolekce je třída, proto se před přidáním dat musí vytvořit instance. Existují dva typy, které jsou obsaženy ve dvou jmenných třídách. Tyto dva typy pracují podobně, ale mají drobné odlišnosti. Oba druhy kolekcí je možná řadit podle zvoleného parametru. V kolekci uložená třída používá pro porovnávání hodnot implementované rozhraní IComparable. Toto rozhraní vyžaduje metodu CompareTo, která se pak používá pro řazení prvků. Podle porovnávaných dat pak metoda CompareTo vrací tři možné hodnoty:
nulu pro rovnost prvků,
záporné číslo pokud je porovnávaný objekt menší než druhý objekt,
kladné číslo, pokud je objekt větší.
Kolekce pro průchod používají metodu (nebo přístupový prvek get). Této metodě (prvku) se říká Iterator. Iterator v C# využívá yeld return pro postupné vracení prvků kolekce. [7] Pro přidávání prvků se používána metoda Add(), která má jako parametr prvek, který bude vložen na konec kolekce. Pokud chceme s prvky v kolekci pracovat, používáme vlastnost Item, implementovanou jako indexer. Další užitečná metoda pro práci s kolekcí je Contains(), která vrací datový typ bool, podle toho, zdali kolekce obsahuje parametrem zadaný objekt. Pro odstraňování prvků je používána metoda Remove() nebo RemoveAt(). Pro Remove() použijeme jako parametr objekt, který chceme z kolekce odstranit (odstraní se první nalezený výskyt) a metoda RemoveAt() se použije pro odstranění prvku podle indexu. Pro odebrání všech dat z kolekce se používá metoda Clear(). Pro výpis všech dat je díky naimplementované metodě IEnumerable vhodné použít cyklus foreach. Tento cyklus umožňuje postupně projít celou kolekci. [8]
32
5.1 System.Collections.Generic Při tvorbě této účetního aplikace jsem pro práci využíval pouze generické kolekce. Jsou obecně doporučovány pro použití a zajišťují typovou bezpečnost. Nejčastěji jsem používal kolekci List pro udržování seznamu záznamů, pak jsem používal Queue pro operace, které vyžadovaly postupné používání záznamů, například tisk záznamů a párování faktur. Obě použití kolekce jsou pro splnění požadavků na aplikaci postačující, protože zvládají všechny potřebné funkce, práce s nimi je jednodušší než tvorba vlastní kolekce nebo používání negenerických kolekcí (např. Array). [7] Použitím generických kolekcí se dá lépe ošetřit běh programu, protože můžeme odhalit všechny chyby už při kompilaci. U negenerických kolekcí můžeme narazit na chyby až za běhu aplikace. Genericita je jednou z vlastností jazyka C#, její používání je obecně doporučováno, protože nám nabízí spoustu výhod. Například typová bezpečnost bez nutnosti odvozování datového typu a implementování specifických členů (implement typespecific members). Protože u generických kolekcí není nutné pro práci přetypování záznamů, je jejich používání jednodušší. Při inicializaci generických kolekcí uvádíme také její datový typ. Tento datový typ se udává do ostrých závorek mezi název kolekce a její jméno. Generické kolekce jsou pak silně typové a při přidávání položek se musí použít pouze parametr se stejným datovým typem jako je kolekce. Nejčastěji používané generické kolekce:
List - Jedna z nejužitečnějších sekvenčních kolekcí. Jde o seznam objektů, ve kterém jsou položky přístupné také pomocí indexu (jako u pole),
Queue - Užitečná kolekce představující frontu typu FIFO (first in, first out / první dovnitř první ven),
Stack - Kolekce, která přestavuje zásobník typu LIFO (last in, first out / poslední dovnitř první ven),
Dictionary - Asociativní kolekce, kolekce s párem klíč/hodnota.
33
5.2 System.Collections Tento jmenný prostor pracuje se svými prvky, jako by byly System.Object. Proto je nutné před použitím prvků použít přetypování. Přetypováním můžeme způsobit chybu, způsobenou přetypováním na špatný objekt. Negenerické kolekce jsou použitelné pro různé datové typy, ale nezaručují nám typovou bezpečnost. Pokud chceme udržet typové bezpečí, musíme přetypování dat řádně ošetřit. Pokud máme větší množství uložených tříd, je tato údržba rozsáhlá a zpomaluje běh programu. Přetypování všech používaných prvků zpomaluje práci, proto při práci s větším množstvím prvků pracují negenerické kolekce (oproti generickým) pomaleji. Další zpomalení nastane zabalováním jednoduchých datových typů (např. int). Přehled nejčastěji používaných kolekcí:
ArrayList - Jde o dynamický list hodnot, jehož počáteční kapacita může být určena při vytváření instance. Práce s ním je podobná jako s kolekcí List.
Queue – představuje FIFO kolekci (jako u generické pouze s daty typu Objekt)
Stack - představuje LIFO kolekci (jako u generické pouze s daty typu Objekt)
HashTable – hešovací tabulka. Asociativní kolekce představující kolekci klíč/hodnota.
5.3 Kolekcemi používaná rozhraní Kolekce implementují řadu rozhraní, díky kterým je možnost pracovat s kolekcemi jednotně, bez ohledu na použití konkrétního typu kolekce. Díky těmto rozhraním si také můžeme udělat vlastní kolekci. I kolekcemi používaná rozhraní jsou rozdělena na beztypová a generická. U generických rozhraní se rozhraní v ostrých závorkách udává typ rozhraní (například u Enemerátoru je to IEnumerable). Pokud nám nestačí vlastnosti a metody kolekcí, které jsou definovány v kolekcích poskytnutých .NET frameworkem můžeme vytvořit vlastní kolekci, u které je vhodné, aby implementovala nějaké rozhraní.
34
Použití vlastní kolekce může být užitečné, pokud máme v kolekci načtené záznamy z databáze a chceme, aby se všechny tyto záznamy v databázi upravily najednou. V tomto případě by nám vlastní kolekce umožnila kontrolu vložení záznamů, v případě chyby by umožnila návrat starých hodnot databáze.
5.3.1 Rozhraní pro procházení IEnumerable je datová struktura, která umožňuje procházet kolekci pomocí cyklu foreach, jde o objekt, který pomocí metody GetEnumarator vrací referenci na prvek v kolekci (IEnumerator). Pomocí implementované metody MoveNext se posouvá na další prvky kolekce. Kolekcí se posouváme, dokud metoda nevrátí hodnotu false, čím je indikován konec seznamu. [7] Pokud chceme ve vlastní kolekci umožnit podporu procházení pomocí prvku foreach, je možné vytvořit Enumerátory. Je to možné dvěma způsoby, můžeme napsat vlastní třídu, která musí implementovat rozhraní třídy IEnumerable nebo použitím iterátorů (přidaným od verze C#2). [8] Tyto iterátory obsahují prvek yield. IDictionaryEnumerator se používá u asociativních datových struktur. Jde o rozhraní používané k procházení obsahu slovníku s dvojící klíč/hodnota, u kterých se prochází podle hodnoty klíče. Umožňuje přístup k prvku, na základě toho klíče. ICollection rozšiřuje rozhraní IEnumerable. Kolekce, které toto rozhraní implementují, mohou být také procházeny pomocí cyklu foreach.
5.3.2 Rozhraní pro řazení IComparer obsahuje metodu vracející int a v této metodě Compare(object x, object y) porovnává dva nezávislé objekty. IComparable pomáhá identifikovat své pořadí vzhledem k jinému prvku stejného typu. Pokud má prvek menší hodnotu, vrací se záporné číslo, pokud má větší hodnotu tak kladné číslo a při rovnosti nula.
35
6. Implementace Kapitola obsahuje podrobný popis založení databáze a obsahuje ukázky a popis syntaxe LINQ to SQL. Ukázky jsou pro demonstraci potřebné, neboť jsem s objektovou prací v prostředí databáze setkal až při tvorbě této aplikace a ukázky zdrojového kódu by čtenáři mohli pomoci k lepšímu porozumění řešeného problému.
6.1 Založení databáze Důležitou součástí každé vyvíjené aplikace je bezpochyby databáze. Následující část bude věnována problému práce s databází v prostředí C#.NET. Bude zde popsán postup, jak založit novou databázi a jak s ní následně pracovat.
6.1.1 Vložení nové databáze V okně pro přidávání nových položek si zvolíme Service-based Database. Po přidání se databáze zobrazí v záložce Server Explorer.
6.1.2 Založení tabulek Pro přidání tabulek se použije zmíněný Server Explorer. V založené databázi rozkliknu možnosti až po složku Tables. Pravým tlačítkem zvolíme možnost Add New Table, poté se otevře Table designer. Pro přidání nového záznamu pouze zapisujeme data na řádky (tyto řádky budou později sloupce tabulky) v okně Design. Každá tabulka musí mít primární klíč, ten se při založení přidá automaticky, pouze ho ručně upravíme, aby se vyplňoval automaticky. Pro přidání jsou dvě možnosti, klikneme pravým tlačítkem na záznam a dáme Set Primary Key, nebo v okně T-SQL upravíme SQL příkaz, kde připíšeme PRIMARY KEY IDENTITY. Primární klíč ještě může mít vlastnost automatického zadávání ID, je vhodné tuto vlastnost nastavit, abychom se nemuseli zabývat unikátním označením primárního klíče. Zvolíme řádek s primárním klíčem a jdeme do Properties, zde nastavím Identity Specification na True. Pokud necháme další možnosti na defaultní hodnotě, bude se nám primární klíč automaticky číslovat od jedničky a bude přirůstat po jedné. Od této chvíle se o primární klíč nemusíme starat.
36
Pro přidání tabulky do databáze, musíme ještě vykonat vygenerovaný SQL příkaz. Zvolíme možnost Update, necháme IDE vygenerovat potřebná data, která pak vložíme možností Update Database. Tímto jsme založili novou tabulku.
6.1.3 Propojení tabulek pomocí cizího klíče Pokud máme založeno více tabulek a chceme je propojit cizím klíčem, tak v designu tabulky pravým tlačítkem přidáme nový cizí klíč. Foreign Keys > Add New Foreign Keys. Právě se nám do okna T-SQL vygenerovaly SQL příkazy, které ještě musíme upravit (viz obrázek). Místo automaticky napsaného ToTable zadáme tabulku, na kterou budeme napojeni, možnost Column bude záznam z této tabulky, který se bude chovat jako cizí klíč (oba záznamy musejí být nastaveny na stejný datový typ). Poslední údaj pro změnu je ToTableColumn, tento záznam je odkaz na primární klíč druhé tabulky. Výsledek celého propojení je zobrazen na obrázku.
Obrázek 9 Výsledek po spojení tabulek pomocí cizího klíče (Zdroj: vlastní)
37
6.2 Ovládání databáze Abychom mohli databázi ovládat pomocí LINQ to SQL, musíme do projektu přidat prvek LINQ to SQL Classes (pojmenujeme ho třeba Ucto). Po vložení do projektu, dvojklikem otevřeme designer, do kterého ze Server Exploreru vložíme tabulky (metodou drag and drop). Po takovémto vložení tabulek budeme mít ze zdrojového kódu objektový přístup do databáze. Před každým pokusem o práci s daty, založíme novou proměnnou, u které bude jméno jejího datového typ částečně složeno podle založeného prvku LINQ to SQL Classes. Jméno bude ve formátu NazevPridanehoPrvkuDataContext. Pro správné uvolňování paměti je vhodné používat direktivu using. Ukázka kódu potřebného pro práci s databází. using (UctoDataContext db = new UctoDataContext ()) { // LINQ to SQL dotazy }
6.2.1 Zapisování do databáze Pro zapisování záznamů do databáze se používá vytvořená proměnná, jméno tabulky a metoda InsertOnSubmit(parametr), která má jako parametr vkládaná data. Ukázka vkládání nového bankovního výpisu do databáze: using (DataClassesDataContext db = new DataClassesDataContext()) { var cisloUctu = db.UCETs.Single(st => st.id_ucet == ucet.id_ucet); var novyVypis = new VYPIS() { id_ucet = cisloUctu.id_ucet, typ = typ, cena = cena, druh_platby = popis, datum = datum }; db.VYPIS.InsertOnSubmit(novyVypis); db.SubmitChanges(); _AktualizujGridVypis(); }
6.2.2 Zobrazování a úprava záznamů Po zobrazení záznamů je třeba načíst data z databáze a tyto data pak vložit do komponenty DataGridView jako jeho DataSource. Ačkoli DataGridView nabízí 38
možnost pro úpravu záznamů přímo ve svém obsahu, při tomto způsobu načtení se tato funkce nedá využít. Proto se se musejí záznamy upravit načtením do komponent, ve kterých byly přidány do databáze. Pro načtení záznamů se využije funkcí jazyka LINQ, při načítání máme možnost výběru všech sloupců, které bude později obsahovat DataGridView, pokud nepřejmenujeme jeho sloupce, budou mít názvy podle nově založených hodnot. Ukázka kódu zobrazuje vytvoření nového DataSource pro zobrazení a přejmenování hlaviček nových sloupců. using (DataClassesDataContext db = new DataClassesDataContext()) { var ucet = from typ in db.UCETs select typ; var vypisy = from ut in db.VYPIS select new { id = ut.id_vypis, ucet = ucet.Single(jm => jm.id_ucet == ut.id_ucet).nazev, cena = ut.cena, }; dgv_Vypisy.DataSource = vypisy; dgv_Vypisy.Columns["id"].Visible = false; dgv_Vypisy.Columns["ucet"].HeaderText = "Bankovní účet"; dgv_Vypisy.Columns["cena"].HeaderText = "Cena"; }
Pro upravení řádku tabulky si tento záznam v tabulce vyhledáme podle jeho identifikačního čísla a pouze mu pomocí funkcí jazyka přepíšeme hodnoty. Hodnoty se v databázi aktualizují po zavolání metody SubmitChanges(), po změně hodnot je třeba ještě aktualizovat zobrazené záznamy. using (DataClassesDataContext db = new DataClassesDataContext()) { var getData = db.VYPIS.SingleOrDefault(a => a.id_vypis == upravPodleId); Ucet ucet = (Ucet)cbx_Banky.SelectedItem; var cisloUctu = db.UCETs.Single(st => st.id_ucet == ucet.id_ucet); getData.id_ucet = cisloUctu.id_ucet; getData.typ = rb_BankaPrijem.Checked; getData.druh_platby = tb_BankaDruhPlatby.Text; getData.datum = new DateTime(dtp_BankaDatum.Value.Year, dtp_BankaDatum.Value.Month, dtp_BankaDatum.Value.Day); db.SubmitChanges(); _AktualizujGridVypis(); }
39
6.2.3 Mazání záznamů Mazání dat z databáze je možné třemi způsoby. Data můžeme z databáze fyzicky odstranit, přesunout, nebo je můžeme „schovat“. Každá možnost má své výhody a nevýhody. V praxi je nejčastěji používána metoda skrytí záznamu, jejíž největší výhoda je v možnosti rychlé obnovy smazaných dat. Nejhorší možností pro mazání je přesouvání do duplicitní databáze. Výhoda této metody je pouze v uschování smazaných záznamů. Nevýhod je celá řada, musíme ošetřovat chyby, které nastanou v případě mazání rodičovských záznamů, v případě úpravy databáze se musí údržba provést na dvou místech a jakákoli úprava bude trvat delší dobu. Pro uživatelem ovládaná data je použito schování záznamu. Smazání záznamu se provádí přepisem hodnoty ve speciálním sloupci, který určuje, zdali je sloupec smazán, nebo ne. Smazané záznamy jsou pak skryty při výběru z databáze, kdy jsou vybrány všechny neoznačené. Metoda je vhodná především při častějších obnovách, protože stačí pouze změnit hodnotu ve sloupci. Při smazání rodičovského záznamu pak použijeme další podmínku, která bude vybírat jenom záznamy, jejichž cizí klíče nemají záznam o smazání. Fyzické smazání záznamu je vhodné ve velikých tabulkách, které mají spoustu sloupců a záznamů, a také z nich je častěji mazáno a málo obnovováno. Mohlo by se jednat třeba o výrobní frontu, kde po vyrobení prvku není nadále potřeba udržovat tento záznam. Při mazání napojených tabulek se může použít kaskádové mazání, které smaže i všechny napojené tabulky (podobně jako při skrytí záznamu udělá podmínka). V LINQ to SQL se může pro mazání použít metody DelleteOnSubmit(záznam), nebo DelleteAllOnSubmit(záznam). DelleteOnSubmit smaže pouze jeden záznam (proto se musí programově ošetřit, pokus o mazání skupiny záznamů, například metodou „Single()“, jak je tomu v ukázce). DelleteAllOnSubmit smaže všechna data.
40
using (DataClassesDataContext db = new DataClassesDataContext()) { var smazat = (from doklad in db.DOKLADs where doklad.id_doklad == mazane_id select doklad).Single(); db.DOKLADs.DeleteOnSubmit(smazat); db.SubmitChanges(); _AktualizujGridDoklad(); }
6.3 Grafické rozhraní Prezentační vrstva je zodpovědná za zpracování a zobrazování informací. Zpracování probíhá v levé části hlavního dialogového okna, zbytek aplikace louží pro zobrazování. Grafické rozhraní se upravuje pomocí vizuálního designeru Visual Studia.
Obrázek 10 Úvodní obrazovka po spuštění aplikace (Zdroj: vlastní)
6.4 Zobrazování záznamů Protože se data vkládají do DataGridView, kterému jsou definovány jenom některé základní vlastnosti pro zobrazení (šířka sloupce, styl přidávání, vybírání záznamů), musíme po vložení hodnoty ještě programově upravit detaily. Jedná se především o skrytí identifikačních čísel záznamu a přejmenování hlaviček sloupců, aby obsahovaly diakritiku a mezery.
41
using (DataClassesDataContext db = new DataClassesDataContext()) { var ucty = from ucet in db.UCETs where ucet.nazev == filtrovaciPodminka select new { id = ucet.id_ucet, nazev = ucet.nazev, }; dgvUcty.DataSource = ucty; dgvUcty.Columns["id"].Visible = false; dgvUcty.Columns["nazev"].HeaderText = "Název"; }
6.5 Filtrování U záznamů které potřebují filtrování, jsou obsažena zadávací pole pro určení filtrovacích podmínek. Filtrování se pak provede pomocí Lambda výrazu, ten vynechá nežádoucí údaje podle aktuálního nastavení filtrů. Lambda výraz je v C# obsažený od verze 3.0. Je to anonymní funkce pro vytvoření delegátů nebo podmínek. Výraz může být použit jako lokální funkce, která může být předána jako parametr nebo vrácena jako hodnota funkce. Lambda výrazy jsou vhodné ve spojení s LINQ dotazy. První příklad zobrazuje filtrování uložených dokladů podle minimální ceny, druhý podle části názvu. doklady = doklady.Where(dok => dok.cena > cenaOd); doklady = doklady.Where(dok => dok.nazev.Contains(nazev));
42
Závěr Cílem práce bylo vytvořit účetní aplikaci v prostředí .NET C#, která by se používala pro podvojné účetnictví spolku, evidenci majetku, správu faktur a záznamy o stavu na založených účtech. Tvorbě aplikace byly velice přínosné časté konzultace s budoucím uživatelem. Při těchto konzultacích jsme se domluvili na drobných úpravách, na grafickém rozhraní, a upřesnili jsme požadavky. Projekt se během svého vzniku projevil jako velmi komplexní, vyžadující intenzivní studium jak tuzemských, tak převážně zahraničních zdrojů. Získané zkušenosti budou s vysokou pravděpodobností aplikovatelné pro další projekty i práci v oboru. V rámci implementace programu projekt několikrát dosahoval neuspokojivých výsledků, jak z hlediska grafického vzhledu, tak použitých technologií nebo ovládání databáze. Jediným řešením se ukázalo být několikanásobné přepracování mnohdy již z velké části fungující aplikace, kdy se prokázalo, že programování je neustálým koloběhem přepisování a ladění. Výstupem práce je funkční formulářová aplikace na platformě .NET založená na dialogových oknech a prací s databází. Veškeré funkce byly prezentovány zadavateli a jím i testovány. Aplikace je v současné době používána účetním spolku. Celkové provedení, funkce a spolehlivost jsou hodnoceny velmi kladně. Možnosti využití vytvořeného programu ostatními entitami jsou v budoucnu, vzhledem k designu na míru sboru dobrovolných hasičů, striktně limitovány na neplátce DPH. Nabízí se mnoho možností pro rozšíření a zvýšení komfortu práce. Je možno vylepšit stávající funkce nebo aplikaci rozšířit o další funkce jako například. Jako možná úpravy jsou především
Daňový základ. Pokud by tato funkce byla potřebná, celý program by se musel rozšířit o možnost zadávání a počítání s DPH. Toto rozšíření by jistě přineslo značné komplikace, jelikož by šlo o úpravu všech částí aplikace.
43
Import záznamů pro toto rozšíření by se dalo využít providera třetí strany pro LINQ. Například LINQ to Excel by umožnil vkládání většího množství, podle zadané struktury.
Práce ve vláknech nebyla pro aplikaci podstatná. Toto rozšíření by mohlo přinést jisté komplikace, ale přispělo by zrychlením.
Zálohování dat na webový server. Zálohy by byla prospěšná především v případě ztráty všech dat na pevném disku. Současné zálohování je použitelné jako rollback databáze a pro archivaci dat je potřeba uložit databázi na jiný disk.
Nasazením aplikace práce neskončila, pouze se místo vývoje bude provádět údržba, ladění a přidávání funkcí podle požadavků účetního.
44
Seznam použité literatury [1]
Microsoft Developer Network. Výuka pro vývojáře na webu Microsoft
Developer Network [online]. [cit. 2016-06-05]. Dostupné z: https://msdn.microsoft.com [2]
Praktické objektové programování v jazyce C# 4.0. Brno: Artax a.s., 2009. ISBN
978-80-87017-07-. [3]
SELLS, Chris. C# a Winforms: programování formulářů windows. Vyd. 1.
Brno: Zoner Press, 2005, 648 s. ISBN 80-868-1525-0 [4]
PIALORSI, Paolo a Marco RUSSO. Microsoft LINQ: kompletní průvodce
programátora. Brno: Computer Press, 2009. Programování (Computer Press). ISBN 978-80-251-2735-3. [5]
STANEK,
William
R. Microsoft
SQL
Server
2012:
kapesní
rádce
administrátora. Brno: Computer Press, 2013. Microsoft (Computer Press). ISBN 97880-251-3797-0. [6]
WATSON, Karli. Beginning Visual C# 2012 programming. Indianapolis, IN:
John Wiley & Sons, c2013. Wrox beginning guides. [7]
POKORNÝ, Jan. Úvod do .NET Framework. Brno: Mobil Media, 2002. ISBN
80-86593-16-9. [8]
RICHTER, Jeffrey. .NET Framework programování aplikací. Praha: Grada,
2003. Moderní programování. ISBN 80-247-0450-1. [9]
LERMAN, Julia. Programming entity framework. 2nd ed. Beijing: O´Reilly,
c2010. ISBN 978-0-596-80726-9. [10]
BYSTRÝ, Ondřej. Technologie COM ve vývojovém nástroji Microsoft Visual
Studio. 2006. [11]
ŠÍMA, František a David VILÍMEK. Microsoft Visual Studio .NET: praktické
programování krok za krokem. Praha: Grada, 2006. Průvodce (Grada). ISBN 80-2471418-3. [12]
Architektura .NET Framework. http://www.cs.vsb.cz [online]. [cit. 2016-08-31].
Dostupné z: http://www.cs.vsb.cz/behalek/vyuka/pcsharp/text/ch01s01.html 45
Seznam obrázků Obrázek 1 Přidání dat do účetního systému DeCe 2011 ................................................ 10 Obrázek 2 Přehled účetních dokladů za vybrané období. ............................................... 11 Obrázek 3 Architektura .NET Framework ..................................................................... 17 Obrázek 4 Vykonání LINQ dotazu nad databází MSSQL ............................................. 19 Obrázek 5 Použitý model databáze ................................................................................. 25 Obrázek 6 Potvrzení události pomocí třídy MessageBox. .............................................. 26 Obrázek 7 Získání údajů od uživatele ve vlastním dialogovém okně. ........................... 27 Obrázek 8 Použití komponent MenuStrip a TabControl v aplikaci................................ 28 Obrázek 9 Výsledek po spojení tabulek pomocí cizího klíče ......................................... 37 Obrázek 10 Úvodní obrazovka po spuštění aplikace ...................................................... 41
Seznam Tabulek Tabulka 1 Porovnání účetních aplikací nabízených na trhu ........................................... 12
46
Seznam použitých zkratek CLR
Common Language Runtime
COM
component object model
CSS
Cascading Style Sheets
FIFO
(First In First Out) První dovnitř, první ven. Jedná se o jednoduchou metodu řízení
GUI
(Graphical User Interface) Grafické uživatelské rozhraní
HTML
HyperText Markup Language
IDE
(Integrated Development Environment) Vývojové prostředí
LIFO
(Last In First Out) Poslední dovnitř, první ven. Jedná se o jednoduchou metodu řízení
LINQ
(Language-Integrated Query) sada funkcí pro vyhledávání v kolekcích dat
MSSQL
Microsoft SQL Server
ORM
Objektově relační zobrazení
SQL
(Structured Query Language) strukturovaný dotazovací jazyk
XHTML
Extensible hypertext markup language
XML
(Extensible Markup Language) rozšiřitelný značkovací jazyk
XSLT
Extensible Stylesheet Language Transformations
47
Přílohy 1. Obsah přiloženého CD
48
