Daňové odpisy
výběr z kódu
plain-text
**********************************************************************************************
**********************************************************************************************
Třída Přehled Majetku - přehled položek majetku.
**********************************************************************************************
**********************************************************************************************
public partial class PrehledMajetku : Form
{
/// <summary>
/// Řádek ve vystupPrehledListView.
/// </summary>
private ListViewItem item;
/// <summary>
/// Instance třídy Filtrovac - práce s databází.
/// </summary>
Filtrovac filtrovac = new Filtrovac();
/// <summary>
/// Převzato - řazení sloupců.
/// </summary>
private ListViewColumnSorter lvwColumnSorter;
/// <summary>
/// Pole představující parametry pro filtr.
/// </summary>
private string[] filtr = new string[6];
/// <summary>
/// Konstruktor - úvodní nastavení.
/// </summary>
public PrehledMajetku()
{
InitializeComponent();
NactiToolTipy();
//úvodní zobrazení
idDotextBox.Text = "100";
datumOdDateTimePicker.Text= "1.1.2000";
datumDoDateTimePicker.Text = DateTime.Now.ToShortDateString();
odpisovaSkupComboBox.SelectedIndex = 0;
ZobrazMajetek();
//kliknutí na řádek vystupPrehledListView
vystupPrehledListView.MouseDown += new MouseEventHandler(this.vystupPrehledListView_MouseDown);
//řazení sloucpů
lvwColumnSorter = new ListViewColumnSorter();
this.vystupPrehledListView.ListViewItemSorter = lvwColumnSorter;
this.vystupPrehledListView.ColumnClick += new System.Windows.Forms.ColumnClickEventHandler(this.vystupPrehledListView_ColumnClick);
}
/// <summary>
/// Metoda pro výpis vybraného majetku na vystupListView.
/// Volá metodu Zobraz ve tříde Filtrovač s parametrem NastavFiltr()
/// </summary>
private void ZobrazMajetek()
{
foreach (string[] radek in filtrovac.Zobraz(NastavFiltr()))
{
item = new ListViewItem(radek);
vystupPrehledListView.Items.Add(item);
}
}
/// <summary>
/// Metoda, která nastaví parametry filtru dle zadaných údajů uživatelem pro zobrazení vybraných položek majetku.
/// </summary>
/// <returns>string[] parametry pro filtr</returns>
private string[] NastavFiltr()
{
for (int i = 0; i < filtr.Length; i++)
filtr[i] = "0";
if (nazevTextBox.Text != "")
filtr[0] = nazevTextBox.Text;
if (idOdtextBox.Text != "")
filtr[1] = idOdtextBox.Text;
if (idDotextBox.Text != "")
filtr[2] = idDotextBox.Text;
filtr[3] = datumOdDateTimePicker.Value.ToString();
filtr[4] = datumDoDateTimePicker.Value.ToString();
filtr[5] = (odpisovaSkupComboBox.SelectedIndex).ToString();
vystupPrehledListView.Items.Clear();
return filtr;
}
/// <summary>
/// Otevře okno pro přidání okno (formulář) položky majetku.
/// </summary>
private void pridejPolozkuButton_Click(object sender, EventArgs e)
{
PridavacMajetku novy = new PridavacMajetku();
novy.ShowDialog();
}
/// <summary>
/// Reakce při dvojkliku - otevření příslušné položky majetku (přepnutí do kalkulátoru odpisů).
/// </summary>
private void vystupPrehledListView_MouseDown(Object sender, MouseEventArgs e)
{
// e.Clicks == 2 - dvojklik
if ((e.Button == MouseButtons.Left) && (e.Clicks == 2))
{
int id = int.Parse(vystupPrehledListView.SelectedItems[0].SubItems[0].Text);
Odpisovac odpisovac = new Odpisovac(filtrovac.VratDleID(id));
odpisovac.ShowDialog();
}
}
/// <summary>
/// Zkontroluje údaje zadané uživatelem a volá metoda ZobrazMajetek() pro výpis vybraných položek majetku.
/// </summary>
private void filtrujButton_Click(object sender, EventArgs e)
{
long id1;
long id2;
string s1 = "0";
string s2 = "0";
if (idOdtextBox.Text != "")
s1 = idOdtextBox.Text;
if (idDotextBox.Text != "")
s2 = idDotextBox.Text;
if (!long.TryParse(s1, out id1) | !long.TryParse(s2, out id2) | id1 < 0 | id2 < 0 | id1 > id2)
MessageBox.Show("Neplatné ID - ID musí být nezáporné celé číslo, kde ID od je větší nebo rovno do!", "Zpráva", MessageBoxButtons.OK, MessageBoxIcon.Asterisk);
else if (datumOdDateTimePicker.Value > datumDoDateTimePicker.Value)
MessageBox.Show("Datum od musí být větší nebo stejné jako datum do!", "Zpráva", MessageBoxButtons.OK, MessageBoxIcon.Asterisk);
else
ZobrazMajetek();
}
/// <summary>
/// Nastaví všechny políčka filtru na původní hodnotu.
/// </summary>
private void resetButton_Click(object sender, EventArgs e)
{
nazevTextBox.Text = "";
idOdtextBox.Text = "";
idDotextBox.Text = "100";
odpisovaSkupComboBox.SelectedIndex = 0;
datumOdDateTimePicker.Text = "1.1.2000";
datumDoDateTimePicker.Text = DateTime.Now.ToShortDateString();
ZobrazMajetek();
}
...
}
**********************************************************************************************
**********************************************************************************************
Filtrovac - třída pro práci s databází - vrací výstup zpět Třídě PřehledMajetku
**********************************************************************************************
**********************************************************************************************
class Filtrovac
{
/// <summary>
/// Kontext databáze.
/// </summary>
DataClassesDataContext kontext = new DataClassesDataContext();
/// <summary>
/// Proměnná název položky majetku.
/// </summary>
string nazev = "";
/// <summary>
/// Oveření použítí názvu ve filtru.
/// </summary>
bool nazevAno = false;
/// <summary>
/// ID majetku od kterého se vyhledává.
/// </summary>
long idOd;
/// <summary>
/// ID majetku do kterého se vyhledává.
/// </summary>
long idDo;
/// <summary>
/// Datum pořízení majetku od kterého se vyhledává.
/// </summary>
DateTime datumOd;
/// <summary>
/// Datum majetku do kterého vyhledává.
/// </summary>
DateTime datumDo;
/// <summary>
/// Odpisová skupina majetku.
/// </summary>
int odpisovaSkupina = 0;
/// <summary>
/// Oveření pouzžití odpisové skupiny ve filtru.
/// </summary>
bool odpisovaSkupinaAno = false;
public Filtrovac()
{
}
/// <summary>
/// Metoda dle zadaných parametrů filtruje položky majetku z databáze.
/// </summary>
/// <param name="filtr">Vstup převzatý z PrehledMajetku.</param>
/// <returns>List výběr (z db)</returns>
public List<string[]> Zobraz(string[] filtr)
{
NastavHodnotyFiltru(filtr);
List<string[]> vyber = new List<string[]>();
var dotaz = from r in kontext.Majeteks
where (r.MajetekID == 0)
select new { MajetekID = r.MajetekID.ToString(), r.Name, Price = r.Price.ToString(), Date = r.Date.ToShortDateString(), Group = r.Group.ToString() };
if (!nazevAno & !odpisovaSkupinaAno)
{
var dotaz1 = from r in kontext.Majeteks
where (r.MajetekID >= idOd & r.MajetekID <= idDo
& r.Date >= datumOd & r.Date <= datumDo)
select new { MajetekID = r.MajetekID.ToString(), r.Name, Price = r.Price.ToString(), Date = r.Date.ToShortDateString(), Group = r.Group.ToString() };
dotaz = dotaz1;
}
else if (nazevAno & !odpisovaSkupinaAno)
{
var dotaz2 = from r in kontext.Majeteks
where (r.MajetekID >= idOd & r.MajetekID <= idDo
& r.Date >= datumOd & r.Date <= datumDo
& r.Name.ToLower().Contains(nazev.ToLower())
)
select new { MajetekID = r.MajetekID.ToString(), r.Name, Price = r.Price.ToString(), Date = r.Date.ToShortDateString(), Group = r.Group.ToString() };
dotaz = dotaz2;
}
else if (!nazevAno & odpisovaSkupinaAno)
{
var dotaz3 = from r in kontext.Majeteks
where (r.MajetekID >= idOd & r.MajetekID <= idDo
& r.Date >= datumOd & r.Date <= datumDo
& r.Group == odpisovaSkupina)
select new { MajetekID = r.MajetekID.ToString(), r.Name, Price = r.Price.ToString(), Date = r.Date.ToShortDateString(), Group = r.Group.ToString() };
dotaz = dotaz3;
}
else if (nazevAno & odpisovaSkupinaAno)
{
var dotaz4 = from r in kontext.Majeteks
where (r.MajetekID >= idOd & r.MajetekID <= idDo
& r.Date >= datumOd & r.Date <= datumDo
& r.Name.ToLower().Contains(nazev.ToLower())
& r.Group == odpisovaSkupina)
select new { MajetekID = r.MajetekID.ToString(), r.Name, Price = r.Price.ToString(), Date = r.Date.ToShortDateString(), Group = r.Group.ToString() };
dotaz = dotaz4;
}
foreach (var row in dotaz)
{
string d = row.ToString();
filtr = d.Split(',');
vyber.Add(filtr);
}
vyber = Vycisti(vyber);
return vyber;
}
/// <summary>
/// Nastaví úvodní hodnoty filtru
/// </summary>
/// <param name="filtr">Vstup převzatý z formuláře PrehledMajetku.</param>
private void NastavHodnotyFiltru(string[] filtr)
{
nazevAno = false;
odpisovaSkupina = 0;
odpisovaSkupinaAno = false;
if (filtr[0] != "0")
{
nazev = filtr[0];
nazevAno = true;
}
idOd = long.Parse(filtr[1]);
if (filtr[2] != "0")
idDo = long.Parse(filtr[2]);
else
idDo = 9999999999;
datumOd = DateTime.Parse(filtr[3]);
datumDo = DateTime.Parse(filtr[4]);
if (filtr[5] != "0")
{
odpisovaSkupina = int.Parse(filtr[5]) - 1;
odpisovaSkupinaAno = true;
}
}
/// <summary>
/// Vyhledá v databází údaj dle ID majetku.
/// </summary>
/// <param name="id">ID majetku.</param>
/// <returns>Pole z požadovanými údaji, najitými v databází dle ID majetku.</returns>
public string[] VratDleID(int id)
{
string[] filtr = new string[6];
var dotaz = from r in kontext.Majeteks
where (r.MajetekID == id)
select new { MajetekID = r.MajetekID.ToString(), r.Name, Price = r.Price.ToString(), Date = r.Date.ToShortDateString(), Group = r.Group.ToString() };
foreach (var row in dotaz)
{
string d = row.ToString();
filtr = d.Split(',');
}
filtr = VycistiRadek(filtr);
return filtr;
}
/// <summary>
/// Metoda, která opakovaně volá (po jednotlivých "řádcích"/polích v listu) metodu VycistiRadek.
/// </summary>
/// <param name="vyber">List výběr</param>
/// <returns>List výběr očištěný o nepotřebné znaky</returns>
private List<string[]> Vycisti(List<string[]> vyber)
{
foreach (string[] radek in vyber)
{
VycistiRadek(radek);
//+1 u zobrazení odpisové skupiny (indexace od nuly +1)
radek[radek.Length - 1] = (int.Parse(radek[radek.Length - 1]) + 1).ToString();
}
return vyber;
}
/// <summary>
/// Metoda, která upravuje výběr z databáze - odebítá nepotřebné znaky (např. "{Name = něco" -> "něco")
/// </summary>
/// <param name="vyber">pole řádek</param>
/// <returns>pole řádek očištěný o nepotřebné znaky</returns>
private string[] VycistiRadek(string[] radek)
{
int p;
int delka = radek.Length;
//úprava pro začátek a střed řádku
for (int l = 0; l < delka - 1; l++)
{
p = radek[l].IndexOf('=');
radek[l] = radek[l].Remove(0, p + 2);
}
//úprava pro konec řádku
p = radek[delka - 1].IndexOf('=');
radek[delka - 1] = radek[delka - 1].Remove(0, p + 2);
p = radek[delka - 1].IndexOf('}');
radek[delka - 1] = radek[delka - 1].Remove(p - 1, 2);
return radek;
}
}
**********************************************************************************************
**********************************************************************************************
Odpisovač - metoda pro zobrazení odpisů a startu jejich výpočtu.
**********************************************************************************************
**********************************************************************************************
public partial class Odpisovac : Form
{
/// <summary>
/// Pořizovací cena majetku pro počítání odpisů.
/// </summary>
private decimal Cena { get; set; }
/// <summary>
/// Vlastnost pro datum zařazení majetku do používání.
/// </summary>
private DateTime Datum { get; set; }
/// <summary>
/// Řádek ve vystupListView.
/// </summary>
private ListViewItem item;
/// <summary>
/// Proměnná pro typ odpisů (zrychlené = true, rovnoměrné = false)
/// </summary>
private bool typ;
/// <summary>
/// ID položky příslušného majetku v databázi.
/// (vztah 1 majetek...n odpisů)
/// </summary>
private long MajetekID { get; set; }
/// <summary>
/// Název položky majetku.
/// </summary>
string Nazev { get; set; }
/// <summary>
/// Odpisová skupina majetku.
/// </summary>
private int OdpisovaSkupina { get; set; }
/// <summary>
/// Instance třídy kalkulátor, kde probíhá výpočet odpisů dle zadaných parametrů.
/// </summary>
Kalkulator kalkulator = new Kalkulator();
/// <summary>
/// Instance třídy filtrovac odpisů - pro práci s databází.
/// </summary>
FiltrovacOdpisu filtrovac = new FiltrovacOdpisu();
/// <summary>
/// Konstruktor - nastavení úvodních hodnot
/// </summary>
/// <param name="identifikace">Pole parametrů (vstupů) v daném pořadí.</param>
public Odpisovac(string[] identifikace)
{
InitializeComponent();
MajetekID = long.Parse(identifikace[0]);
Nazev = identifikace[1];
cenaTextBox.Text = (decimal.Parse(identifikace[2].Remove(identifikace[2].Length - 3, 3))).ToString();
datumDateTimePicker.Value = DateTime.Parse(identifikace[3]);
odpisovaSkupinaComboBox.SelectedIndex = int.Parse(identifikace[4]);
cenaTextBox.ReadOnly = true;
datumDateTimePicker.Enabled = false;
odpisovaSkupinaComboBox.Enabled = false;
upravButton.Hide();
NactiToolTipy();
Vypis(filtrovac.ZobrazDleMajetekID(MajetekID));
if (filtrovac.ZobrazDleMajetekID(MajetekID).Count != 0)
Zamkni();
}
/// <summary>
/// Reakce na tlačítko Vypočti - kontrola vstupů a volání metod pro vypsání(výpočet) odpisů.
/// </summary>
private void vypoctiButton_Click(object sender, EventArgs e)
{
//pomocná proměnná (true při zjištěné chybě)
bool chyba = false;
decimal cena;
typ = zrychleneRadioButton.Checked;
//kontrola vstupů
if (!decimal.TryParse(cenaTextBox.Text, out cena) | (cena < 2000))
{
MessageBox.Show("Neplatná hodnota - Pořizovací cena! Pořizovací cena musí být vyšší než 2 000!", "Zpráva", MessageBoxButtons.OK, MessageBoxIcon.Asterisk);
chyba = true;
}
//spuštění nastavení a výpočtů
if (!chyba)
{
Cena = Math.Ceiling(cena);
Datum = datumDateTimePicker.Value;
OdpisovaSkupina = odpisovaSkupinaComboBox.SelectedIndex;
Vypis(kalkulator.Vypocti(typ, Cena, Datum, OdpisovaSkupina));
}
}
/// <summary>
/// Metoda pro vypsání 1 naformátovaného řádku tabulky (vystupListView).
/// </summary>
private void Vypis(List<string[]> list)
{
vystupListView.Items.Clear();
foreach (string[] radek in list)
{
for (int i = 0; i < radek.Length; i++)
{
if (radek[i].Contains(".00"))
radek[i] = radek[i].Remove(radek[i].Length - 3, 3);
}
item = new ListViewItem(radek);
vystupListView.Items.Add(item);
}
}
/// <summary>
/// Metoda naplní list náplň (z vystupListView) a volá metodu pro uložení náplně do databáze.
/// V případě, že první krok proběhne v pořádku, volá metodu pro zamknutí možností výpočtu.
/// </summary>
private void ulozButton_Click(object sender, EventArgs e)
{
List <string[]> napln = new List<string[]>();
int i = 0;
if (vystupListView.Items.Count == 0)
MessageBox.Show("Chybí vstupní data pro vytvoření souboru.", "Zpráva", MessageBoxButtons.OK, MessageBoxIcon.Asterisk);
else
{
foreach (ListViewItem item in vystupListView.Items)
{
string[] zaznam = new string[5];
item.Selected = true;
//nastaveni vystupu
zaznam[4] = MajetekID.ToString();
for (int j = 0; j < zaznam.Length - 1; j++)
{
zaznam[j] = vystupListView.SelectedItems[i].SubItems[j].Text;
}
napln.Add(zaznam);
i++;
}
filtrovac.UlozDoDb(napln, MajetekID);
MessageBox.Show("Uloženo", "Zpráva", MessageBoxButtons.OK, MessageBoxIcon.Asterisk);
Zamkni();
}
}
/// <summary>
/// Tlačítko Uprav volá metodu pro odemknutí možností výpočtu.
/// </summary>
private void upravButton_Click(object sender, EventArgs e)
{
Odemkni();
}
/// <summary>
/// Metoda uzamyká možnosti výpočtu a uložení do databáze.
/// </summary>
private void Zamkni()
{
upravButton.Show();
ulozButton.Hide();
vypoctiButton.Hide();
}
/// <summary>
/// Metoda odemyká možnosti výpočtu a uložení do databáze.
/// </summary>
private void Odemkni()
{
ulozButton.Show();
vypoctiButton.Show();
upravButton.Hide();
}
}
**********************************************************************************************
**********************************************************************************************
Třída Kalkulátor pro samotný výpočet odpisů.
**********************************************************************************************
**********************************************************************************************
class Kalkulator
{
/// <summary>
/// Proměnná pro pořizovací cenu majetku.
/// </summary>
private decimal cena;
/// <summary>
/// Proměnná pro zůstatkovou cenu.
/// </summary>
private decimal zcena;
/// <summary>
/// Proměnná pro počet let (dle odpisové třídy zadané uživatelem)
/// </summary>
private byte PocetLet { get; set; }
/// <summary>
/// Proměnná pro rok pořízení majetku a začátku jeho odpisování (zadáná uživatelem).
/// </summary>
private int letopocet;
/// <summary>
/// Proměnná představující částku odpisu v daném roce.
/// </summary>
private decimal odpis;
/// <summary>
/// Pole pro počty let odpisování definované zákonem dle odpisových skupin.
/// </summary>
byte[] poctyLet = { 3, 5, 10, 20, 30, 50 };
/// <summary>
/// Pole pro koeficienty rovnoměrného odpisování definované zákonem dle odpisových skupin.
/// </summary>
decimal[] koeficienty = { 40, 22.25m, 10.5m, 5.15m, 3.4m, 2.02m };
/// <summary>
/// Promenná představující koeficient u rovnoměrných odpisů.
/// </summary>
private decimal Koeficient { get; set; }
private int odpisovaSkupina;
/// <summary>
/// Vlastnost odpisová skupina - při její změně dochází i k nastavení koeficientu a počtu let.
/// </summary>
private int OdpisovaSkupina
{
get
{
return odpisovaSkupina;
}
set
{
odpisovaSkupina = value;
Koeficient = koeficienty[odpisovaSkupina];
PocetLet = poctyLet[odpisovaSkupina];
}
}
/// <summary>
/// List polí výsledku výpočtu daňových odpisů.
/// </summary>
private List<string[]> vypocet = new List<string[]>();
/// <summary>
/// Metoda nastavuje hodnoty výpočtu dle zadaných parametrů a volá metodu představující příslušný způsob výpočtu.
/// </summary>
/// <param name="typ">Odpisy zrychlené true, rovnoměrné false</param>
/// <param name="cena">Cena pořízení majetku.</param>
/// <param name="datum">Datum zařazení do užívání.</param>
/// <param name="odpisSkup">Odpisová skupina majetku.</param>
/// <returns></returns>
public List<string[]> Vypocti(bool typ, decimal cena, DateTime datum, int odpisSkup)
{
this.cena = cena;
zcena = cena;
OdpisovaSkupina = odpisSkup;
letopocet = datum.Year;
vypocet.Clear();
if (typ)
ZrychleneOdpis();
else
RovnomerneOdpis();
return vypocet;
}
/// <summary>
/// Metoda pro výpočt zrychlených odpisů.
/// Volá metodu ZahrnDoListu() pro zařazení výpočtu daného roku do listu vypocet.
/// </summary>
private void ZrychleneOdpis()
{
odpis = Math.Ceiling(zcena / PocetLet);
zcena = zcena - odpis;
ZahrnDoListu();
letopocet = letopocet + 1;
for (int i = 1; i < PocetLet; i++)
{
odpis = Math.Ceiling(2 * zcena / (PocetLet + 1 - i));
zcena = zcena - odpis;
ZahrnDoListu();
letopocet = letopocet + 1;
}
}
/// <summary>
/// Metoda pro výpočet rovnoměrných odpisů.
/// Volá metodu ZahrnDoListu() pro zařazení výpočtu daného roku do listu vypocet.
/// </summary>
private void RovnomerneOdpis()
{
odpis = cena * (100 - (Koeficient * (PocetLet - 1))) / 100;
odpis = Math.Ceiling(odpis);
zcena = zcena - odpis;
ZahrnDoListu();
letopocet = letopocet + 1;
for (int i = 1; i < PocetLet; i++)
{
if (i == PocetLet - 1 & zcena < odpis)
{
odpis = zcena;
zcena = zcena - odpis;
ZahrnDoListu();
}
else
{
odpis = cena * Koeficient / 100;
odpis = Math.Ceiling(odpis);
zcena = zcena - odpis;
ZahrnDoListu();
letopocet = letopocet + 1;
}
}
}
/// <summary>
/// Metoda přidá výpočet 1 roku (který představuje 1 řádek ve na výstupu) do listu výpočet.
/// </summary>
private void ZahrnDoListu()
{
string[] zaznam = new string[4];
zaznam[0] = letopocet.ToString();
zaznam[1] = odpis.ToString();
zaznam[2] = zcena.ToString();
zaznam[3] = (cena-zcena).ToString();
vypocet.Add(zaznam);
}
}
**********************************************************************************************
**********************************************************************************************Neformátovaný
Přidáno: 8.6.2013
Expirace: Neuvedeno
Autor: Neaktivní uživatel