Beispiel #1
0
        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>());
            }
        }
Beispiel #2
0
 public Response Insert(User item)
 {
     using (DietDB db = new DietDB())
     {
         db.Users.Add(item);
         db.SaveChangesAsync();
         return(ResponseFactory.ResponseSuccessModel());
     }
 }
Beispiel #3
0
        public async Task <Response> Insert(Food item)
        {
            using (DietDB db = new DietDB())
            {
                db.Foods.Add(item);
                await db.SaveChangesAsync();
            }

            return(ResponseFactory.ResponseSuccessModel());
        }
Beispiel #4
0
        public async Task <Response> Update(Food item)
        {
            using (DietDB db = new DietDB())
            {
                db.Entry(item).State = EntityState.Modified;
                await db.SaveChangesAsync();
            }

            return(ResponseFactory.ResponseSuccessModel());
        }
Beispiel #5
0
        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));
        }
Beispiel #6
0
        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));
            }
        }
Beispiel #7
0
        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);
        }
Beispiel #8
0
        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);
        }
Beispiel #9
0
        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);
        }
Beispiel #10
0
        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>();
        }
Beispiel #11
0
        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));
            }
        }
Beispiel #12
0
        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>());
            }
        }
Beispiel #13
0
        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());
            }
        }
Beispiel #14
0
        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());
        }
Beispiel #15
0
        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);
        }
Beispiel #16
0
        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>());
            }
        }
Beispiel #17
0
        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>());
            }
        }
Beispiel #18
0
        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>());
            }
        }
Beispiel #19
0
        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>());
            }
        }
Beispiel #20
0
        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>());
            }
        }
Beispiel #21
0
        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());
            }
        }
Beispiel #22
0
        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>());
            }
        }
Beispiel #23
0
        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());
            }
        }
Beispiel #24
0
        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>());
            }
        }
Beispiel #25
0
        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>());
            }
        }
Beispiel #26
0
        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());
            }
        }
Beispiel #27
0
        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>());
            }
        }
Beispiel #28
0
        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>());
            }
        }
Beispiel #29
0
        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>());
            }
        }
Beispiel #30
0
        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>());
            }
        }