/// <summary>
/// Füge einen Passagier zu einem Flug hinzu
/// </summary>
public Lagerbestand NuerLagerplatz(int MaschinenartID)
{
try
{
Lagerbestand DiesesLager = new Lagerbestand();
DiesesLager.Maschinenart_ID = MaschinenartID;
modell.LagerbestandSatz.AddObject(DiesesLager);
try
{
modell.SaveChanges();
}
catch (Exception ex)
{
Console.WriteLine(DiesesLager.ToString() + " | " + ex.Message.ToString());
}
return(DiesesLager);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message.ToString());
return(null);
}
}
async void hinzufuegen(Object sender, EventArgs e)
{
Lagerbestand lager = new Lagerbestand();
lager.lag_preis = e_lager_preis.Text;
lager.lag_akt_menge = e_lager_akt.Text;
lager.lag_res_menge = e_lager_res.Text;
lager.produkt_pro_id = (from p in produkts
where p.pro_bezeichnung == proBez
select p.pro_id).SingleOrDefault();
lager.regal_reg_id = (from r in regals
where r.reg_bezeichnung == regBez
select r.reg_id).SingleOrDefault();
if (lager.produkt_pro_id != null && lager.regal_reg_id != null)
{
await App.produktManager.SaveTaskAsync(lager, isNewLagerbestand);
await DisplayAlert("Erfolgreich", "Lagerbestand wurde geaddet.", "Okay");
await Navigation.PushModalAsync(new HomeScreen());
}
else
{
await DisplayAlert("Fehler!", "Lagerbestand konnte nicht geaddet werden.", "Okay");
}
}
private void Add()
{
Lagerbestand newLagerbestand = new Lagerbestand();
Lager.Add(newLagerbestand);
walkthrowGridUpdaterMethod();
}
async void hinzufuegen(Object sender, EventArgs e)
{
Lagerbestand lager = new Lagerbestand();
Verkauf verkauf = new Verkauf();
int akt, res, ver, checkMenge;
verkauf.ver_menge = e_ver_menge.Text;
verkauf.ver_datum = d_ver_datum.Date;
verkauf.ver_betrag = e_ver_betrag.Text;
verkauf.produkt_pro_id = (from p in produkts
where p.pro_bezeichnung == proBez
select p.pro_id).SingleOrDefault();
lager = (from lag in lagers
where lag.produkt_pro_id == verkauf.produkt_pro_id
select lag).FirstOrDefault <Lagerbestand>();
if (lager != null)
{
akt = 0;
int.TryParse(lager.lag_akt_menge, out akt);
res = 0;
int.TryParse(lager.lag_res_menge, out res);
ver = 0;
int.TryParse(verkauf.ver_menge, out ver);
checkMenge = (akt - res) - ver;
if (checkMenge >= 0)
{
if (verkauf != null && verkauf.ver_menge != "0" && verkauf.ver_datum != null)
{
await App.produktManager.SaveTaskAsync(verkauf, isnewVerkauf);
await DisplayAlert("Erfolgreich", "Verkauf wurde geaddet.", "Okay");
lager.lag_akt_menge = (akt - ver).ToString();
await App.produktManager.SaveTaskAsync(lager, false);
await Navigation.PushModalAsync(new Lagerverwalten());
}
else
{
await DisplayAlert("Fehler!", "Verkauf konnte nicht geaddet werden.", "Okay");
}
}
else
{
await DisplayAlert("Fehler!", "Es sind nicht genügend Stück dieses Produkts im Lager vorhanden!.", "Okay");
}
}
else
{
await DisplayAlert("Fehler!", "Es sind nicht genügend Stück dieses Produkts im Lager vorhanden!.", "Okay");
}
}
public LagerbestandAendern(Lagerbestand lagerbestand)
{
InitializeComponent();
this.lagerbestand = lagerbestand;
isNewProdukt = false;
e_preis.Text = lagerbestand.lag_preis;
e_akt.Text = lagerbestand.lag_akt_menge;
e_res.Text = lagerbestand.lag_res_menge;
}
/// <summary>
/// Änderungen an einer Liste von Passagieren speichern
/// Die neu hinzugefügten Passagiere muss die Routine wieder zurückgeben, da die IDs für die
/// neuen Passagiere erst beim Speichern von der Datenbank vergeben werden
/// </summary>
public List <Lagerbestand> SaveLagerSet(List <Lagerbestand> LagerSet, out string Statistik)
{
//https://blogs.msdn.microsoft.com/diego/2010/10/05/self-tracking-entities-applychanges-and-duplicate-entities/
// Änderungen für jeden einzelnen Passagier übernehmen
try
{
foreach (Lagerbestand p in LagerSet)
{
if (p.ChangeTracker.State == ObjectState.Modified)
{
var abfrage = from Lager in modell.LagerbestandSatz.Include("Maschinenart") select Lager;
Lagerbestand current = abfrage.Where(o => o.Lagerbestand_ID == p.Lagerbestand_ID).First();
Lagerbestand.Clone(p, current);
modell.LagerbestandSatz.ApplyChanges(current);
current.ChangeTracker.State = ObjectState.Unchanged;
}
else if (p.ChangeTracker.State == ObjectState.Deleted)
{
var abfrage = from Lager in modell.LagerbestandSatz.Include("Maschinenart") select Lager;
Lagerbestand current = abfrage.Where(o => o.Lagerbestand_ID == p.Lagerbestand_ID).First();
current.MarkAsDeleted();
modell.LagerbestandSatz.DeleteObject(current);
}
else if (p.ChangeTracker.State == ObjectState.Added)
{
modell.LagerbestandSatz.ApplyChanges(p);
}
}
}
catch
{
Console.Write("Context is up to date");
}
// Statistik der Änderungen zusammenstellen
Statistik = "";
Statistik += "Geändert: " + modell.ObjectStateManager.GetObjectStateEntries(System.Data.EntityState.Modified).Count();
Statistik += " Neu: " + modell.ObjectStateManager.GetObjectStateEntries(System.Data.EntityState.Added).Count();
Statistik += " Gelöscht: " + modell.ObjectStateManager.GetObjectStateEntries(System.Data.EntityState.Deleted).Count();
// Neue Datensätze merken, da diese nach Speichern zurückgegeben werden müssen (haben dann erst ihre IDs!)
List <Lagerbestand> NeueLager = LagerSet.Where(f => f.ChangeTracker.State == ObjectState.Added).ToList();
// Änderungen speichern
modell.SaveChanges();
modell.Refresh(System.Data.Objects.RefreshMode.StoreWins, modell.LagerbestandSatz);
// Statistik der Änderungen zurückgeben
return(NeueLager);
}
async void Update_Clicked(object sender, EventArgs e)
{
Lagerbestand lag = (Lagerbestand)lagerlist.SelectedItem;
if (lag != null)
{
await Navigation.PushModalAsync(new LagerbestandAendern(lag));
}
else
{
await DisplayAlert("Fehler!", "Kein Lagerbestand ausgewählt!.", "Okay");
}
}
/// <summary>
/// Füge einen Passagier zu einem Flug hinzu
/// </summary>
public Lagerbestand AddGekaufteMaschineZuLager(int MaschinenartID, int Anzahl)
{
try
{
Lagerbestand lager = modell.LagerbestandSatz.Where(f => f.Maschinenart_ID == MaschinenartID).SingleOrDefault();
lager.Gesamtanzahl += Anzahl;
lager.Lagermenge += Anzahl;
modell.SaveChanges();
return(lager);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message.ToString());
return(null);
}
}
/// ########################### Konstruktor ###########################################
public LagerdatenViewModel(Lagerbestand lager = null)
{
/// ########################### Befehle Verknüpfen ###########################################
Lagertabeldoubleclick = new ActionCommand(LagertabeldoubleclickMethod);
Lagertabelclick = new ActionCommand(LagertabelclickMethod);
PressEnterKey = new ActionCommand(PressEnterKeyMethod);
AddCommand = new ActionCommand(Add);
SaveCommand = new ActionCommand(Save);
DeleteCommand = new ActionCommand(Delete);
DataService client = new DataService();
Lager = client.GetAllLagerbestandlisten();
client.Close();
}
async void delete_Clicked(object sender, EventArgs e)
{
Lagerbestand lag = (Lagerbestand)lagerlist.SelectedItem;
if (lag != null)
{
Lagerbestand lager = (from l in lagers
where l.lag_id == lag.lag_id
select l).FirstOrDefault <Lagerbestand>();
await App.produktManager.DeleteTaskAsync(lager);
await Navigation.PushModalAsync(new LagerbestandEdit());
}
else
{
await DisplayAlert("Fehler!", "Kein Lagerbestand ausgewählt!.", "Okay");
}
}
/// <summary>
/// Füge einen Passagier zu einem Flug hinzu
/// </summary>
public Maschinenart AddGekaufteMaschineZuMaschinenart(int MaschinenartID, int rechnungspreis)
{
try
{
Maschinenart art = modell.MaschinenartenlisteSatz.Where(f => f.Maschinenart_ID == MaschinenartID).SingleOrDefault();
Lagerbestand lager = modell.LagerbestandSatz.Where(f => f.Maschinenart_ID == MaschinenartID).SingleOrDefault();;
art.Gesamtkosten += rechnungspreis;
art.Tagessatz = art.Gesamtkosten / lager.Gesamtanzahl * 0.1;
art.Rentabilität = ((art.Gesamteinnahmen / art.Gesamtkosten) - 1) * 100;
modell.SaveChanges();
return(art);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message.ToString());
return(null);
}
}
public Task DeleteTaskAsync(Object ob)
{
if (ob is Produkt)
{
Produkt pro = new Produkt();
pro = (Produkt)ob;
return(restService.DeleteProduktAsync(pro.pro_id));
}
if (ob is Kategorie)
{
Kategorie kat = new Kategorie();
kat = (Kategorie)ob;
return(restService.DeleteKategorieAsync(kat.kat_id));
}
if (ob is Hersteller)
{
Hersteller her = new Hersteller();
her = (Hersteller)ob;
return(restService.DeleteHerstellerAsync(her.her_id));
}
if (ob is Regal)
{
Regal regal = new Regal();
regal = (Regal)ob;
return(restService.DeleteRegalAsync(regal.reg_id));
}
if (ob is Lagerbestand)
{
Lagerbestand lager = new Lagerbestand();
lager = (Lagerbestand)ob;
return(restService.DeleteLagerbestandAsync(lager.lag_id));
}
if (ob is Verkauf)
{
Verkauf verkauf = new Verkauf();
verkauf = (Verkauf)ob;
return(restService.DeleteVerkaufAsync(verkauf.ver_id));
}
return(null);
//return restService.DeleteProduktAsync(produkt.pro_id);
}
///-------------------------------------------------------------------------------------
///-------------------------------------------------------------------------------------
///-------------------------------------------------------------------------------------
/// <summary>
/// Füge einen Passagier zu einem Flug hinzu
/// </summary>
public Maschinenkauf NeuMaschinenkauf(int MaschinenartID, int anz, int Einzelpreis, DateTime Kaufdatum)
{
try
{
// Transaktion, nur erfolgreich wenn Platzanzahl reduziert und Buchung erstellt!
using (System.Transactions.TransactionScope t = new System.Transactions.TransactionScope())
{
// hier erfolgen Änderungen in Datenbanken über zwei Methoden der Datenzugriffsschicht
Maschinenkauf kauf = Maschinenkauf_Verwaltungsklasse.NeuMaschinenkauf(MaschinenartID, anz, Einzelpreis, Kaufdatum);
if (kauf != null)
{
return(null);
}
// Lagerbestand erhöhen
Lagerbestand lager = Maschinenkauf_Verwaltungsklasse.AddGekaufteMaschineZuLager(MaschinenartID, anz);
if (lager != null)
{
return(null);
}
// Zu Maschinenartenliste hinzufügen
Maschinenart art = Maschinenkauf_Verwaltungsklasse.AddGekaufteMaschineZuMaschinenart(MaschinenartID, anz * Einzelpreis);
if (art != null)
{
return(null);
}
// Transaktion erfolgreich abschließen
t.Complete();
// Buchungscode zurückgeben
return(kauf);
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message.ToString());
return(null);
}
}
public async Task DeleteLagerbestandAsync(string id)
{
var uri = new Uri(string.Format(Constants.LagerbestandDelete, string.Empty));
Lagerbestand lager = new Lagerbestand();
lager.lag_id = id;
try
{
var json = JsonConvert.SerializeObject(lager);
var content = new StringContent(json, Encoding.UTF8, "application/json");
var response = await client.PostAsync(uri, content);
if (response.IsSuccessStatusCode)
{
Debug.WriteLine(@" Lagerbestand successfully deleted.");
}
}
catch (Exception ex)
{
Debug.WriteLine(@" ERROR {0}", ex.Message);
}
}
