public IActionResult CreateRecipe(CreateRecipeViewModel vm)
{
var recipe = vm.Recipe;
recipe.CreatedAt = DateTime.Now;
recipe.UserId = userManager.GetUserId(User);
context.Recipes.Add(recipe);
context.SaveChanges();
var id = recipe.Id;
foreach (var ingredient in vm.ChosenIngredients)
{
var ing = new IngredientInRecipe()
{
IngredientId = ingredient.IngredientId,
Quantity = ingredient.Quantity,
RecipeId = id
};
context.IngredientsInRecipes.Add(ing);
}
context.SaveChanges();
return(Json(new { redirectToUrl = Url.Action("Index", "Home") }));
}
public virtual async Task <IActionResult> CreateRecipe(CreateRecipeViewModel viewModel)
{
if (!ModelState.IsValid)
{
return(this.ViewOrBadRequest(viewModel));
}
var recipe = new Recipe()
{
Enabled = false,
Name = viewModel.Name,
Description = viewModel.Description,
UserId = GetUserId()
};
await _recipeManager.AddOrUpdateRecipe(recipe);
if (string.IsNullOrEmpty(recipe.Id))
{
ModelState.AddModelError(string.Empty, "Could not save recipe");
return(this.ViewOrBadRequest(viewModel));
}
if (this.IsApi())
{
return(await EditRecipe(recipe.Id, (string)null));
}
return(RedirectToAction("EditRecipe", new { id = recipe.Id, statusMessage = "Recipe created" }));
}
public async Task UpdateRecipe(CreateRecipeViewModel model, IPrincipal user)
{
var unitOfWork = OwinContext.Get <UnitOfWork>();
// retrieve model from database
var recipe = await unitOfWork.Recipes.GetById(model.Id);
if (recipe == null)
{
throw new ObjectNotFoundException("The entry you are looking for doesn't exist in our database.");
}
// update model
recipe.Title = model.Title;
recipe.Description = model.Description;
if (model.PictureFile != null)
{
var fileStorageService = new LocalFileStorageService();
var picturePath = fileStorageService.StoreFile(model.PictureFile);
model.Picture = picturePath;
}
// save changes of modified model
await unitOfWork.SaveChangesAsync();
}
public IActionResult CreateCookingRecipe(CreateRecipeViewModel model)
{
if (!ModelState.IsValid)
{
return(this.View(model));
}
try
{
var creatorId = this.userManager
.GetUserAsync(HttpContext.User)
.GetAwaiter().GetResult()
.Id;
this.cookingRecipeService.CreateCookingRecipe(creatorId, model);
TempData["statusMessage"] = "Cooking recipe was created successfully!";
return(RedirectToAction("Index", "CookingRecipe"));
}
catch (System.Exception exeption)
{
ModelState.AddModelError("Action Failed!", exeption.Message);
return(this.View(model));
//another approach
//TempData["statusMessage"] = $"Action Failed! | {exeption.Message}";
//return RedirectToAction("Index", "CookingRecipe");
}
}
public async Task <IActionResult> EditData(string identifier, CreateRecipeViewModel data)
{
var result = await GetRecipeAction(identifier);
if (result.Error != null)
{
return(result.Error);
}
if (!ModelState.IsValid)
{
data.Recipes = new SelectList(await _recipeManager.GetRecipes(new RecipesQuery()
{
UserId = _userManager.GetUserId(User)
}), nameof(BtcTransmuter.Data.Entities.Recipe.Id), nameof(BtcTransmuter.Data.Entities.Recipe.Name),
data.RecipeTemplateId);
return(View(data));
}
var recipeAction = result.Data;
SetValues(data, recipeAction);
await _recipeManager.AddOrUpdateRecipeAction(recipeAction);
return(RedirectToAction("EditRecipe", "Recipes", new
{
id = recipeAction.RecipeId,
statusMessage = "Create Recipe Action Updated"
}));
}
public IActionResult SaveDatas([FromBody] RecipeModel model)
{
using (var db = new DatabaseContext())
{
var tempObject = new CreateRecipeViewModel
{
UserId = _userManager.GetUserId(User),
Title = model.title,
Details = model.details,
CreatedDate = DateTime.Now,
EditedDate = DateTime.Now
};
db.Recipe.Add(tempObject);
db.SaveChanges();
foreach (dynamic data in model.ingredients)
{
db.Ingredient.Add(new IngredientViewModel {
RecipeId = tempObject.Id, Name = data["Name"], Quantity = data["Quantity"], MeasurementUnit = data["MeasurementUnit"]
});
db.SaveChanges();
}
}
return(View("Recipe/Recipe"));
}
public async Task <ActionResult> Edit(CreateRecipeViewModel model)
{
var recipeManagement = HttpContext.GetOwinContext().Get <RecipeManagement>();
await recipeManagement.UpdateRecipe(model, User);
return(RedirectToAction("Details", new { model.Id, slug = model.Title.ToSlug() }));
}
public IActionResult CreateCookingRecipe()
{
CreateRecipeViewModel model = new CreateRecipeViewModel();
model.Cloudinary = this.cloudinaryService.GetCloudinaryInstance();
return(this.View(model));
}
public async Task <IActionResult> Create(CreateRecipeViewModel recipeViewModel, List <IFormFile> files)
{
var recipe = new Recipe();
if (ModelState.IsValid)
{
recipe.ApplicationUserId = _userManager.GetUserId(HttpContext.User);
var now = DateTime.Now;
recipe.CreatedAt = now;
recipe.UpdatedAt = now;
recipe.Name = recipeViewModel.Name;
recipe.Text = recipeViewModel.Text;
recipe.DetailedText = recipeViewModel.DetailedText;
recipe.TimeNeeded = recipeViewModel.TimeNeeded;
var tags = tagsRepository.GetAllTags().Where(tag => recipeViewModel.SelectedTags.Contains(tag.Id));
recipe.Tags = tags.Select(tag => new RecipeTag()
{
Recipe = recipe, Tag = tag
}).ToList();
recipe.Ingredients = new List <RecipeIngredient>();
foreach (var formFile in files)
{
if (formFile.Length > 0)
{
using (var fileStream = formFile.OpenReadStream())
using (var ms = new MemoryStream())
{
fileStream.CopyTo(ms);
var fileBytes = ms.ToArray();
string Image = Convert.ToBase64String(fileBytes);
recipe.Image = Image;
}
}
}
foreach (var pair in recipeViewModel.SelectedIngredient.Zip(recipeViewModel.SelectedIngredientAmount, (ingredient, amount) => new { ingredient, amount }))
{
var ingredient = ingredientsRepository.GetAllIngredients().FirstOrDefault(ing => ing.Id == pair.ingredient);
if (ingredient != null)
{
recipe.Ingredients.Add(new RecipeIngredient()
{
Recipe = recipe, Ingredient = ingredient, Amount = pair.amount
});
}
}
await recipesRepository.Add(recipe);
return(RedirectToAction("Index"));
}
ViewData["ApplicationUserId"] = new SelectList(usersRepository.GetAllUsers(), "Id", "Id", recipe.ApplicationUserId);
return(View(recipeViewModel));
}
// GET: Recipe/Create
public IActionResult Create()
{
CreateRecipeViewModel model = new CreateRecipeViewModel()
{
Units = dbContext.Units.OrderBy(u => u.Name).ToList()
};
return(View(model));
}
public ActionResult Create()
{
CreateRecipeViewModel model = new CreateRecipeViewModel()
{
Categories = this.GetCategories()
};
return(View(model));
}
public IActionResult Create(CreateRecipeViewModel viewModel)
{
if (!ModelState.IsValid)
{
return(View(viewModel));
}
_repository.AddRecipe(viewModel);
return(RedirectToAction("published", "Recipes"));
}
private async Task SetValues(RecipeAction from, CreateRecipeViewModel to)
{
var data = from.Get <CreateRecipeData>();
to.Recipes = new SelectList(await _recipeManager.GetRecipes(new RecipesQuery()
{
UserId = _userManager.GetUserId(User)
}), nameof(BtcTransmuter.Data.Entities.Recipe.Id), nameof(BtcTransmuter.Data.Entities.Recipe.Name), data.RecipeTemplateId);
to.RecipeTemplateId = data.RecipeTemplateId;
to.Enable = data.Enable;
to.RecipeId = from.RecipeId;
}
public IActionResult CreateRecipe(CreateRecipeViewModel vm)
{
var recipe = vm.Recipe;
recipe.CreatedAt = DateTime.Now;
recipe.UserId = userManager.GetUserId(User);
recipeService.CreateOrUpdateRecipe(recipe);
recipeService.AddIngredientsToRecipe(vm.ChosenIngredients, recipe.Id);
return(Json(recipe.Id));
}
public IActionResult Create(CreateRecipeViewModel createViewModel)
{
if (ModelState.IsValid)
{
var user = UserManager.GetUserId(User);
var recipe = createViewModel.FromCreateViewModel();
Service.Create(user, recipe);
return(RedirectToAction("Detailss", "Home", new { id = recipe.Id }));
}
return(RedirectToAction("Home"));
}
public IActionResult Create()
{
var vm = new CreateRecipeViewModel()
{
MealCategories = context.Categories.OrderBy(c => c.Name).ToList(),
Ingredients = context.Ingredients.OrderBy(i => i.Name).ToList(),
Recipe = new Recipe(),
ChosenIngredients = new List <IngredientInRecipe>()
};
return(View(vm));
}
public IActionResult Create(CreateRecipeViewModel model)
{
if (ModelState.IsValid)
{
var userId = _userManager.GetUserId(HttpContext.User);
string uniqueFileName = null;
if (model.Image != null)
{
string uploadFolder = Path.Combine("wwwroot", "images");
uniqueFileName = Guid.NewGuid().ToString() + "_" + model.Image.FileName;
string filePath = Path.Combine(uploadFolder, uniqueFileName);
using (var fileStream = new FileStream(filePath, FileMode.Create))
{
model.Image.CopyTo(fileStream);
}
}
Recipe newRecipe = new Recipe
{
Title = model.Title,
Description = model.Description,
Instructions = model.Instructions,
MealType = model.MealType,
Servings = model.Servings,
PrepTime = model.PrepTime,
CookTime = model.CookTime,
Category = model.Category,
SpiceLevel = model.SpiceLevel,
ApplicationUserId = userId,
ImagePath = uniqueFileName
};
_recipeRepository.AddRecipe(newRecipe);
foreach (var item in model.Ingredients)
{
Ingredient ingredient = new Ingredient
{
RecipeId = newRecipe.Id,
Measure = item.Measure,
Unit = item.Unit,
Name = item.Name
};
_ingredientRepository.AddIngredient(ingredient);
}
return(RedirectToAction("index", "home"));
}
return(View());
}
public IActionResult Edit(int id)
{
var vm = new CreateRecipeViewModel()
{
Ingredients = context.Ingredients.ToList(),
Recipe = recipeService.GetRecipe(id),
MealCategories = context.Categories.ToList(),
ChosenIngredients = context.IngredientsInRecipes.Where(i => i.RecipeId == id),
MealCategoryId = context.Recipes.FirstOrDefault(r => r.Id == id).Category.Id
};
return(View("Create", vm));
}
public async Task <ActionResult> Create(CreateRecipeViewModel model)
{
try
{
var recipeManagement = HttpContext.GetOwinContext().Get <RecipeManagement>();
await recipeManagement.CreateNewRecipe(model, User);
return(RedirectToAction("Index"));
}
catch
{
return(View());
}
}
public static Recipe FromCreateViewModel(this CreateRecipeViewModel createRecipeVieModel)
{
return(new Recipe
{
Id = createRecipeVieModel.Id,
Title = createRecipeVieModel.Title,
Directions = createRecipeVieModel.Directions,
Description = createRecipeVieModel.Description,
ImageUrl = createRecipeVieModel.ImageUrl,
Ingredients = createRecipeVieModel.Ingredients,
Country = createRecipeVieModel.Country,
Type = createRecipeVieModel.Type,
});
}
private bool IsModelValid(CreateRecipeViewModel model)
{
var category = this._appDbContext.Categories.FirstOrDefault(x => x.Id.ToString() == model.category);
var country = this._appDbContext.Countries.FirstOrDefault(x => x.Id.ToString() == model.country);
if (category != null && country != null && !string.IsNullOrEmpty(model.Description) && !string.IsNullOrEmpty(model.Topic) && !string.IsNullOrEmpty(model.CookingProcess))
{
return(true);
}
else
{
return(false);
}
}
// GET: Recipes/Edit/5
public async Task <ActionResult> Edit(int id)
{
var recipe = await UnitOfWork.Recipes.GetById(id);
var model = new CreateRecipeViewModel
{
Title = recipe.Title,
Id = recipe.Id,
Description = recipe.Description,
Picture = recipe.Picture
};
return(View(model));
}
public async Task <ActionResult> Edit(int id, CreateRecipeViewModel model)
{
try
{
// TODO: Add update logic here
model.Id = id;
var recipeManagement = HttpContext.GetOwinContext().Get <RecipeManagement>();
await recipeManagement.UpdateRecipe(model, User);
return(RedirectToAction("Details", new { id }));
}
catch
{
return(View());
}
}
public async Task <IActionResult> EditData(string identifier)
{
var result = await GetRecipeAction(identifier);
if (result.Error != null)
{
return(result.Error);
}
var vm = new CreateRecipeViewModel()
{
RecipeId = result.Data.RecipeId
};
await SetValues(result.Data, vm);
return(View(vm));
}
protected override async Task <(RecipeAction ToSave, CreateRecipeViewModel showViewModel)> BuildModel(
CreateRecipeViewModel viewModel, RecipeAction mainModel)
{
if (ModelState.IsValid)
{
mainModel.Set <CreateRecipeData>(viewModel);
return(mainModel, null);
}
viewModel.Recipes = new SelectList(
await _recipeManager.GetRecipes(new RecipesQuery()
{
UserId = _userManager.GetUserId(User)
}),
nameof(BtcTransmuter.Data.Entities.Recipe.Id), nameof(BtcTransmuter.Data.Entities.Recipe.Name),
viewModel.RecipeTemplateId);
return(null, viewModel);
}
public async Task CreateNewRecipe(CreateRecipeViewModel model, IPrincipal user)
{
var fileStorageService = new LocalFileStorageService();
var picturePath = fileStorageService.StoreFile(model.PictureFile);
// create model
var recipe = new Recipe()
{
Title = model.Title,
Description = model.Description,
Picture = picturePath,
AuthorId = user.Identity.GetUserId()
};
// insert model in the database
await UnitOfWork.Recipes.Add(recipe);
// save changes
await UnitOfWork.SaveChangesAsync();
}
public void CreateCookingRecipe(string creatorId, CreateRecipeViewModel viewModel)
{
var cookingRecipe = new CookingRecipe()
{
Title = viewModel.Title,
ShortDescription = viewModel.ShortDescription,
ExecutingTime = viewModel.ExecutingTime,
Products = viewModel.Products,
Content = viewModel.Content,
Hashtags = viewModel.Hashtags,
CreationDate = DateTime.UtcNow,
LastModifiedAt = DateTime.UtcNow,
CreatorId = creatorId,
CoverImageFileName = viewModel.CoverImageFileName,
};
var newCookingRecipeId = this.cookingRecipeRepo
.CreateCookingRecipeAsync(cookingRecipe)
.GetAwaiter().GetResult();
}
public IActionResult CreateRecipe([FromBody] CreateRecipeViewModel model)
{
if (IsModelValid(model))
{
this._appDbContext.Recipes.Add(new Recipe()
{
Category = this._appDbContext.Categories.FirstOrDefault(x => x.Id.ToString() == model.category),
Country = this._appDbContext.Countries.FirstOrDefault(x => x.Id.ToString() == model.country),
User = this._appDbContext.Users.FirstOrDefault(x => x.Id == model.uid),
Description = model.Description,
Topic = model.Topic,
CreationDate = DateTime.Now,
CookingProcess = model.CookingProcess,
});
this._appDbContext.SaveChanges();
return(Ok("Created!"));
}
else
{
return(BadRequest("INVALID!"));
}
}
public async Task <IActionResult> SaveRecipe(CreateRecipeViewModel recipe)
{
// Forward to login page if user not signed in
if (!User.IsSignedIn())
{
return(RedirectToAction("Login", "Account"));
}
using (var recipeManager = new RecipeManager())
{
// TODO Check to see if the save operation was successful
await recipeManager.SaveRecipeAsync(User.GetUserId(), recipe.RecipeName, recipe.RecipeText);
// Put user back on the homepage
var model = new HomeViewModel
{
Recipes = recipeManager.GetRecipesForUser(User.GetUserId())
};
return(View("Index", model));
}
}
public async Task <ActionResult> Create(CreateRecipeViewModel recipeViewModel)
{
if (ModelState.IsValid && recipeViewModel.Image != null)
{
await this._imgurService.UploadImage(recipeViewModel);
ApplicationUser user = await base._userManager.GetUserAsync(HttpContext.User);
recipeViewModel.UserId = user.Id;
this._recipeService.Add(this._mapper.Map <Recipe>(recipeViewModel));
return(RedirectToAction("Index", "Home"));
}
if (recipeViewModel.Image == null)
{
ModelState.AddModelError("Image", "The Image field is required.");
}
recipeViewModel.Categories = this.GetCategories();
return(View(recipeViewModel));
}
