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>());
}
}
