public async Task <IActionResult> Edit(int id, [Bind("ProduktKategorieId,Name")] Kategorie kategorie)
{
if (id != kategorie.ProduktKategorieId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(kategorie);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!KategorieExists(kategorie.ProduktKategorieId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(kategorie));
}
/// <summary>
/// Úvodní nastavení okna.
/// </summary>
/// <param name="PridavaciRezim">TRUE - Režim okna pro přidání nových položek, FALSE - Režim okna pro úpravu stávajících položek</param>
public void UvodniNastaveni(bool PridavaciRezim)
{
// Nastavení názvu okna
Title = PridavaciRezim ? "Přidat nové položky" : "Upravit položky";
// Nastavení ikony okna
Icon = new BitmapImage(new Uri(Path.Combine(Validace.VratCestuSlozkyAplikace(), "Icons\\NewFile.png")));
// Úvodní inicializace pomocných proměnných
Nazev = "";
Popis = "";
Cena = 0;
KategoriePolozky = Kategorie.Nevybrano;
// Vytvoření instance třídy pro nastavení stylů tlačítek
GrafickePrvky Grafika = new GrafickePrvky();
// Nastavení stylu tlačítek
Grafika.NastavTlacitkoPRIDAT(PridatButton);
Grafika.NastavTlacitkoODEBRAT(OdebratButton);
// Nastavení zadávacích polí
NazevPolozkyTextBox.Text = Nazev;
PopisTextBox.Text = Popis;
Controller.NastavKategorieDoComboBoxu(KategorieComboBox);
}
private async void DodajKategorieExecute()
{
PokazProgressDodajKategorie = true;
await _repozytorium.CategoriesRepository.Add(RegistryPomocnik.NazwaZalogowanegoUzytkownika, RegistryPomocnik.KluczUzytkownika, NazwaKategorii)
.ContinueWith(task =>
{
if (task.Status == TaskStatus.RanToCompletion &&
task.Result != null &&
task.Result.StatusCode == System.Net.HttpStatusCode.OK)
{
Application.Current.Dispatcher.Invoke(() =>
{
Kategorie.Add(new Category()
{
Name = NazwaKategorii
});
NazwaKategorii = string.Empty;
PokazProgressDodajKategorie = false;
});
}
else
{
Application.Current.Dispatcher.Invoke(() =>
{
MessageBox.Show("błąd");
});
}
});
}
/// <summary>
/// Konstruktor třídy pro vytvoření nové položky s nastavením všech parametrů předaných v konstruktoru.
/// </summary>
/// <param name="Nazev">Název položky</param>
/// <param name="Cena">Hodnota položky</param>
/// <param name="kategorie">Kategorie položky</param>
/// <param name="popis">Textový popis položky</param>
public Polozka(string Nazev, double Cena, Kategorie kategorie, string popis)
{
this.Nazev = Nazev;
this.Cena = Cena;
this.KategoriePolozky = kategorie;
this.Popis = popis;
}
public void Populate()
{
UIManager manager = GameObject.Find("Canvas").GetComponent <UIManager>();
Kategorie = manager.KategorieClicked;
Debug.Log("Populate Kategorie" + Kategorie.Name);
GameObject newObj;
Debug.Log(Kategorie.gameObjects.Length);
for (int i = 0; i < Kategorie.gameObjects.Length; i++)
{
newObj = Instantiate(prefab, transform);
newObj.GetComponent <Eintrag>().Name = (Kategorie.gameObjects[i] as GameObject).name;
newObj.GetComponent <Eintrag>().Width = (Kategorie.gameObjects[i] as GameObject).transform.localScale.x;
newObj.GetComponent <Eintrag>().Heigth = (Kategorie.gameObjects[i] as GameObject).transform.localScale.y;
newObj.GetComponent <Eintrag>().Depth = (Kategorie.gameObjects[i] as GameObject).transform.localScale.z;
newObj.GetComponent <Eintrag>().GameObject = Kategorie.gameObjects[i] as GameObject;
InstantiatedObjects.Add(newObj);
GameObject go = Kategorie.gameObjects[i] as GameObject;
Sprite mySprite = Sprite.Create(RuntimePreviewGenerator.GenerateModelPreview(go.transform, 128, 128), new Rect(.0f, .0f, 128, 128), new Vector2(.5f, .5f), 100.0f);
newObj.GetComponent <Eintrag>().Image.sprite = mySprite;
}
}
// GET: Zgloszenias/Delete/5
public ActionResult Delete(int?id)
{
ApplicationUser user = db.Users.Find(User.Identity.GetUserId());
if (user.ChangedPassword == 1)
{
if (id == null || user.KategorieId != 9)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Zgloszenia zgloszenia = db.Zgloszenias.Find(id);
if (zgloszenia == null)
{
return(HttpNotFound());
}
Kategorie a = db.Kategories.Find(zgloszenia.KategorieId);
ViewBag.Kategoria = a.Nazwa;
Statusy b = db.Statusys.Find(zgloszenia.StatusyId);
ViewBag.Status = b.Nazwa;
return(View(zgloszenia));
}
else
{
return(RedirectToAction("ChangePassword", "Manage"));
}
}
private void SynchronizovatLokalniDatabaziAsync()
{
if (App.CheckForInternetConnection() == true)
{
var kategorie = App.DatabazeKategorii.GetItemsRest();
var zbozi = App.DatabazeZbozi.GetItemsRest();
App.DatabazeKategorii.DeleteItemsFromTable();
App.DatabazeZbozi.DeleteItemsFromTable();
App.CartDatabase.DeleteItemsFromTable();
foreach (Kategorie kategorie_item in kategorie)
{
Kategorie kategorie_obj = new Kategorie();
kategorie_obj.ID = kategorie_item.ID;
kategorie_obj.NazevKategorie = kategorie_item.NazevKategorie;
App.DatabazeKategorii.SaveItemAsync(kategorie_obj);
}
foreach (Zbozi zbozi_item in zbozi)
{
Zbozi zbozi_obj = new Zbozi();
zbozi_obj.ID = zbozi_item.ID;
zbozi_obj.KategorieZbozi = zbozi_item.KategorieZbozi;
zbozi_obj.NazevZbozi = zbozi_item.NazevZbozi;
zbozi_obj.PocetKusuSkladem = zbozi_item.PocetKusuSkladem;
zbozi_obj.Popis = zbozi_item.Popis;
zbozi_obj.Vyprodej = zbozi_item.Vyprodej;
zbozi_obj.FotoZbozi = zbozi_item.FotoZbozi;
zbozi_obj.Cena = zbozi_item.Cena;
zbozi_obj.CenaPredSlevou = zbozi_item.CenaPredSlevou;
App.DatabazeZbozi.SaveItemAsync(zbozi_obj);
}
}
}
public async Task <ActionResult <Kategorie> > PostCategory(Kategorie kategorie)
{
if (kategorie == null)
{
return(BadRequest());
}
if (!TokenProvider.IsAdmin(User))
{
return(Unauthorized());
}
_context.Kategorie.Add(kategorie);
try
{
await _context.SaveChangesAsync().ConfigureAwait(false);
}
catch (DbUpdateException)
{
if (KategorieExists(kategorie.Id))
{
return(Conflict());
}
throw;
}
return(CreatedAtAction("GetCategory", new { id = kategorie.Id }, kategorie));
}
public void RueckerstattungErfassenTest_KorrektesErfassen()
{
//Arrange
Model model = new Model();
int kId = model.LadeKreditoren("").First().ID;
Kategorie kat = model.LadeKategorien().First();
Rechnung sollRueckerstattung = new Rechnung
{
Beschreibung = "Testrueckerstattung",
Betrag = 100m,
Kategorie = kat.Name,
KreditorID = kId,
AlsRueckzahlung = true
};
//Act
this._id = model.SpeichereRueckzahlung(sollRueckerstattung);
List <Rechnung> rlist = model.LadeRueckzahlungen("");
Rechnung istRueckzahlung = rlist.First(i => i.ID == this._id);
//Assert
Assert.IsNotNull(istRueckzahlung);
Assert.IsTrue(istRueckzahlung.Beschreibung == "Testrueckerstattung");
Assert.IsTrue(model.LoescheRueckzahlung(istRueckzahlung));
}
//Alternativ zu den Feldern (Teil b) mit Properties (erspart uns die mühseligen getter- und setter-Methoden)
/*
* public string bezeichnung {get; set;}
* public int registriernummer {get; set;}
* public Kategorie kategorie {get; set;}
* public float leistung {get; set;}
*
* //-> ausführliche Schreibweise mit get und set (hier wird das Property als Wrapper für das Feld 'leistung' benutzt)
* public float leistungProperty
* {
* get
* {
* return this.leistung;
* }
* set
* {
* this.leistung = value;
* }
* }
* //Auch ausführlich, aber in Kurzform:
* public float leistungProperty
* {
* get => this.leistung;
*
* set => this.leistung = value;
* }
*/
//Konstruktor mit vier Parametern
public Energiewesen(string bez, int regNr, Kategorie kat, float leistung)
{
bezeichnung = bez;
registriernummer = regNr;
kategorie = kat;
this.leistung = leistung;
}
public async Task <IActionResult> PutCategory(long id, Kategorie kategorie)
{
if (id != kategorie.Id)
{
return(BadRequest());
}
if (!TokenProvider.IsAdmin(User))
{
return(Unauthorized());
}
_context.Entry(kategorie).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync().ConfigureAwait(false);
}
catch (DbUpdateConcurrencyException)
{
if (!KategorieExists(id))
{
return(NotFound());
}
throw;
}
return(Ok());
}
/// <summary>
/// Úvodní nastavení okna v režimu úpravy existujícího záznamu.
/// </summary>
/// <param name="zaznam">Záznam určený k úpravě</param>
public void UvodniNastaveniRezimuUpravovani(Zaznam zaznam)
{
// Úvodní nastavení okna
Title = "Úprava existujícího záznamu";
Icon = new BitmapImage(new Uri(Path.Combine(Validace.VratCestuSlozkyAplikace(), "Icons\\Disketa.png")));
// Úvodní nastavení interních proměnných
Nazev = zaznam.Nazev;
Datum = zaznam.Datum;
PrijemNeboVydaj = zaznam.PrijemNeboVydaj;
PrijemVydaj_Hodnota = zaznam.Hodnota_PrijemVydaj;
Poznamka = zaznam.Poznamka;
KategorieZaznamu = zaznam.kategorie;
// Vytvoření instance třídy pro nastavení stylů tlačítek
GrafickePrvky Grafika = new GrafickePrvky();
// Nastavení stylu tlačítek
Grafika.NastavTlacitkoULOZIT(UlozitButton);
Grafika.NastavTlacitkoUPRAVITPOZNAMKU(NastavPoznamkuButton);
Grafika.NastavTlacitkoUPRAVITPOLOZKY(NastavPolozkuButton);
// Nastavení zadávacích polí
NastavZadavaciPole();
// Nastavení zobrazení kategorie a hodnoty záznamu
KategorieComboBox.SelectedIndex = (int)KategorieZaznamu - 1;
PrijemVydajComboBox.SelectedIndex = (int)PrijemNeboVydaj;
PrijemVydajTextBox.Text = PrijemVydaj_Hodnota.ToString();
}
public static void Main(string[] args)
{
#if DEBUG
args = new string[] { "einzahlung", "400" };
//args = new string[] { "auszahlung", "5,99", "Restaurantbesuche", "Schokobecher" };
//args = new string[] { "auszahlung", "01.01.2015", "700", "Miete" };
//args = new string[] { "einzahlung", "01.01.2015", "400" };
//args = new string[] { "übersicht" };
//args = new string[] { "übersicht", "12", "2014" };
//args = new string[] { "übersicht", "01", "2015" };
#endif
Ui.Start();
new Interaktionen(new TransaktionenRepository("Buchungsdatenbank.data")).Start(
args,
onEinAuszahlung: (tuple) => {
Money kassenbestand = tuple.Item1;
Kategorie aktuelleKategorie = tuple.Item2;
Ui.Zeige_EinAuszahlung(kassenbestand, aktuelleKategorie);
},
onUebersicht: (kategorieUebersicht) => {
Ui.Zeige_Uebersicht(kategorieUebersicht);
}
);
Ui.Ende();
}
public async Task <bool> CreateCategory(Kategorie kategorie)
{
using (var conn = new SqlConnection(_configuration.Value))
{
const string query = @"insert into dbo.Kategorie (KategorieName, Beschreibung) values (@KategorieName, @Beschreibung)";
if (conn.State == ConnectionState.Closed)
{
conn.Open();
}
try
{
await conn.ExecuteAsync(query, new { kategorie.KategorieName, kategorie.Beschreibung }, commandType : CommandType.Text);
}
catch (Exception ex)
{
throw ex;
}
finally
{
if (conn.State == ConnectionState.Open)
{
conn.Close();
}
}
}
return(true);
}
public async Task <bool> EditCategory(int id, Kategorie kategorie)
{
using (var conn = new SqlConnection(_configuration.Value))
{
const string query = @"update dbo.Kategorie set KategorieName = @KategorieName, Beschreibung = @Beschreibung where KategorieId=@Id";
if (conn.State == ConnectionState.Closed)
{
conn.Open();
}
try
{
await conn.ExecuteAsync(query, new { kategorie.KategorieName, kategorie.Beschreibung, id }, commandType : CommandType.Text);
}
catch (Exception ex)
{
throw ex;
}
finally
{
if (conn.State == ConnectionState.Open)
{
conn.Close();
}
}
}
return(true);
}
public async Task <Kategorie> SingleCategory(int id)
{
Kategorie kategorie = new Kategorie();
using (var conn = new SqlConnection(_configuration.Value))
{
const string query = @"select * from dbo.Kategorie where KategorieId=@Id";
if (conn.State == ConnectionState.Closed)
{
conn.Open();
}
try
{
kategorie = await conn.QueryFirstOrDefaultAsync <Kategorie>(query, new { id }, commandType : CommandType.Text);
}
catch (Exception ex)
{
throw ex;
}
finally
{
if (conn.State == ConnectionState.Open)
{
conn.Close();
}
}
}
return(kategorie);
}
/// <summary>
/// Nastavení zadávacích polí do výchozího nastavení.
/// </summary>
private void ResetujZadavaciPole()
{
// Vymazání názvu
Nazev = "";
NazevTextBox.Text = Nazev;
// Vymazání pole pro hodnotu
Hodnota_MIN = 0;
Hodnota_MAX = 9999999999;
HodnotaMINTextBox.Text = "";
HodnotaMAXTextBox.Text = "";
// Vymazání pole pro počet položek
PocetPolozek_MIN = 0;
PocetPolozek_MAX = 10000;
PolozkyMINTextBox.Text = "";
PolozkyMAXTextBox.Text = "";
// Nastavení data
Datum_MIN = PrvniDenAktualnihoMesice;
Datum_MAX = DateTime.Now.Date;
DatumMIN_DatePicker.SelectedDate = Datum_MIN;
DatumMAX_DatePicker.SelectedDate = Datum_MAX;
// Vyplnění rozbalovací nabídky jednotlivými prvky
Controller.NastavKategorieDoComboBoxu(KategorieComboBox);
// Nastavení defaultní hodnoty kategorie
kategorie = Kategorie.Nevybrano;
}
public JsonResult Create()
{
try
{
if (Request["id"] != null)
{
System.Diagnostics.Debug.WriteLine(Request["id"]);
var id = int.Parse(Request["id"]);
if (Request["name"] != null)
{
System.Diagnostics.Debug.WriteLine(Request["name"]);
var tmp = new Kategorie();
tmp.id_kategorii = -1;
tmp.nazwa = Request["name"];
if (id != -1)
{
tmp.dziedzina = id;
}
db.Kategorie.Add(tmp);
db.SaveChanges();
var iid = tmp.id_kategorii;
return(Json(new { result = true, id = iid }, JsonRequestBehavior.AllowGet));
}
}
}
catch (Exception er) { System.Diagnostics.Debug.WriteLine(er.Message); }
return(Json(new { result = false }, JsonRequestBehavior.AllowGet));
}
public ActionResult AddKategorie(Kategorie _kategorie)
{
try
{
if (ModelState.IsValid)
{
_db.Kategorie.Add(_kategorie);
_db.SaveChanges();
return(RedirectToAction("Create"));
}
}
catch (DbEntityValidationException dbEx)
{
foreach (var validationErrors in dbEx.EntityValidationErrors)
{
foreach (var validationError in validationErrors.ValidationErrors)
{
Trace.TraceInformation("Property: {0} Error: {1}",
validationError.PropertyName,
validationError.ErrorMessage);
}
}
}
return(HttpNotFound());
}
public async Task <ActionResult> Detale(int?id)
{
if (id == null)
{
return(NotFound());
}
var ksiazka = await _context.Ksiazki.FirstOrDefaultAsync(m => m.id_ksiazki == id);
ksiazka.Wydawnictwa = await _context.Wydawnictwa.FirstOrDefaultAsync(m => m.id_wydawnictwa == ksiazka.id_wydawnictwa);
if (ksiazka == null)
{
return(NotFound());
}
KsiazkaViewModel ksiazkaVM = new KsiazkaViewModel();
ksiazkaVM.id_ksiazki = ksiazka.id_ksiazki;
ksiazkaVM.id_wydawnictwo = ksiazka.id_wydawnictwa;
ksiazkaVM.tytuł = ksiazka.tytuł;
ksiazkaVM.data_wydania = ksiazka.data_wydania;
ksiazkaVM.Wydawnictwa = await _context.Wydawnictwa.FirstOrDefaultAsync(m => m.id_wydawnictwa == ksiazka.id_wydawnictwa);
//kategorie
var kategorie_ksiazki = await _context.Kategorie_Ksiazki.Where(m => m.id_ksiazki == ksiazka.id_ksiazki).ToListAsync();
Kategorie kategoria = new Kategorie();
List <string> listaKategorii = new List <string>();
foreach (Kategorie_Ksiazki k in kategorie_ksiazki)
{
kategoria = await _context.Kategorie.FirstOrDefaultAsync(m => m.id_kategorii == k.id_kategorii);
listaKategorii.Add(kategoria.nazwa);
}
ksiazkaVM.kategorieLista = listaKategorii;
//autorzy
var autorzy_ksiazki = await _context.Autorzy_Ksiazki.Where(m => m.id_ksiazki == ksiazka.id_ksiazki).ToListAsync();
Autor autor = new Autor();
List <string> listaAutorow = new List <string>();
string autorRecord;
foreach (Autorzy_Ksiazki a in autorzy_ksiazki)
{
autor = await _context.Autor.FirstOrDefaultAsync(m => m.id_autor == a.id_autora);
autorRecord = autor.imie + " " + autor.nazwisko;
listaAutorow.Add(autorRecord);
}
ksiazkaVM.autorzyLista = listaAutorow;
return(View(ksiazkaVM));
// return View();
}
public ActionResult DeleteConfirmed(int id)
{
Kategorie kategorie = db.Kategorie.Find(id);
db.Kategorie.Remove(kategorie);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public ActionResult DeleteKategorieConfirmed(Kategorie _name, string roh)
{
var p = from a in _db.Kategorie where a.Id == _name.Id select a;
Kategorie viewKat = p.FirstOrDefault();
_db.Kategorie.Remove(viewKat);
_db.SaveChanges();
return(RedirectToAction(roh));
}
public Kategorie UpdateKategorie(Kategorie kategorie)
{
var kategorieToUpdate = _db.Kategorien.Find(kategorie.KategorieID);
kategorieToUpdate.Name = kategorie.Name;
_db.SaveChanges();
return(kategorieToUpdate);
}
public string AsCsv()
{
StringBuilder sb = new StringBuilder();
sb.Append(WrapText(Kategorie.ToString()));
sb.Append(";");
sb.Append(Buchungsdatum.ToString(CultureInfo.CurrentCulture));
sb.Append(";");
sb.Append(Valutadatum.ToString(CultureInfo.CurrentCulture));
sb.Append(";");
sb.Append(WrapText(Buchungstext));
sb.Append(";");
sb.Append(WrapText(InterneNotiz));
sb.Append(";");
sb.Append(Betrag.ToString(CultureInfo.CurrentCulture));
sb.Append(";");
sb.Append(WrapText(Belegdaten));
sb.Append(";");
string normBelegDaten = Belegdaten.Trim();
normBelegDaten = normBelegDaten.Trim().Trim(new char[] { '"' }).Trim();
string beleg = string.IsNullOrEmpty(normBelegDaten) ? "" : "B" + Beleg;
sb.Append(WrapText(beleg));
sb.Append(";");
sb.Append(WrapText(Auftraggebername));
sb.Append(";");
sb.Append(WrapText(Auftraggeberkonto));
sb.Append(";");
sb.Append(WrapText(AuftraggeberBLZ));
sb.Append(";");
sb.Append(WrapText(Empfaengername));
sb.Append(";");
sb.Append(WrapText(Empfaengerkonto));
sb.Append(";");
sb.Append(WrapText(EmpfaengerBLZ));
sb.Append(";");
sb.Append(WrapText(Zahlungsgrund));
return(sb.ToString());
}
public IActionResult Post([FromBody] Kategorie kategorie)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var result = _repository.CreateKategorie(kategorie);
return(CreatedAtAction("GetKategorien", new { id = kategorie.KategorieID }, result));
}
public ActionResult Edit([Bind(Include = "KategorieId,Nazwa,PrzyjaznaNazwa,Opis,DataUtworzenia,CzyOpublikowany")] Kategorie kategorie)
{
if (ModelState.IsValid)
{
db.Entry(kategorie).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(kategorie));
}
public ActionResult Details(int?Id)
{
main proid = _db.main.Find(Id);
Kategorie viewKat = _db.Kategorie.Find(proid.Kategorie_Id);
ViewModelAufgabe _view = new ViewModelAufgabe();
_view._main = proid;
_view._kategorie = viewKat;
return(View(_view));
}
public ActionResult Edit([Bind(Include = "Id,Kategoria")] Kategorie kategorie)
{
if (ModelState.IsValid)
{
db.Entry(kategorie).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(kategorie));
}
public static void Zeige_EinAuszahlung(Money kassenbestand, Kategorie kategorie)
{
Leerzeile();
Meldung($"Kassenbestand: {kassenbestand.Amount} {kassenbestand.Currency.Code}");
if (kategorie != null && !string.IsNullOrEmpty(kategorie.Bezeichnung))
{
Meldung($"{kategorie.Bezeichnung}: {kategorie.Summe.Amount} {kategorie.Summe.Currency.Code}");
}
}
// GET: Produkt
public ActionResult Index(int?kategorie, int?vegan, int?vegetarisch, int?limit)
{
List <Produkt> produkte = Produkt.getProdukteListe(kategorie, vegan, vegetarisch, limit);
ViewBag.Kategorie = Kategorie.kategorieName(kategorie);
ViewBag.KategorieListe = Kategorie.kategorieListe();
return(View(produkte));
}
public ActionResult Create(FormCollection collection)
{
try
{
var a = new Kategorie();
UpdateModel(a);
data.Kategorie.Add(a);
data.SaveChanges();
return RedirectToAction("Index");
}
catch
{
return View();
}
}
public override void Read(ManifestData reader, int ID)
{
base.Read(reader, ID);
this.Art = (Kategorie)Enum.Parse(typeof(Kategorie), reader.FlatName, true);
}
