private void StopProcess()
{
BrewingData.IsRunning = false;
arduinoConnection.TurnHeaterOff();
arduinoConnection.TurnPumpOff();
bool isCompeted = true;
foreach (var phase in BrewingPhases)
{
if (phase.IsCompleted == false)
{
isCompeted = false;
break;
}
}
BrewProcess brewProcess = new BrewProcess
{
IsCompleted = isCompeted,
Recipe = Recipe,
RecipeID = Recipe.ID,
Time = DateTime.Now
};
using BreweryContext db = new BreweryContext();
db.BrewProcesses.Add(brewProcess);
db.SaveChanges();
}
private void SaveExecute(object obj)
{
using (var db = new BreweryContext())
{
if (Evaluation.ID == 0)
{
Recipe recipe = db.Recipes.FirstOrDefault(r => r.ID == recipeId);
Evaluation.Recipe = recipe;
Evaluation.RecipeID = recipe.ID;
db.Evaluations.Add(Evaluation);
db.SaveChanges();
}
else
{
foreach (var criteria in Evaluation.Criterias)
{
db.Entry(criteria).State = EntityState.Modified;
db.SaveChanges();
}
db.Entry(Evaluation).State = EntityState.Modified;
db.SaveChanges();
}
}
}
private void InitModel()
{
List <Recipe> recipes = new List <Recipe>();
List <Evaluation> evaluations = new List <Evaluation>();
using (var db = new BreweryContext())
{
recipes = db.Recipes.ToList();
evaluations = db.Evaluations.ToList();
}
RecipesOverviewModels = new ObservableCollection <OverviewModel>();
foreach (var recipe in recipes)
{
Evaluation evaluation = evaluations.FirstOrDefault(e => e.RecipeID == recipe.ID);
int ranking = -1;
if (evaluation != null)
{
ranking = evaluation.GetAverage();
}
RecipesOverviewModels.Add(new OverviewModel {
RecipeName = recipe.Name, RecipeID = recipe.ID, Ranking = ranking
});
}
RecipesOverviewModels = new ObservableCollection <OverviewModel>(RecipesOverviewModels.OrderByDescending(n => n.Ranking));
}
public BeerRepository(
BreweryContext breweryContext,
IMapper mapper)
{
this._breweryContext = breweryContext;
this._mapper = mapper;
}
public BeersController(IBreweryRepository breweryRepository,
IBeerRepository beerRepository,
BreweryContext breweryContext) : base(breweryContext)
{
this.breweryRepository = breweryRepository;
this.beerRepository = beerRepository;
}
private void SaveExecute(object obj)
{
using (BreweryContext db = new BreweryContext())
{
db.PumpIntervals.Add(PumpInterval);
db.SaveChanges();
}
CloseAction();
}
public ProvidersController(IProviderRepository providerRepository,
IBeerRepository beerRepository,
IBeerProviderRepository beerProviderRepository,
BreweryContext breweryContext) : base(breweryContext)
{
this.providerRepository = providerRepository;
this.beerRepository = beerRepository;
this.beerProviderRepository = beerProviderRepository;
}
public SettingsViewModel()
{
SaveCommand = new RelayCommand(SaveExecute);
DeleteCommand = new RelayCommand(DeleteExecute);
using var db = new BreweryContext();
FoundationIngrediets = new ObservableCollection <FoundationIngrediet>(db.FoundationIngrediets.ToList());
FoundationCriterias = new ObservableCollection <FoundationCriteria>(db.FoundationCriterias.ToList());
PumpIntervals = new ObservableCollection <PumpInterval>(db.PumpIntervals.ToList());
EmailAddresses = new ObservableCollection <EMailAddress>(db.EMailAddresses.ToList());
}
public AddRecipeViewModel(int recipeID)
{
#region Init Commands
#region Init Phase - Commands
AddPhaseCommand = new RelayCommand(AddPhaseExecute);
DuplicatePhaseCommand = new RelayCommand(DuplicatePhaseExecute);
DeletePhaseCommand = new RelayCommand(DeletePhaseExecute);
PositionUpPhaseCommand = new RelayCommand(PositionUpPhaseExecute, PositionUpPhaseCanExecute);
PositionDownPhaseCommand = new RelayCommand(PositionDownPhaseExecute, PositionDownPhaseCanExecute);
AddPumpIntervalCommand = new RelayCommand(AddPumpIntervalExecute);
#endregion
#region Init Ingredient - Commands
AddIngredientCommand = new RelayCommand(AddIngredientExecute);
DuplicateIngredientCommand = new RelayCommand(DuplicateIngredientExecute);
DeleteIngredientCommand = new RelayCommand(DeleteIngredientExecute);
#endregion
SaveRecipeCommand = new RelayCommand(SaveRecipeExecute, SaveRecipeCanExecute);
#endregion
using var db = new BreweryContext();
PumpIntervals = new ObservableCollection <PumpInterval>(db.PumpIntervals.ToList());
var recipe = db.Recipes.FirstOrDefault(r => r.ID == recipeID);
if (recipe != null)
{
RecipeName = recipe.Name;
RecipeDescription = recipe.Description;
recipeId = recipe.ID;
List <Phase> phases = new List <Phase>();
foreach (var phase in db.Phases)
{
if (phase.RecipeID == recipeID)
{
phases.Add(phase);
}
}
List <Ingredient> ingredients = new List <Ingredient>();
foreach (var ingredient in db.Ingredients)
{
if (ingredient.RecipeID == recipeID)
{
ingredients.Add(ingredient);
}
}
RecipeIngredients = new ObservableCollection <Ingredient>(ingredients);
RecipePhases = new ObservableCollection <Phase>(phases.OrderBy(p => p.Position));
}
}
private void BrewExecute(object obj)
{
if (obj is OverviewModel overview)
{
using var db = new BreweryContext();
var recipe = db.Recipes.FirstOrDefault(r => r.ID == overview.RecipeID);
if (recipe != null)
{
mainWindow.LoadBrewingControl(recipe);
}
}
}
private void DublicateExecute(object obj)
{
if (obj is OverviewModel overview)
{
using var db = new BreweryContext();
var dbRecipe = db.Recipes.FirstOrDefault(r => r.ID == overview.RecipeID);
if (dbRecipe != null)
{
List <Ingredient> ingredients = new List <Ingredient>();
var inList = db.Ingredients.Where(i => i.RecipeID == dbRecipe.ID);
foreach (var ingr in inList)
{
ingredients.Add(new Ingredient
{
Name = ingr.Name,
Amount = ingr.Amount,
Typ = ingr.Typ
});
}
List <Phase> phases = new List <Phase>();
var phList = db.Phases.Where(p => p.RecipeID == dbRecipe.ID);
foreach (var phase in phList)
{
phases.Add(new Phase
{
Name = phase.Name,
Typ = phase.Typ,
PeriodOfMinutes = phase.PeriodOfMinutes,
Position = phase.Position,
PumpInterval = phase.PumpInterval,
PumpIntervalID = phase.PumpIntervalID,
TargetTemperature = phase.TargetTemperature
});
}
Recipe recipe = new Recipe
{
Name = dbRecipe.Name,
Description = dbRecipe.Description,
IsFavorite = dbRecipe.IsFavorite,
Ingredients = ingredients,
Phases = phases
};
db.Recipes.Add(recipe);
db.SaveChanges();
InitModel();
}
}
}
private void DeleteExecute(object obj)
{
if (obj is OverviewModel overview)
{
using var db = new BreweryContext();
var recipe = db.Recipes.FirstOrDefault(r => r.ID == overview.RecipeID);
if (recipe != null)
{
db.Entry(recipe).State = Microsoft.EntityFrameworkCore.EntityState.Deleted;
db.Recipes.Remove(recipe);
db.SaveChanges();
InitModel();
}
}
}
private void DeleteExecute(object obj)
{
if (obj is PumpInterval pumpInterval)
{
using var db = new BreweryContext();
var item = db.PumpIntervals.FirstOrDefault(p => p.ID == pumpInterval.ID);
if (item != null)
{
db.PumpIntervals.Remove(item);
db.SaveChanges();
PumpIntervals.Remove(pumpInterval);
}
}
else if (obj is EMailAddress eMailAddress)
{
using var db = new BreweryContext();
var item = db.EMailAddresses.FirstOrDefault(p => p.ID == eMailAddress.ID);
if (item != null)
{
db.EMailAddresses.Remove(item);
db.SaveChanges();
EmailAddresses.Remove(eMailAddress);
}
}
else if (obj is FoundationCriteria foundationCriteria)
{
using var db = new BreweryContext();
var item = db.FoundationCriterias.FirstOrDefault(p => p.ID == foundationCriteria.ID);
if (item != null)
{
db.FoundationCriterias.Remove(item);
db.SaveChanges();
FoundationCriterias.Remove(foundationCriteria);
}
}
else if (obj is FoundationIngrediet foundationIngrediets)
{
using var db = new BreweryContext();
var item = db.FoundationIngrediets.FirstOrDefault(p => p.ID == foundationIngrediets.ID);
if (item != null)
{
db.FoundationIngrediets.Remove(item);
db.SaveChanges();
FoundationIngrediets.Remove(foundationIngrediets);
}
}
}
public EvaluationViewModel(int recipeID)
{
SaveCommand = new RelayCommand(SaveExecute);
AbortCommand = new RelayCommand(AbortExecute);
recipeId = recipeID;
List <FoundationCriteria> foundationCriterias = new List <FoundationCriteria>();
List <Criteria> criterias = new List <Criteria>();
Recipe recipe = null;
Evaluation evaluation = null;
using (var db = new BreweryContext())
{
foundationCriterias = db.FoundationCriterias.ToList();
recipe = db.Recipes.FirstOrDefault(r => r.ID == recipeId);
evaluation = db.Evaluations.FirstOrDefault(e => e.RecipeID == recipeId);
}
foreach (var criteria in foundationCriterias)
{
criterias.Add(new Criteria
{
Description = criteria.Description
});
}
if (evaluation == null)
{
Evaluation = new Evaluation
{
Criterias = criterias,
Recipe = recipe
};
}
else
{
Evaluation = evaluation;
using (var db = new BreweryContext())
{
criterias = db.Criterias.Where(c => c.EvaluationID == Evaluation.ID).ToList();
Evaluation.Criterias = criterias;
}
}
}
public AddRecipeViewModel()
{
#region Init Commands
#region Init Phase - Commands
AddPhaseCommand = new RelayCommand(AddPhaseExecute);
DuplicatePhaseCommand = new RelayCommand(DuplicatePhaseExecute);
DeletePhaseCommand = new RelayCommand(DeletePhaseExecute);
PositionUpPhaseCommand = new RelayCommand(PositionUpPhaseExecute, PositionUpPhaseCanExecute);
PositionDownPhaseCommand = new RelayCommand(PositionDownPhaseExecute, PositionDownPhaseCanExecute);
AddPumpIntervalCommand = new RelayCommand(AddPumpIntervalExecute);
#endregion
#region Init Ingredient - Commands
AddIngredientCommand = new RelayCommand(AddIngredientExecute);
DuplicateIngredientCommand = new RelayCommand(DuplicateIngredientExecute);
DeleteIngredientCommand = new RelayCommand(DeleteIngredientExecute);
#endregion
SaveRecipeCommand = new RelayCommand(SaveRecipeExecute, SaveRecipeCanExecute);
#endregion
using var db = new BreweryContext();
PumpIntervals = new ObservableCollection <PumpInterval>(db.PumpIntervals.ToList());
foreach (var ingredient in db.FoundationIngrediets.ToList())
{
RecipeIngredients.Add(new Ingredient {
Name = ingredient.Name, Amount = ingredient.Amount, Typ = ingredient.Typ
});
}
RecipePhases.Add(new Phase {
Position = 0, Name = "Aufwärmen", PeriodOfMinutes = 60, TargetTemperature = 50, Typ = PhaseTyp.HeatUp, PumpInterval = PumpIntervals[0]
});
RecipePhases.Add(new Phase {
Position = 1, Name = "Halten", PeriodOfMinutes = 60, TargetTemperature = 50, Typ = PhaseTyp.KeepHeat, PumpInterval = PumpIntervals[2]
});
RecipePhases.Add(new Phase {
Position = 2, Name = "Aufwärmen 2", PeriodOfMinutes = 60, TargetTemperature = 70, Typ = PhaseTyp.HeatUp, PumpInterval = PumpIntervals[2]
});
RecipePhases.Add(new Phase {
Position = 3, Name = "Rast 2", PeriodOfMinutes = 60, TargetTemperature = 70, Typ = PhaseTyp.KeepHeat, PumpInterval = PumpIntervals[2]
});
}
public MainWindow()
{
InitializeComponent();
try
{
using (var db = new BreweryContext())
{
if (db.Database.EnsureCreated())
{
InitBreweryDatabase.Init();
}
}
}
catch (Exception ex)
{
MessageBox.Show("Fehler beim Laden der Datenbank. " + ex.Message);
}
ContentArea.Content = new DashboardControl();
addRecipeControl = new AddRecipeControl(this);
}
/// <summary>
/// Gibt den Durchschnittswert aller Kriterien zurück
/// </summary>
/// <returns></returns>
public int GetAverage()
{
int output = 0;
int sum = 0;
using (var db = new BreweryContext())
{
Criterias = db.Criterias.Where(c => c.EvaluationID == ID).ToList();
}
if (Criterias.Count > 0)
{
foreach (var criteria in Criterias)
{
sum += criteria.Ranking;
}
output = sum / Criterias.Count;
}
return(output);
}
private void AddPumpIntervalExecute(object obj)
{
AddPumpInteralView addPumpInteral = new AddPumpInteralView();
addPumpInteral.ShowDialog();
RecipePhases[0].Name = "Affe";
OnPropertyChanged(nameof(RecipePhases));
using var db = new BreweryContext();
ObservableCollection <PumpInterval> pump = new ObservableCollection <PumpInterval>(db.PumpIntervals.ToList());
if (PumpIntervals.Count != pump.Count)
{
var last = pump.Last();
PumpIntervals.Add(last);
if (obj is Phase phase)
{
phase.PumpInterval = last;
}
}
}
public BeerProviderRepository(BreweryContext breweryContext)
{
this.breweryContext = breweryContext;
}
private void SaveRecipeExecute(object obj)
{
using var db = new BreweryContext();
//Rezept neu
if (recipeId == 0)
{
foreach (var phase in RecipePhases)
{
var pumpIntervall = db.PumpIntervals.FirstOrDefault(p => p.ID == phase.PumpInterval.ID);
if (pumpIntervall != null)
{
phase.PumpInterval = pumpIntervall;
phase.PumpIntervalID = pumpIntervall.ID;
}
}
Recipe recipe = new Recipe()
{
Description = RecipeDescription,
Name = RecipeName,
Ingredients = new List <Ingredient>(RecipeIngredients),
Phases = new List <Phase>(RecipePhases),
IsFavorite = false
};
db.Recipes.Add(recipe);
db.SaveChanges();
}
else
{
//Rezept schon vorhanden
var recipe = db.Recipes.FirstOrDefault(r => r.ID == recipeId);
if (recipe != null)
{
foreach (var phase in RecipePhases)
{
var pumpIntervall = db.PumpIntervals.FirstOrDefault(p => p.ID == phase.PumpInterval.ID);
if (pumpIntervall != null)
{
phase.PumpInterval = pumpIntervall;
phase.PumpIntervalID = pumpIntervall.ID;
}
}
recipe.Description = RecipeDescription;
recipe.Name = RecipeName;
recipe.Ingredients = new List <Ingredient>(RecipeIngredients);
recipe.Phases = new List <Phase>(RecipePhases);
recipe.IsFavorite = false;
db.Entry(recipe).State = EntityState.Modified;
db.SaveChanges();
//Löschen der nicht mehr genutzten Ingredients in der DB
var dbRecipeIngredients = db.Ingredients.Where(i => i.RecipeID == recipe.ID);
foreach (var dbRecipeIngredient in dbRecipeIngredients)
{
var item = RecipeIngredients.FirstOrDefault(i => i.ID == dbRecipeIngredient.ID);
if (item == null)
{
db.Ingredients.Remove(dbRecipeIngredient);
db.SaveChanges();
}
}
//Löschen der nicht mehr genutzten Phases in der DB
var dbRecipePhases = db.Phases.Where(i => i.RecipeID == recipe.ID);
foreach (var dbRecipePhase in dbRecipePhases)
{
var item = RecipePhases.FirstOrDefault(i => i.ID == dbRecipePhase.ID);
if (item == null)
{
db.Phases.Remove(dbRecipePhase);
db.SaveChanges();
}
}
}
}
}
public BreweryRepository(BreweryContext breweryContext)
{
this.breweryContext = breweryContext;
}
public BreweriesController(BreweryContext breweryContext,
IBreweryRepository breweryRepository) : base(breweryContext)
{
this.breweryRepository = breweryRepository;
}
private void SaveExecute(object obj)
{
using var db = new BreweryContext();
// Save FoundationIngrediets
foreach (var foundationIngrediet in FoundationIngrediets)
{
if (foundationIngrediet.ID == 0)
{
db.FoundationIngrediets.Add(foundationIngrediet);
db.SaveChanges();
}
else
{
var dbPfoundation = db.FoundationIngrediets.FirstOrDefault(e => e.ID == foundationIngrediet.ID);
if (dbPfoundation != null)
{
dbPfoundation.Amount = foundationIngrediet.Amount;
dbPfoundation.Name = foundationIngrediet.Name;
dbPfoundation.Typ = foundationIngrediet.Typ;
db.SaveChanges();
}
}
}
// Save FoundationCriterias
foreach (var foundationCriteria in FoundationCriterias)
{
if (foundationCriteria.ID == 0)
{
db.FoundationCriterias.Add(foundationCriteria);
db.SaveChanges();
}
else
{
var dbPfoundation = db.FoundationCriterias.FirstOrDefault(e => e.ID == foundationCriteria.ID);
if (dbPfoundation?.Description != foundationCriteria.Description)
{
dbPfoundation.Description = foundationCriteria.Description;
db.SaveChanges();
}
}
}
// Save PumpIntervals
foreach (var interval in PumpIntervals)
{
if (interval.ID == 0)
{
db.PumpIntervals.Add(interval);
db.SaveChanges();
}
else
{
var dbPumpInterval = db.PumpIntervals.FirstOrDefault(e => e.ID == interval.ID);
if (dbPumpInterval != null)
{
dbPumpInterval.Name = interval.Name;
dbPumpInterval.RestTimeInSeconds = interval.RestTimeInSeconds;
dbPumpInterval.RunningTimeInSeconds = interval.RunningTimeInSeconds;
db.SaveChanges();
}
}
}
// Save EmailAddresses
foreach (var address in EmailAddresses)
{
if (address.ID == 0)
{
db.EMailAddresses.Add(address);
db.SaveChanges();
}
else
{
var dbEmail = db.EMailAddresses.FirstOrDefault(e => e.ID == address.ID);
if (dbEmail?.Address != address.Address)
{
dbEmail.Address = address.Address;
db.SaveChanges();
}
}
}
}
public Repository()
{
this.context = new BreweryContext();
}
public CoreController(BreweryContext breweryContext)
{
this.breweryContext = breweryContext;
}
public WholesalerService(BreweryContext context)
{
_context = context ?? throw new ArgumentNullException(nameof(context));
}
public BreweryDataAccess(BreweryContext context)
{
_context = context;
}
public void SetUp()
{
dbContext = new BreweryContext();
}
