public async Task <IActionResult> GetRecipes([FromRoute] string id)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var recipes = await _context.Recipes
.Include(m => m.SocialWork)
.Include(u => u.User)
.ThenInclude(l => l.Lab)
.Include(g => g.RecipeDetails)
.Where(u => u.User.Id == id)
.OrderBy(t => t.RecipeDate)
.ToListAsync();
if (recipes == null)
{
return(BadRequest("No hay Recetas para este Usuario."));
}
List <RecipeResponse> recipeResponses = new List <RecipeResponse>();
foreach (RecipeEntity recipe in recipes)
{
RecipeResponse recipeResponse = await _converterHelper.ToRecipeResponse(recipe);
recipeResponses.Add(recipeResponse);
}
return(Ok(recipeResponses));
}
public static void deleteRecipe(recipe recipe, string dataurl, string apiAuthToken)
{
string jsonurl = "";
if (recipe.idString != null)
{
jsonurl = dataurl + "/beernet/recipe/" + recipe.idString;
}
else
{
return;
}
var client = new RestClient("" + dataurl);
var request = new RestRequest(jsonurl, Method.DELETE);
// Json to post.
string jsonToSend = Newtonsoft.Json.JsonConvert.SerializeObject(recipe);
request.AddParameter("application/json; charset=utf-8", jsonToSend, ParameterType.RequestBody);
request.RequestFormat = DataFormat.Json;
request.AddHeader("Authorization", "bearer " + apiAuthToken);
var response = client.Execute(request);
RecipeResponse returnable = JsonConvert.DeserializeObject <RecipeResponse>(response.Content);
}
public async Task <RecipeResponse> GetRecipejsonData()
{
RecipeResponse response = new RecipeResponse();
try
{
var assembly = this.GetType().GetTypeInfo().Assembly;
Stream stream = assembly.GetManifestResourceStream("BloomAssignment.BloomRecipe.json");
using (var reader = new System.IO.StreamReader(stream))
{
var jsonString = reader.ReadToEnd();
response = JsonConvert.DeserializeObject <RecipeResponse>(jsonString);
var mealType = response.Items.Select(x => x.MealType).ToList();
// List<LocalItemsModel> type = new List<LocalItemsModel>();
foreach (var item in mealType)
{
foreach (var items in item)
{
LocalItemsModel meal = new LocalItemsModel();
meal.Id = items.Id;
meal.Name = items.Name;
meal.FeaturedImage = items.FeaturedImage;
meal.Slug = items.Slug;
await App.Database.SaveItemAsync(meal);
}
}
}
return(response);
}
catch (Exception ex)
{
return(response);
}
}
public void Save(bool save)
{
RecipeResponse r = RecipeHelper.SaveRecipe(Model, save, SessionID);
Model.recipeStats = r.recipeStats;
Model.lastModifiedGuid = r.lastModifiedGuid;
Model.idString = r.idString;
refreshParent.InvokeAsync("");
}
public static RecipeResponse SaveRecipe(recipe recipe, bool save, string sessionID)
{
//string token = Auth.getAPIAuthToken(apiLink, loginEndpoint, values).Replace("\"", "");
string LoginToken = retrieveToken(sessionID);
RecipeResponse stats = DataAccess.postRecipe(recipe, apiLink, LoginToken, save);
return(stats);
}
public async void Save(bool save)
{
RecipeResponse r = RecipeHelper.SaveRecipe(Model, save, await getSessionID());
Model.idString = r.idString;
Model.recipeStats = r.recipeStats;
Model.lastModifiedGuid = r.lastModifiedGuid;
StateHasChanged();
}
public IActionResult Delete(int recipeId)
{
RecipeResponse deletedRecipe = repository.DelecteRecipe(recipeId);
if (deletedRecipe != null)
{
TempData["message"] = $"{deletedRecipe.FoodName} was deletd!";
}
return(RedirectToAction("RecipeList"));
}
public IActionResult AddRecipe(RecipeResponse recipe)
{
if (ModelState.IsValid)
{
repository.SaveRecipe(recipe);
TempData["message"] = $"{recipe.FoodName} has been saved!";
return(RedirectToAction("RecipeList"));
}
else
{
return(View(recipe));
}
}
public void SaveRecipe_Failure()
{
var recipeResponse = new RecipeResponse("Null Category");
_mockService.Setup(s => s.SaveRecipe(It.IsAny <Recipe>()))
.Returns(recipeResponse);
_recipesController = new RecipesController(_mockService.Object, _logger.Object, _mappingConfig.CreateMapper());
var result = _recipesController.SaveRecipe(CreateRandomRecipe());
result.Should().NotBeNull();
var res = (Microsoft.AspNetCore.Mvc.BadRequestObjectResult)result;
res.StatusCode.Should().Be((int)HttpStatusCode.BadRequest);
}
public async Task <IActionResult> Create([FromBody] CreateRecipeRequest recipeRequest)
{
if (recipeRequest.Name == null || recipeRequest.Description == null)
{
return(BadRequest(new { error = "Null variables [Name and Description] are not allowed" }));
}
var recipe = new Recipe
{
Id = new int(),
Name = recipeRequest.Name,
Description = recipeRequest.Description,
Date = DateTime.UtcNow,
ParentId = recipeRequest.ParentId,
Left = 1,
Right = 2,
DepthLevel = 0,
TreeId = Guid.NewGuid()
};
if (recipe.ParentId != null)
{
var parentRecipe = await _recipeService.GetRecipeByIdAsync((int)recipe.ParentId);
recipe.DepthLevel = parentRecipe.DepthLevel + 1;
recipe.TreeId = parentRecipe.TreeId;
recipe.Left = await _recipeService.FindLeftAtSpecificDeep(recipe.DepthLevel, recipe.TreeId, (int)recipe.ParentId);
recipe.Right = recipe.Left + 1;
await _recipeService.IncrementAllPositionsWhenRecipeAdded(recipe.Right, recipe.TreeId, (int)recipe.ParentId);
}
await _recipeService.CreateRecipeAsync(recipe);
var response = new RecipeResponse
{
Id = recipe.Id,
Name = recipe.Name,
Description = recipe.Description,
Date = recipe.Date,
ParentId = recipe.ParentId,
DepthLevel = recipe.DepthLevel,
TreeId = recipe.TreeId
};
return(Ok(response));
}
public RecipesControllerTest()
{
_mockService = new Mock <IRecipeService>();
var recipeResponse = new RecipeResponse(CreateRandomRecipe2());
_mockService.Setup(s => s.GetRecipes()).Returns(new List <Recipe>());
_mockService.Setup(s => s.SaveRecipe(It.IsAny <Recipe>()))
.Returns(recipeResponse);
_mockService.Setup(s => s.UpdateRecipe(It.IsAny <Guid>(), It.IsAny <Recipe>()))
.Returns(recipeResponse);
_mockService.Setup(s => s.DeleteRecipe(It.IsAny <Guid>())).Returns(recipeResponse);
_logger = new Mock <ILogger <Program> >();
_mappingConfig = new MapperConfiguration(mc => { mc.AddProfile(new Mapping.ModelToResourceProfile()); });
_recipesController = new RecipesController(_mockService.Object, _logger.Object, _mappingConfig.CreateMapper());
}
public static RecipeResponse postRecipe(recipe recipe, string dataurl, string apiAuthToken, bool save)
{
string jsonurl = "";
if (recipe.equipmentProfile == null)
{
recipe.equipmentProfile = RecipeTools.getDefaultEquipmentProfile();
}
if (recipe.idString != null)
{
if (save)
{
jsonurl = dataurl + "/beernet/recipe/" + recipe.idString;
}
else
{
jsonurl = dataurl + "/beernet/recipe/" + recipe.idString + "/true";
}
}
else
{
jsonurl = dataurl + "/beernet/recipe";
}
var client = new RestClient("" + dataurl);
var request = new RestRequest(jsonurl, Method.POST);
// Json to post.
string jsonToSend = Newtonsoft.Json.JsonConvert.SerializeObject(recipe);
request.AddParameter("application/json; charset=utf-8", jsonToSend, ParameterType.RequestBody);
request.RequestFormat = DataFormat.Json;
request.AddHeader("Authorization", "bearer " + apiAuthToken);
var response = client.Execute(request);
RecipeResponse returnable = JsonConvert.DeserializeObject <RecipeResponse>(response.Content);
return(returnable);
}
//IngredientsRequest ingredientsRequest
public async Task <IActionResult> GetRecipesAsync(RecipeRequest recipeRequest)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
// TODO: Consulta de acuerdo a los ingredientes que escoga la persona,
// por el momento se traeran todas la recetas disponibles
//var recipes = await _dataContext.Recipes
// .Include(r => r.RecipeType)
// .Include(r => r.Comments)
// .Include(r => r.RateRecipes)
// .Include(r => r.FavouriteRecipes)
// .Include(r => r.RecipeIngredients)
// .ThenInclude(r => r.Ingredient)
// .ToListAsync();
//.ToList();
//.All(r => r.RecipeIngredients.Count > 0);
//.AnyAsync(r => r.RecipeIngredients.Count > 0);
//.Any(r => r.RecipeIngredients.Any(ri => ri.Ingredient == ))
//try
//{
// var recipes = ;
//}
//catch (Exception e)
//{
// throw;
//}
//try
//{
// var recipes = _dataContext.AllRecipesViews
// .Where(x => recipeRequest.Ingredients.Any(y => y == x.NameIngredient))
// .ToList();
//}
//catch (Exception ex)
//{
// throw;
//}
//var recipes = await _dataContext.RecipeIngredients
// .Include(r => r.Recipe)
// .ThenInclude(r => r.RecipeType)
// .Include(r => r.Recipe)
// .ThenInclude(r => r.Comments)
// .Include(r => r.Recipe)
// .ThenInclude(r => r.RateRecipes)
// .Include(r => r.Recipe)
// .ThenInclude(r => r.FavouriteRecipes)
// .Include(r => r.Ingredient)
// .Where(r => r.Ingredient.Name.Contains(recipeRequest.Ingredients[0]))
// .OrderBy(r => r.Recipe.Name)
// .ToListAsync();
var recipes = await _dataContext.RecipeIngredients
.Include(r => r.Recipe)
.ThenInclude(r => r.RecipeType)
.Include(r => r.Recipe)
.ThenInclude(r => r.Comments)
.Include(r => r.Recipe)
.ThenInclude(r => r.RateRecipes)
.Include(r => r.Recipe)
.ThenInclude(r => r.FavouriteRecipes)
.Include(r => r.Ingredient)
.OrderBy(r => r.Recipe.Name)
.ToListAsync();
var recipesfilter = recipes.Where(r => recipeRequest.Ingredients.Any(i => i == r.Ingredient.Name))
.ToList();
var response = new List <RecipeResponse>();
foreach (var recipe in recipesfilter)
{
var recipeResponse = new RecipeResponse
{
Id = recipe.Recipe.Id,
Name = recipe.Recipe.Name,
Description = recipe.Recipe.Description,
Instructions = recipe.Recipe.Instructions,
ImageUrl = recipe.Recipe.ImageFullPath,
RecipeType = recipe.Recipe.RecipeType.Name,
IngredientRecipes = recipe.Recipe.RecipeIngredients.Select(ri => new IngredientRecipeResponse
{
Id = ri.Id,
Amount = ri.Amount,
Ingredient = ri.Ingredient.Name
}).ToList(),
CommentResponses = recipe.Recipe.Comments.Select(c => new CommentResponse
{
Id = c.Id,
Remarks = c.Remarks,
Date = c.DateLocal,
Customer = c.Customer.User.FullName
}).ToList()
};
response.Add(recipeResponse);
}
;
//response.Distinct().ToList();
//var noDupsList = new HashSet<RecipeResponse>(response).ToList();
return(Ok(response));
}
