public async Task <Response> Insert(User item) { using (DietDB db = new DietDB()) { if (item.Restriction != null) { //Informa o EF para não tentar cadastrar as comidas dentro da restrição db.Foods.AttachRange(item.Restriction.Foods); //Cadastra a restrição db.Restrictions.Add(item.Restriction); //cadastra o usuario item.RestrictionID = item.Restriction.ID; db.Users.Add(item); await db.SaveChangesAsync(); return(ResponseFactory.ResponseSuccessModel()); } else if (item.Restriction == null) { db.Users.Add(item); await db.SaveChangesAsync(); return(ResponseFactory.ResponseSuccessModel()); } return(ResponseFactory.SingleResponseNotFoundException <User>()); } }
public Response Insert(User item) { using (DietDB db = new DietDB()) { db.Users.Add(item); db.SaveChangesAsync(); return(ResponseFactory.ResponseSuccessModel()); } }
public async Task <Response> Insert(Food item) { using (DietDB db = new DietDB()) { db.Foods.Add(item); await db.SaveChangesAsync(); } return(ResponseFactory.ResponseSuccessModel()); }
public async Task <Response> Update(Food item) { using (DietDB db = new DietDB()) { db.Entry(item).State = EntityState.Modified; await db.SaveChangesAsync(); } return(ResponseFactory.ResponseSuccessModel()); }
public async Task <SingleResponse <int> > Insert(Meal item) { using (DietDB db = new DietDB()) { item.SetStatus(true); db.Meals.Add(item); await db.SaveChangesAsync(); } return(ResponseFactory.SingleResponseSuccessModel <int>(item.ID)); }
public async Task <QueryResponse <Food> > GetByCategoryId(int id) { QueryResponse <Food> response = new QueryResponse <Food>(); using (DietDB db = new DietDB()) { List <Food> foods = await db.Foods.Where(c => c.CategoryID == id).ToListAsync(); response.Data = foods; return(ResponseFactory.QueryResponseSuccessModel <Food>(foods)); } }
public async Task <QueryResponse <Meal> > GetByCategory(Meal_Category category) { QueryResponse <Meal> response = new QueryResponse <Meal>(); using (DietDB db = new DietDB()) { List <Meal> meal = await db.Meals.Include(c => c.Foods).Where(w => w.Category == category).ToListAsync(); response.Data = meal; } return(response); }
public async Task <QueryResponse <Meal> > GetAll() { QueryResponse <Meal> response = new QueryResponse <Meal>(); using (DietDB db = new DietDB()) { List <Meal> meals = await db.Meals.ToListAsync(); response.Data = meals; } return(response); }
public async Task <QueryResponse <FoodAmountPerMeal> > GetMealFoodsById(int id) { QueryResponse <FoodAmountPerMeal> response = new QueryResponse <FoodAmountPerMeal>(); using (DietDB db = new DietDB()) { List <FoodAmountPerMeal> meal = await db.FoodAmountPerMeal.Where(w => w.Meal.ID == id).ToListAsync(); response.Data = meal; } return(response); }
public async Task <QueryResponse <Food> > GetAll() { QueryResponse <Food> response = new QueryResponse <Food>(); using (DietDB db = new DietDB()) { List <Food> foods = await db.Foods.ToListAsync(); response.Data = foods; return(ResponseFactory.QueryResponseSuccessModel <Food>(foods)); } //return ResponseFactory.QueryResponseNotFoundException<Food>(); }
public async Task <SingleResponse <User> > Authenticate(string email, string senha) { using (DietDB db = new DietDB()) { User user = await db.Users.FirstOrDefaultAsync(u => u.Email == email && u.Password == senha); if (user == null) { return(ResponseFactory.SingleResponseNotFoundException <User>()); } return(ResponseFactory.SingleResponseSuccessModel <User>(user)); } }
public async Task <Response> Insert(FoodCategory item) { using (DietDB db = new DietDB()) { if (item != null) { db.Categories.Add(item); await db.SaveChangesAsync(); return(ResponseFactory.ResponseSuccessModel()); } return(ResponseFactory.SingleResponseNotFoundException <User>()); } }
public async Task <Response> Update(Diet item) { using (DietDB db = new DietDB()) { if (item != null) { db.Entry(item).State = EntityState.Modified; await db.SaveChangesAsync(); return(ResponseFactory.ResponseSuccessModel()); } return(ResponseFactory.ResponseNotFoundException()); } }
public async Task <Response> Delete(int id) { Food food = new Food(); food.ID = id; using (DietDB db = new DietDB()) { db.Entry(food).State = EntityState.Deleted; await db.SaveChangesAsync(); } return(ResponseFactory.ResponseSuccessModel()); }
public async Task <SingleResponse <Meal> > GetByName(Meal item) { SingleResponse <Meal> response = new SingleResponse <Meal>(); string name = item.Name; using (DietDB db = new DietDB()) { Meal meal = await db.Meals.FirstOrDefaultAsync(w => w.Name == name); response.Data = meal; } return(response); }
public async Task <SingleResponse <Meal> > GetById(int id) { SingleResponse <Meal> response = new SingleResponse <Meal>(); using (DietDB db = new DietDB()) { Meal meal = await db.Meals.FirstOrDefaultAsync(w => w.ID == id); if (meal != null) { response.Data = meal; return(ResponseFactory.SingleResponseSuccessModel <Meal>(meal)); } return(ResponseFactory.SingleResponseNotFoundException <Meal>()); } }
public async Task <SingleResponse <FoodCategory> > GetByName(string nome) { SingleResponse <FoodCategory> response = new SingleResponse <FoodCategory>(); using (DietDB db = new DietDB()) { FoodCategory category = await db.Categories.FirstOrDefaultAsync(w => w.Name == nome); if (category != null) { response.Data = category; return(ResponseFactory.SingleResponseSuccessModel <FoodCategory>(category)); } return(ResponseFactory.SingleResponseNotFoundException <FoodCategory>()); } }
public async Task <SingleResponse <User> > GetById(int id) { SingleResponse <User> response = new SingleResponse <User>(); using (DietDB db = new DietDB()) { User user = await db.Users.FirstOrDefaultAsync(w => w.ID == id); if (user != null) { response.Data = user; return(ResponseFactory.SingleResponseSuccessModel <User>(user)); } return(ResponseFactory.SingleResponseNotFoundException <User>()); } }
public async Task <SingleResponse <Diet> > GetById(int id) { SingleResponse <Diet> response = new SingleResponse <Diet>(); using (DietDB db = new DietDB()) { Diet diet = await db.Diets.Include(c => c.Meals).FirstOrDefaultAsync(w => w.ID == id); if (diet != null) { response.Data = diet; return(ResponseFactory.SingleResponseSuccessModel <Diet>(diet)); } return(ResponseFactory.SingleResponseNotFoundException <Diet>()); } }
public async Task <QueryResponse <Diet> > GetAll() { QueryResponse <Diet> response = new QueryResponse <Diet>(); using (DietDB db = new DietDB()) { List <Diet> diets = await db.Diets.Where(a => a.Status).ToListAsync(); if (diets != null) { response.Data = diets; return(ResponseFactory.QueryResponseSuccessModel(diets)); } return(ResponseFactory.QueryResponseNotFoundException <Diet>()); } }
public async Task <Response> Disable(int id) { using (DietDB db = new DietDB()) { FoodCategory food_Category = await db.Categories.FirstOrDefaultAsync(u => u.ID == id); if (food_Category != null) { //food_Category.SetStatus(false); await db.SaveChangesAsync(); return(ResponseFactory.ResponseSuccessModel()); } return(ResponseFactory.ResponseNotFoundException()); } }
public async Task <QueryResponse <User> > GetAll() { QueryResponse <User> response = new QueryResponse <User>(); using (DietDB db = new DietDB()) { List <User> users = await db.Users.Where(a => a.Status).ToListAsync(); if (users != null) { response.Data = users; return(ResponseFactory.QueryResponseSuccessModel(users)); } return(ResponseFactory.QueryResponseNotFoundException <User>()); } }
public async Task <Response> Disable(int id) { using (DietDB db = new DietDB()) { Diet diet = await db.Diets.FirstOrDefaultAsync(u => u.ID == id); if (diet != null) { diet.SetStatus(false); await db.SaveChangesAsync(); return(ResponseFactory.ResponseSuccessModel()); } return(ResponseFactory.ResponseNotFoundException()); } }
public async Task <SingleResponse <Food> > GetById(int id) { SingleResponse <Food> response = new SingleResponse <Food>(); using (DietDB db = new DietDB()) { Food food = await db.Foods.FirstOrDefaultAsync(w => w.ID == id); if (food != null) { response.Data = food; return(ResponseFactory.SingleResponseSuccessModel <Food>(food)); } return(ResponseFactory.SingleResponseNotFoundException <Food>()); } }
public async Task <QueryResponse <FoodCategory> > GetAll() { QueryResponse <FoodCategory> response = new QueryResponse <FoodCategory>(); using (DietDB db = new DietDB()) { List <FoodCategory> food_Categories = await db.Categories.Include(c => c.Foods).ToListAsync(); if (food_Categories != null) { response.Data = food_Categories; return(ResponseFactory.QueryResponseSuccessModel(food_Categories)); } return(ResponseFactory.QueryResponseNotFoundException <FoodCategory>()); } }
public async Task <Response> Disable(int id) { using (DietDB db = new DietDB()) { Food food = await db.Foods.FirstOrDefaultAsync(u => u.ID == id); if (food != null) { food.Status = false; await db.SaveChangesAsync(); return(ResponseFactory.ResponseSuccessModel()); } return(ResponseFactory.ResponseNotFoundException()); } }
public async Task <Response> Delete(int id) { Diet diet = new Diet(); diet.ID = id; using (DietDB db = new DietDB()) { if (diet != null) { db.Entry(diet).State = EntityState.Deleted; await db.SaveChangesAsync(); return(ResponseFactory.ResponseSuccessModel()); } return(ResponseFactory.SingleResponseNotFoundException <Diet>()); } }
public async Task <Response> Delete(int id) { FoodCategory food_Category = new FoodCategory(); food_Category.ID = id; using (DietDB db = new DietDB()) { if (food_Category != null) { db.Entry(food_Category).State = EntityState.Deleted; await db.SaveChangesAsync(); return(ResponseFactory.ResponseSuccessModel()); } return(ResponseFactory.SingleResponseNotFoundException <FoodCategory>()); } }
public async Task <SingleResponse <Food> > GetByName(Food item) { SingleResponse <Food> response = new SingleResponse <Food>(); string name = item.Food_Name; using (DietDB db = new DietDB()) { Food food = await db.Foods.FirstOrDefaultAsync(w => w.Food_Name == name); if (food != null) { response.Data = food; return(ResponseFactory.SingleResponseSuccessModel <Food>(food)); } return(ResponseFactory.SingleResponseNotFoundException <Food>()); } }
public async Task <Response> Delete(int id) { Meal user = new Meal(); user.ID = id; using (DietDB db = new DietDB()) { if (user != null) { db.Entry(user).State = EntityState.Deleted; await db.SaveChangesAsync(); return(ResponseFactory.ResponseSuccessModel()); } return(ResponseFactory.SingleResponseNotFoundException <User>()); } }