public Solution(string input)
{
var lines = Input.GetInputLines(input).ToArray();
foreach (var line in lines)
{
var firstSplit = line.Split(new char[] { '(', ')' }, StringSplitOptions.RemoveEmptyEntries);
var ingreds = firstSplit[0].Split(' ', StringSplitOptions.RemoveEmptyEntries);
foreach (var ingred in ingreds)
{
int num;
if (!ingredients.TryGetValue(ingred, out num))
{
ingredients[ingred] = 0;
}
ingredients[ingred]++;
}
var allergenStrings = firstSplit[1].Replace("contains", "").Split(new char[] { ' ', ',' }, StringSplitOptions.RemoveEmptyEntries);
foreach (var allergenString in allergenStrings)
{
Allergen allergen;
allergens.TryGetValue(allergenString, out allergen);
if (allergen == null)
{
allergen = new Allergen()
{
Name = allergenString
};
allergens.Add(allergenString, allergen);
}
if (allergen.MightBeIn.Count == 0)
{
allergen.MightBeIn.AddRange(ingreds);
}
else
{
allergen.MightBeIn = allergen.MightBeIn.Intersect(ingreds).ToList();
}
}
}
}
public void AddNewAllergenTestMethod()
{
var allergen = new Allergen {
Title = "New allergen", Description = "Allergen description"
};
var firstAllergen = repository.AllergenRepository.First();
repository.AddNewAllergen(allergen);
int count = repository.AllergenRepository.Count();
repository.AddNewAllergen(firstAllergen);
int count2 = repository.AllergenRepository.Count();
Assert.IsTrue(repository.AllergenRepository.Any(p => p.Title == "New allergen"), "Allergen not in database");
Assert.IsTrue(count == count2, "Added existing allergen");
}
public OperationResult AddNewAllergen(Allergen allergen)
{
if (DatabaseContext.Allergens.All(al => al.AllergenId != allergen.AllergenId))
{
DatabaseContext.Allergens.Add(allergen);
DatabaseContext.SaveChanges();
return(new OperationResult {
IsSucceeded = true
});
}
else
{
return(new OperationResult {
IsSucceeded = false
});
}
}
public Allergen[] List()
{
for (int i = 128; i >= 1; i = i / 2)
{
if (allergieScore - i >= 0)
{
Allergen enumToAdd = (Allergen)Enum.Parse(typeof(Allergen), Enum.GetName(typeof(Allergen), i));
allergenList.Insert(0, enumToAdd);
allergieScore -= i;
}
}
Allergen[] allergies = allergenList.ToArray();
return(allergies);
}
private List <Ingredient> GetIngredients()
{
var allergenGluten = new Allergen {
Name = "Gluten"
};
var allergenMilk = new Allergen {
Name = "Milk"
};
var ingredients = new List <Ingredient>
{
new Ingredient
{
Name = "Flour",
IngredientAllergens = new List <IngredientAllergen>
{
new IngredientAllergen {
Allergen = allergenGluten
},
}
},
new Ingredient
{
Name = "Tomatoes",
Description = "Some description",
ImagePath = "www....",
},
new Ingredient {
Name = "Pepperoni"
},
new Ingredient
{
Name = "Parmesan",
IngredientAllergens = new List <IngredientAllergen>
{
new IngredientAllergen {
Allergen = allergenMilk
}
},
Description = "Some description",
ImagePath = "www...."
}
};
return(ingredients);
}
private Ingredient(
Identity <Guid> id,
string name,
Allergen allergens,
Requirement requirements,
IEnumerable <MacroNutrientShare> shares,
IEventPublisher eventPublisher,
IIngredientRepository ingredientRepository)
{
Id = id;
Name = SetName(name);
Allergens = allergens;
Requirements = requirements;
MacroNutrientsSharesCollection = new MacroNutrientsSharesCollection(shares);
_eventPublisher = eventPublisher;
_ingredientRepository = ingredientRepository;
}
public OperationResult RemoveProductAllergen(Allergen allergen)
{
try
{
var first = DatabaseContext.Allergens.Single(a => a.AllergenId == allergen.AllergenId);
DatabaseContext.Allergens.Remove(first);
DatabaseContext.SaveChanges();
return(new OperationResult()
{
IsSucceeded = true
});
}
catch (InvalidOperationException e)
{
return(new OperationResult {
IsSucceeded = false
});
}
}
public void AddAllergen(Allergen newAllergen)
{
if (newAllergen == null)
{
return;
}
if (_allergensFile.allergens == null)
{
_allergensFile.allergens = new ObservableCollection <Allergen>();
}
foreach (Allergen allergen in _allergensFile.allergens)
{
if (allergen.Name == newAllergen.Name)
{
return;
}
}
_allergensFile.allergens.Add(newAllergen);
}
public void RemoveAllergenTestMethod()
{
var allergen = new Allergen {
Title = "New allergen", Description = "Allergen description"
};
var firstAllergen = repository.AllergenRepository.First();
int count = repository.AllergenRepository.Count();
repository.RemoveProductAllergen(firstAllergen);
int count2 = repository.AllergenRepository.Count();
Assert.IsTrue(count == count2 + 1, "Existing allergen not removed");
count = repository.AllergenRepository.Count();
repository.RemoveProductAllergen(allergen);
count2 = repository.AllergenRepository.Count();
Assert.IsTrue(count == count2, "Removing not existing allergen");
}
private void EditAllergenButton_OnClick(object sender, RoutedEventArgs e)
{
Button button = sender as Button;
Allergen copy = new Allergen(button.DataContext as Allergen);
var dialog = new AddModifyAllergenDialog(copy);
dialog.Owner = this;
dialog.ShowDialog();
if (dialog.DialogResult == true)
{
for (int i = 0; i < _viewModel.Allergens.Count; i++)
{
if (_viewModel.Allergens[i].AllergenId == copy.AllergenId)
{
_viewModel.allergenRepository.ChangeAllergen(_viewModel.Allergens[i], copy);
_viewModel.Allergens[i] = copy;
}
}
}
}
public void ChangeAllergenTestMethod()
{
var newAllergen = new Allergen {
Title = "New allergen", Description = "Allergen description"
};
var firstAllergen = repository.AllergenRepository.First();
int id = firstAllergen.AllergenId;
int count = repository.AllergenRepository.Count();
repository.ChangeAllergen(firstAllergen, newAllergen);
int count2 = repository.AllergenRepository.Count();
var changedAllergen = repository.AllergenRepository.First(p => p.AllergenId == id);
Assert.IsTrue(
count == count2 &&
changedAllergen.Description.Equals(newAllergen.Description) &&
changedAllergen.Title.Equals(newAllergen.Title)
, "Not changed");
}
public static void Intro(Allergen allergen)
{
Console.WriteLine("What is your favorite number?");
string response = "";
string userNumber = Console.ReadLine();
double num = allergen.GetUserInput(userNumber);
if (num == -.1)
{
Console.WriteLine("git gud at life, try again");
Intro(allergen);
}
else
{
response = allergen.ShowAllergens(num);
response = allergen.UnknownReplacer(response);
Console.WriteLine("Your allergen list: " + response);
}
}
public void RemoveAllergen(int dishId, int allergenId)
{
Dish dish = _unitOfWork.DishRepository.Get(d => (d.DishId == dishId) && (d.RestaurantId == _id)).First();
if (dish == null)
{
throw new EntityNotFoundException("Dish with id " + dishId + " not found.");
}
Allergen allergen = _unitOfWork.AllergenRepository.Get(allergenId);
if (allergen == null)
{
throw new EntityNotFoundException("Allergen with id " + allergenId + " not found.");
}
dish.Allergens.Remove(allergen);
_unitOfWork.DishRepository.Update(dish);
_unitOfWork.Complete();
}
public AllergenViewModel Convert(Allergen allergen)
{
try
{
AllergenViewModel allergenViewModel = null;
if (allergen != null)
{
allergenViewModel = new AllergenViewModel();
allergenViewModel.CodeId = allergen.Id;
allergenViewModel.CodeDesc = allergen.Desc;
allergenViewModel.CodeText = allergen.Text;
allergenViewModel.TypeId = allergen.TypeId;
}
return(allergenViewModel);
}
catch (Exception exception)
{
throw new Exception("Convert allergenSeverity > allergenSeverityViewModel failed!", exception);
}
}
public void MealThatCompliesWithRulesCompletesSuccessfully()
{
string designation = "Stone Soup";
MealType type = MealType.ValueOf(ExistingMealTypesService.ExistingMealTypes[0]);
List <Ingredient> ingredients = new List <Ingredient>();
ingredients.Add(Ingredient.ValueOf(ExistingIngredientsService.ExistingIngredients[0]));
List <Descriptor> descriptors = new List <Descriptor>();
descriptors.Add(Descriptor.ValueOf("Calorie", 50, "cal"));
List <Allergen> allergens = new List <Allergen>();
allergens.Add(Allergen.ValueOf(ExistingAllergensService.ExistingAllergens[0]));
new Meal(designation, type, ingredients, descriptors, allergens);
}
public void MealWithNullDescriptorsListThrowsArgumentNullException()
{
string designation = "Stone Soup";
MealType type = MealType.ValueOf(ExistingMealTypesService.ExistingMealTypes[0]);
List <Ingredient> ingredients = new List <Ingredient>();
ingredients.Add(Ingredient.ValueOf(ExistingIngredientsService.ExistingIngredients[0]));
List <Descriptor> descriptors = null;
List <Allergen> allergens = new List <Allergen>();
allergens.Add(Allergen.ValueOf(ExistingAllergensService.ExistingAllergens[0]));
Action newMeal = () => new Meal(designation, type, ingredients, descriptors, allergens);
Assert.Throws <ArgumentNullException>(newMeal);
}
public void MealWithEmptyIngredientsListThrowsArgumentException()
{
string designation = "Stone Soup";
MealType type = MealType.ValueOf(ExistingMealTypesService.ExistingMealTypes[0]);
List <Ingredient> ingredients = new List <Ingredient>();
List <Descriptor> descriptors = new List <Descriptor>();
descriptors.Add(Descriptor.ValueOf("Calorie", 50, "cal"));
List <Allergen> allergens = new List <Allergen>();
allergens.Add(Allergen.ValueOf(ExistingAllergensService.ExistingAllergens[0]));
Action newMeal = () => new Meal(designation, type, ingredients, descriptors, allergens);
Assert.Throws <ArgumentException>(newMeal);
}
public IHttpActionResult DeleteAllergen(int id)
{
Allergen allergen = db.Allergens.Find(id);
string userId = User.Identity.GetUserId();
RemoveAllergenFromLog(id);
Customer customer = db.Customers.Where(c => c.ApplicationUserId == userId).FirstOrDefault();
if (allergen == null)
{
return(NotFound());
}
try
{
AllergenTotal total = db.AllergenTotals.Where(a => a.AllergenId == id).FirstOrDefault();
db.AllergenTotals.Remove(total);
}
catch { }
try
{
AllergenJunction user = db.AllergensJunction.Where(a => a.AllergenId == id && a.CustomerId == customer.id).FirstOrDefault();
db.AllergensJunction.Remove(user);
}
catch { }
try
{
List <AllergenReactionJunction> logged = db.AllergensReactionsJunction.Where(a => a.AllergenId == id && a.CustomerId == customer.id).ToList();
db.AllergensReactionsJunction.RemoveRange(logged);
}
catch { }
db.Allergens.Remove(allergen);
db.SaveChanges();
return(Ok(allergen));
}
private void Button_Click(object sender, RoutedEventArgs e)
{
SecretaryController sc = new SecretaryController();
AllergensManagement am = new AllergensManagement();
PatientManagement pm = new PatientManagement();
Patient p;
string cb = ComboBox1.Text;
string specName = textBoxTypeAllergen.Text;
List <Patient> patients = sc.GetAllPatients();
p = sc.getPatient(idP);
string idAllergen = am.getID(cb);
Allergen a = new Allergen(idAllergen, cb, specName);
p.ListAllergens.Add(a);
pm.updateAllergen(p);
Close();
}
public Allergies(int allergyScore)
{
AllergyScore = (Allergen)allergyScore;
}
public bool IsAllergicTo(Allergen allergen) => AllergyScore.HasFlag(allergen);
public bool IsAllergicTo(Allergen allergen)
{
return(this.Mask.HasFlag(allergen));
}
public bool IsAllergicTo(Allergen allergen)
{
return((scoallergy & (int)allergen) > 0);
}
public Allergies(int mask)
{
_mask = mask;
_allergen = new Allergen();
_allergen |= (Allergen)_mask;
}
public bool IsAllergicTo(Allergen allergen) => Array.Exists(_allergens, x => x == allergen);
public bool IsAllergicTo(Allergen allergen)
{
return(_allergen.HasFlag(allergen));
}
public bool IsAllergicTo(Allergen allergen)
{
//return (mintMask & (int)allergen) > 0;
return(EnuMask.HasFlag(allergen));
}
public Allergies(int mask)
{
EnuMask = (Allergen)mask;
}
public void UpdateAllergen(Allergen allergen)
{
allergenService.UpdateAllergen(allergen);
}
public void CreateAllergen(Allergen allergen)
{
allergenService.CreateAllergen(allergen);
}
