public async Task <IHttpActionResult> PostAllergens(AllergensDTO allergensDTO)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var addedRecipies = allergensDTO.Recipes.Select(i => db.Recipes.Find(i)).ToList();
if (addedRecipies.Contains(null))
{
return(NotFound());
}
Allergens allergens = new Allergens()
{
Name = allergensDTO.Name,
Recipes = addedRecipies
};
db.Allergens.Add(allergens);
await db.SaveChangesAsync();
var x = CreatedAtRoute("DefaultApi", new { id = allergens.ID }, allergens);
allergensDTO.ID = allergens.ID;
return(Ok(allergensDTO));
}
private void AddAllergy_Click(object sender, RoutedEventArgs e)
{
if (NewAllergy.Text.Equals(""))
{
ErrorMessage.Visibility = Visibility.Visible;
Error.Text = ERROR_ADD;
return;
}
Allergens allergenToAdd = null;
var recordToUpdate = medicalRecordController.GetMedicalRecord(Informations.currentRecord.MedicalRecord.IdRecord);
foreach (Allergens allergens in allergensController.GetAllAllergies())
{
if (allergens.Allergen.ToLower().Equals(NewAllergy.Text))
{
allergenToAdd = allergens;
}
}
if (allergenToAdd != null)
{
medicalRecordController.UpdateAllergies(allergenToAdd, recordToUpdate);
}
Informations.currentRecord.MedicalRecord = medicalRecordController.GetMedicalRecord(recordToUpdate.IdRecord);
setListBoxes();
}
public Allergens AddAllergen(Allergens allergen)
{
if (allergen.AllergenType == null)
{
throw new ArgumentException("You need to add a name for the allergen");
}
return(_allergensRepo.CreateAllergen(allergen));
}
public static IEnumerable <string> GetAllergyStrings(this Allergens flags)
{
foreach (Allergens allergen in Enum.GetValues(typeof(Allergens)))
{
if (flags.HasFlag(allergen))
{
yield return(AllergyEnumToString[allergen]);
}
}
}
public MedicalRecord UpdateAllergies(Allergens allergy, MedicalRecord medicalRecord)
{
MedicalRecord medicalRecordToUpdate = medicalRecordRepository.GetObject(medicalRecord.IdRecord);
if (!medicalRecordToUpdate.Allergies.Any(entity => entity.Allergen.Equals(allergy.Allergen)))
{
medicalRecordToUpdate.Allergies.Add(allergy);
}
return(medicalRecordRepository.Update(medicalRecordToUpdate));
}
public static bool HasFlagFromString(this Allergens flags, string allergy)
{
if (!AllergyStringToEnum.ContainsKey(allergy))
{
return(false);
}
var flag = AllergyStringToEnum[allergy];
return(flags.HasFlag(flag));
}
public Allergens UpdateAllergen(Allergens allergenUpdate)
{
if (allergenUpdate.Id < 1)
{
throw new ArgumentException("Íd need to be higher than 0");
}
if (allergenUpdate.AllergenType == null)
{
throw new ArgumentException("You need to add a name for the allergen");
}
return(_allergensRepo.UpdateAllergen(allergenUpdate));
}
public Allergens Create(Allergens entity)
{
if (!ExistsInSystem(entity))
{
var allAllergens = stream.GetAll().ToList();
allAllergens.Add(entity);
stream.SaveAll(allAllergens);
return(entity);
}
else
{
throw new EntityAlreadyExists(ALREADY_EXISTS);
}
}
public Allergens CreateAllergen(Allergens allergen)
{
//Clone allergensInMenu to new location in memory, so they are not overridden on Attach
var newAllergenInMenu = new List <AllergensInMenu>(allergen.AllergensInMenu);
//Attach ingredient so basic properties are updated
_ctx.Attach(allergen).State = EntityState.Added;
//Remove all recipelines with updated order information
_ctx.AllergensInMenu.RemoveRange(
_ctx.AllergensInMenu.Where(ol => ol.MainFoodId == allergen.Id)
);
//Add all orderlines with updated order information
foreach (var ol in newAllergenInMenu)
{
_ctx.Entry(ol).State = EntityState.Added;
}
// Save it
_ctx.SaveChanges();
//Return it
return(allergen);
}
public async Task <IHttpActionResult> DeleteAllergens(int id)
{
Allergens allergens = await db.Allergens.FindAsync(id);
if (allergens == null)
{
return(NotFound());
}
AllergensDTO result = (new AllergensDTO()
{
ID = allergens.ID,
Name = allergens.Name,
Recipes = (from s in allergens.Recipes select s.Id).AsEnumerable().ToList()
});
db.Allergens.Remove(allergens);
await db.SaveChangesAsync();
return(Ok(result));
}
/// <summary>
/// Dieser Event Handler wird aufgerufen, wenn die Weboberfläche angefordert wird.<para>
/// Er konfiguriert gegebenenfalls die Tabelle gemäß der Suchanfrage.</para>
/// </summary>
/// <param name="search">
/// Der zu suchende Ausdruck
/// </param>
/// <param name="sortOrder">
/// Das Sortierverhalten
/// </param>
public void OnGet(string search, string sortOrder)
{
SearchKeyWord = search ?? string.Empty;
if (!string.IsNullOrEmpty(SearchKeyWord))
{
Allergens = Allergens.Search(search, allergen => allergen.ToString()).ToArray();
}
Sort = string.IsNullOrEmpty(sortOrder) ? "!" : "";
IOrderedEnumerable <Allergen> allergens = Allergens.OrderBy(allergen => 0);
switch (sortOrder)
{
case "!":
allergens = allergens.OrderByDescending(allergen => allergen.Description);
break;
default:
allergens = allergens.OrderBy(allergen => allergen.Description);
break;
}
Allergens = allergens.ToArray();
}
private void DeleteAllergies_Click(object sender, RoutedEventArgs e)
{
if (selectedAllergy == null)
{
ErrorMessage.Visibility = Visibility.Visible;
Error.Text = ERROR_DELETE;
return;
}
ModelHCI.MedicalRecordHCI record = Informations.currentRecord;
var recordToUpdate = record.MedicalRecord;
Allergens allergyToDelete = null;
foreach (Allergens allergens in recordToUpdate.Allergies)
{
if (allergens.Allergen.Equals(selectedAllergy.allergens.Allergen))
{
allergyToDelete = allergens;
}
}
if (allergyToDelete != null)
{
recordToUpdate.Allergies.Remove(allergyToDelete);
}
var recordUpdate = medicalRecordController.GetMedicalRecord(recordToUpdate.IdRecord);
if (allergyToDelete != null)
{
recordUpdate.Allergies.Remove(allergyToDelete);
}
medicalRecordController.UpdateRecord(recordToUpdate);
Informations.currentRecord.MedicalRecord = medicalRecordController.GetMedicalRecord(recordToUpdate.IdRecord);
setListBoxes();
}
public Allergens UpdateAllergen(Allergens allergenUpdate)
{
foreach (var item in _ctx.AllergensInMenu.ToList().Where(c => c.AllergenID == allergenUpdate.Id))
{
_ctx.AllergensInMenu.Remove(item);
}
//Clone allergens in menu to new location in memory, so they are not overridden on Attach
var relation = new List <AllergensInMenu>(allergenUpdate.AllergensInMenu);
//Attach A.I.M so basic properties are updated
_ctx.Attach(allergenUpdate).State = EntityState.Modified;
//Add all orderlines with updated order information
foreach (var ol in relation)
{
_ctx.Entry(ol).State = EntityState.Added;
}
// Save it
_ctx.SaveChanges();
//Return it
return(allergenUpdate);
}
public Allergens CreateAllergen(Allergens allergens) => allergensService.CreateAllergen(allergens);
public Allergens CreateAllergen(Allergens allergens) => allergensRepository.Create(allergens);
public bool ExistsInSystem(Allergens allergens)
{
var allAllergens = stream.GetAll().ToList();
return(allAllergens.Any(item => item.Allergen == allergens.Allergen));
}
/// <summary>
/// Returns true if BrandedFoodObjectItems instances are equal
/// </summary>
/// <param name="other">Instance of BrandedFoodObjectItems to be compared</param>
/// <returns>Boolean</returns>
public bool Equals(BrandedFoodObjectItems other)
{
if (ReferenceEquals(null, other))
{
return(false);
}
if (ReferenceEquals(this, other))
{
return(true);
}
return
((
Barcode == other.Barcode ||
Barcode != null &&
Barcode.Equals(other.Barcode)
) &&
(
Name == other.Name ||
Name != null &&
Name.Equals(other.Name)
) &&
(
Brand == other.Brand ||
Brand != null &&
Brand.Equals(other.Brand)
) &&
(
Ingredients == other.Ingredients ||
Ingredients != null &&
Ingredients.Equals(other.Ingredients)
) &&
(
Package == other.Package ||
Package != null &&
Package.Equals(other.Package)
) &&
(
Serving == other.Serving ||
Serving != null &&
Serving.Equals(other.Serving)
) &&
(
Categories == other.Categories ||
Categories != null &&
Categories.SequenceEqual(other.Categories)
) &&
(
Nutrients == other.Nutrients ||
Nutrients != null &&
Nutrients.SequenceEqual(other.Nutrients)
) &&
(
DietLabels == other.DietLabels ||
DietLabels != null &&
DietLabels.Equals(other.DietLabels)
) &&
(
DietFlags == other.DietFlags ||
DietFlags != null &&
DietFlags.SequenceEqual(other.DietFlags)
) &&
(
PackagingPhotos == other.PackagingPhotos ||
PackagingPhotos != null &&
PackagingPhotos.Equals(other.PackagingPhotos)
) &&
(
Allergens == other.Allergens ||
Allergens != null &&
Allergens.SequenceEqual(other.Allergens)
) &&
(
BrandList == other.BrandList ||
BrandList != null &&
BrandList.SequenceEqual(other.BrandList)
) &&
(
Countries == other.Countries ||
Countries != null &&
Countries.SequenceEqual(other.Countries)
) &&
(
CountryDetails == other.CountryDetails ||
CountryDetails != null &&
CountryDetails.Equals(other.CountryDetails)
) &&
(
PalmOilIngredients == other.PalmOilIngredients ||
PalmOilIngredients != null &&
PalmOilIngredients.SequenceEqual(other.PalmOilIngredients)
) &&
(
IngredientList == other.IngredientList ||
IngredientList != null &&
IngredientList.SequenceEqual(other.IngredientList)
) &&
(
HasEnglishIngredients == other.HasEnglishIngredients ||
HasEnglishIngredients != null &&
HasEnglishIngredients.Equals(other.HasEnglishIngredients)
) &&
(
Minerals == other.Minerals ||
Minerals != null &&
Minerals.SequenceEqual(other.Minerals)
) &&
(
Traces == other.Traces ||
Traces != null &&
Traces.SequenceEqual(other.Traces)
) &&
(
Vitamins == other.Vitamins ||
Vitamins != null &&
Vitamins.SequenceEqual(other.Vitamins)
) &&
(
Description == other.Description ||
Description != null &&
Description.Equals(other.Description)
) &&
(
Keywords == other.Keywords ||
Keywords != null &&
Keywords.SequenceEqual(other.Keywords)
));
}
/// <summary>
/// Gets the hash code
/// </summary>
/// <returns>Hash code</returns>
public override int GetHashCode()
{
unchecked // Overflow is fine, just wrap
{
var hashCode = 41;
// Suitable nullity checks etc, of course :)
if (Barcode != null)
{
hashCode = hashCode * 59 + Barcode.GetHashCode();
}
if (Name != null)
{
hashCode = hashCode * 59 + Name.GetHashCode();
}
if (Brand != null)
{
hashCode = hashCode * 59 + Brand.GetHashCode();
}
if (Ingredients != null)
{
hashCode = hashCode * 59 + Ingredients.GetHashCode();
}
if (Package != null)
{
hashCode = hashCode * 59 + Package.GetHashCode();
}
if (Serving != null)
{
hashCode = hashCode * 59 + Serving.GetHashCode();
}
if (Categories != null)
{
hashCode = hashCode * 59 + Categories.GetHashCode();
}
if (Nutrients != null)
{
hashCode = hashCode * 59 + Nutrients.GetHashCode();
}
if (DietLabels != null)
{
hashCode = hashCode * 59 + DietLabels.GetHashCode();
}
if (DietFlags != null)
{
hashCode = hashCode * 59 + DietFlags.GetHashCode();
}
if (PackagingPhotos != null)
{
hashCode = hashCode * 59 + PackagingPhotos.GetHashCode();
}
if (Allergens != null)
{
hashCode = hashCode * 59 + Allergens.GetHashCode();
}
if (BrandList != null)
{
hashCode = hashCode * 59 + BrandList.GetHashCode();
}
if (Countries != null)
{
hashCode = hashCode * 59 + Countries.GetHashCode();
}
if (CountryDetails != null)
{
hashCode = hashCode * 59 + CountryDetails.GetHashCode();
}
if (PalmOilIngredients != null)
{
hashCode = hashCode * 59 + PalmOilIngredients.GetHashCode();
}
if (IngredientList != null)
{
hashCode = hashCode * 59 + IngredientList.GetHashCode();
}
if (HasEnglishIngredients != null)
{
hashCode = hashCode * 59 + HasEnglishIngredients.GetHashCode();
}
if (Minerals != null)
{
hashCode = hashCode * 59 + Minerals.GetHashCode();
}
if (Traces != null)
{
hashCode = hashCode * 59 + Traces.GetHashCode();
}
if (Vitamins != null)
{
hashCode = hashCode * 59 + Vitamins.GetHashCode();
}
if (Description != null)
{
hashCode = hashCode * 59 + Description.GetHashCode();
}
if (Keywords != null)
{
hashCode = hashCode * 59 + Keywords.GetHashCode();
}
return(hashCode);
}
}
public bool IsAllergicTo(Allergens allergen)
{
return((GetAllergens() & allergen) != 0);
}
public MedicalRecord UpdateAllergies(Allergens allergy, MedicalRecord medicalRecord) => medicalRecordService.UpdateAllergies(allergy, medicalRecord);
public IEnumerable GetSuggestions(string filter)
{
return(Allergens.Where(a => a.Name.ToLower().Contains(filter)));
}
public Allergies(int mask)
{
_allergenFlags = (Allergens)mask;
}
