public void UpdateStep1(RecipeStep step)
{
var allStepForRecipe = recipeAdapter.GetStepForRecipe(step.RecipeId);
var recipeToUpdate = allStepForRecipe.FirstOrDefault(r => r.Id == step.Id);
if (step.Order < recipeToUpdate.Order)
{
var stepsBetween = allStepForRecipe.Where(r => r.Order >= step.Order && r.Order < recipeToUpdate.Order);
foreach (var item in stepsBetween)
{
item.Order++;
recipeAdapter.UpdateStep(item.Id, item.Text, item.Order);
}
}
else
{
var stepsBetween = allStepForRecipe.Where(r => r.Order <= step.Order && r.Order > recipeToUpdate.Order);
foreach (var item in stepsBetween)
{
item.Order--;
recipeAdapter.UpdateStep(item.Id, item.Text, item.Order);
}
}
recipeAdapter.UpdateStep(step.Id, step.Text, step.Order);
}
public void UpdateStep(RecipeStep step)
{
var allStepForRecipe = recipeAdapter.GetStepForRecipe(step.RecipeId).ToList();
var recipeToUpdate = allStepForRecipe.FirstOrDefault(r => r.Id == step.Id);
bool isTextChanged = !string.IsNullOrEmpty(step.Text) && step.Text != recipeToUpdate.Text;
if (isTextChanged && step.Order == recipeToUpdate.Order)
{
recipeAdapter.UpdateStep(step.Id, step.Text);
return;
}
allStepForRecipe.OrderBy(s => s.Order);
allStepForRecipe.Remove(recipeToUpdate);
allStepForRecipe.Insert(step.Order - 1, recipeToUpdate);
int order = 1;
foreach (var item in allStepForRecipe)
{
item.Order = order++;
if (item.Id == recipeToUpdate.Id)
{
recipeAdapter.UpdateStep(step.Id, isTextChanged ? step.Text : null, step.Order);
continue;
}
recipeAdapter.UpdateStep(item.Id, order: item.Order);
}
}
public IActionResult CreateStep(RecipeStep s, bool addingIngredient)
{
if (ModelState.IsValid && !addingIngredient)
{
recipeStep.TempRequiredCookware = s.TempRequiredCookware;
recipeStep.TempSuggestedCookware = s.TempSuggestedCookware;
recipeStep.SeperateListStrings();
recipeStep.Instructions = s.Instructions;
recipeStep.IsTimer = s.IsTimer;
recipeStep.Timer = s.Timer;
recipeStep.TimerName = s.TimerName;
recipe.Steps.Add(recipeStep);
return(View("Create", recipe));
}
else if (addingIngredient)
{
recipeStep.TempRequiredCookware = s.TempRequiredCookware;
recipeStep.TempSuggestedCookware = s.TempSuggestedCookware;
recipeStep.SeperateListStrings();
recipeStep.Instructions = s.Instructions;
recipeStep.IsTimer = s.IsTimer;
recipeStep.Timer = s.Timer;
recipeStep.TimerName = s.TimerName;
recipeStep.TempRequiredCookware = s.TempRequiredCookware;
return(RedirectToAction("CreateIngredient", recipeStep));
}
else
{
return(View());
}
}
public async Task AddStepToRecipeAsync_Should_Add_Step()
{
//Arrange
List <Recipe> mockRecipeDB = GetRecipes();
List <RecipeStep> mockStepsDB = GetSteps();
Recipe target = new Recipe {
Id = 1, Name = "Recipe 1", Description = "desc1", CategoryId = 1, Steps = new List <RecipeStep>()
};
string newStep = "test step"; //stepnnumber = 1
_mockRepository.Setup(r => r.FirstOrDefaultAsync <Recipe>(It.IsAny <Expression <Func <Recipe, bool> > >()))
.ReturnsAsync(() => mockRecipeDB.SingleOrDefault(x => string.Equals(x.Name, target.Name, StringComparison.OrdinalIgnoreCase) && x.CategoryId == target.CategoryId && x.Id == target.Id));
_mockRepository.Setup(r => r.UpdateAsync <Recipe>(It.Is <Recipe>(x => x.Name == target.Name && x.Id == target.Id)))
.Callback((Recipe recipe) =>
{
RecipeStep toAdd = new RecipeStep {
Id = 1, Description = newStep, RecipeId = recipe.Id, StepNumber = recipe.Steps.Count + 1
};
mockStepsDB.Add(toAdd);
});
//Act
await _recipeStepController.AddStepToRecipeAsync(target, newStep);
//Assert
var retrieved = mockStepsDB.FirstOrDefault(x => x.Description == newStep);
_mockRepository.Verify(r => r.FirstOrDefaultAsync <Recipe>(It.IsAny <Expression <Func <Recipe, bool> > >()), Times.Once);
_mockRepository.Verify(r => r.UpdateAsync <Recipe>(It.Is <Recipe>(x => x.Name == target.Name && x.Id == target.Id)), Times.Once);
Assert.NotNull(retrieved);
}
public void When_UpdateRecipeStepLowToHight_Then()
{
var steps = GetSteps();
myRecipeDataAdapter.GetStepForRecipe(Arg.Any <Guid>()).Returns(steps);
var step = new RecipeStep
{
Id = steps[3].Id,
Order = 1
};
myService.UpdateStep(step);
var expectedResult = new Dictionary <Guid, int>
{
{ myStepId0, 2 },
{ myStepId1, 3 },
{ myStepId2, 4 },
{ myStepId3, 1 }
};
foreach (var item in steps)
{
myRecipeDataAdapter.Received().UpdateStep(item.Id, null, expectedResult[item.Id]);
}
}
public ActionResult AddStep(AddFoodStepViewModel addFoodStepViewModel)
{
if (ModelState.IsValid)
{
var ingredientSize = new RecipeStep()
{
Description = addFoodStepViewModel.Description,
Title = addFoodStepViewModel.Title,
Order = addFoodStepViewModel.Order,
RecipeID = addFoodStepViewModel.StebRecipeID
};
if (Request.Files.Count > 0)
{
ingredientSize.Image = new Image(Request.Files[0]);
}
var recipe = repository.GetRecipe(addFoodStepViewModel.StebRecipeID);
recipe.Steps.Add(ingredientSize);
repository.UpdateRecipe(recipe);
TempData["Message"] = $"Step added to {recipe.Title}";
}
return(RedirectToAction("Details", new { id = addFoodStepViewModel.StebRecipeID }));
}
public RecipeStep UpdateRecipeStep(RecipeStep recipeStep)
{
this.db.Attach(recipeStep);
this.db.Entry(recipeStep).State = EntityState.Modified;
this.db.SaveChanges();
return(recipeStep);
}
public RecipeStep Dequeue(string executionId)
{
if (!_appDataFolder.DirectoryExists(Path.Combine(_recipeQueueFolder, executionId)))
{
return(null);
}
RecipeStep recipeStep = null;
int stepIndex = GetFirstStepIndex(executionId);
if (stepIndex >= 0)
{
var stepPath = Path.Combine(_recipeQueueFolder, executionId + Path.DirectorySeparatorChar + stepIndex);
// string to xelement
var stepElement = XElement.Parse(_appDataFolder.ReadFile(stepPath));
var stepName = stepElement.Element("Name").Value;
recipeStep = new RecipeStep {
Name = stepName,
Step = stepElement.Element(stepName)
};
_appDataFolder.DeleteFile(stepPath);
}
if (stepIndex < 0)
{
_appDataFolder.DeleteFile(Path.Combine(_recipeQueueFolder, executionId));
}
return(recipeStep);
}
public static Recipe FromJson(Context context, JSONObject json) {
var recipe = new Recipe ();
try
{
recipe.TitleText = json.GetString(Constants.RecipeFieldTitle);
recipe.SummaryText = json.GetString(Constants.RecipeFieldSummary);
if (json.Has(Constants.RecipeFieldImage)) {
recipe.RecipeImage = json.GetString(Constants.RecipeFieldImage);
}
JSONArray ingredients = json.GetJSONArray(Constants.RecipeFieldIngredients);
recipe.IngredientsText = "";
for (int i = 0; i < ingredients.Length(); i++)
{
recipe.IngredientsText += " - " + ingredients.GetJSONObject(i).GetString(Constants.RecipeFieldText) + "\n";
}
JSONArray steps = json.GetJSONArray(Constants.RecipeFieldSteps);
for (int i = 0; i < steps.Length(); i++)
{
var step = steps.GetJSONObject(i);
var recipeStep = new RecipeStep();
recipeStep.StepText = step.GetString(Constants.RecipeFieldText);
if (step.Has(Constants.RecipeFieldName)) {
recipeStep.StepImage = step.GetString(Constants.RecipeFieldImage);
}
recipe.RecipeSteps.Add(recipeStep);
}
}
catch (Exception ex) {
Log.Error (Tag, "Error loading recipe: " + ex);
return null;
}
return recipe;
}
private void btnUpdateStep_Click(object sender, EventArgs e)
{
if (string.IsNullOrWhiteSpace(txtStepOrder.Text))
{
errProvider.SetError(txtStepOrder, "Please select the step you want to update.");
}
else if (string.IsNullOrWhiteSpace(txtStepDescription.Text))
{
errProvider.SetError(txtStepOrder, "");
errProvider.SetError(txtStepDescription, "Description must not be blank!");
}
else
{
errProvider.SetError(txtStepOrder, "");
errProvider.SetError(txtStepDescription, "");
int id = int.Parse(txtStepOrder.Text);
string description = txtStepDescription.Text;
string image = txtStepImage.Text;
RecipeStep updatedStep = new RecipeStep(id, description, image);
for (int i = 0; i < recipeSteps.Count; i++)
{
if (recipeSteps[i].Equals(updatedStep))
{
recipeSteps[i] = updatedStep;
break;
}
}
imagePaths["Step" + id] = tmpFilePath;
LoadAllSteps();
}
}
public async Task <bool> AddRecipeSteps(RecipeStep recipeStep)
{
_context.Add(recipeStep);
var saveResult = await _context.SaveChangesAsync();
return(saveResult == 1);
}
void Start()
{
_highlightedColor = new Color(0.937f, 0.741f, 0.42f);
_viewportActiveColor = new Color(0.56f, 0.67f, 0.85f);
_selectingColor = new Color(0.5f, 0.98f, 1f);
_baseColor = new Color(1f, 1f, 1f);
_buttons = new List <GameObject>();
active_timer_index = -1;
count = 0;
List <RecipeStep> steps = RecipeMenuList.SelectedRecipe.steps;
for (int i = 0; i < steps.Count; i++)
{
GameObject button = Instantiate(buttonTemplate);
button.SetActive(true);
Image buttonImage = button.GetComponent <Image>();
buttonImage.color = i == 0 ? _highlightedColor : _baseColor;
int stepNumber = i + 1;
RecipeStep step = steps[i];
button.GetComponent <StepListButton>().SetText(" " + stepNumber + ". " + step.instruction);
button.transform.SetParent(buttonTemplate.transform.parent, false);
_buttons.Add(button);
}
}
public async Task AddStepToRecipeAsync(Recipe recipe, string description)
{
string errorMessage = "";
if (recipe == null)
{
errorMessage = "Recipe reference is null.";
Logger.LogError(errorMessage);
throw new ArgumentNullException(errorMessage);
}
if (description.IsNullOrEmpty())
{
errorMessage = "Step Description is empty.";
Logger.LogError(errorMessage);
throw new EmptyFieldException(errorMessage);
}
var checkRecipe = (await UnitOfWork.Repository.FirstOrDefaultAsync <Recipe>(x => x.Name.ToLower() == recipe.Name.ToLower() && x.CategoryId == recipe.CategoryId && x.Id == recipe.Id));
if (checkRecipe == null)
{
errorMessage = $"Recipe {recipe.Name} : {recipe.Id} doesn't exist in Database.";
Logger.LogError(errorMessage);
throw new EntryAlreadyExistsException(errorMessage);
}
var recipeStep = new RecipeStep()
{
RecipeId = checkRecipe.Id, Description = description, StepNumber = checkRecipe.Steps.Count + 1
};
checkRecipe.Steps.Add(recipeStep);
await UnitOfWork.Repository.UpdateAsync <Recipe>(checkRecipe);
}
public IHttpActionResult PutRecipeStep(int id, RecipeStep recipeStep)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != recipeStep.ID)
{
return(BadRequest());
}
db.Entry(recipeStep).State = EntityState.Modified;
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!RecipeStepExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public RecipeStep GetRecipeStep(byte tubeIndex, int stepIndex)
{
//add validation
RecipeStep step = RecipeService.Instance.GetRecipeStep(stepIndex);
return(step);
}
public RecipeStep Dequeue(string executionId)
{
Logger.Information("Dequeuing recipe steps.");
if (!_appDataFolder.DirectoryExists(Path.Combine(_recipeQueueFolder, executionId)))
{
return(null);
}
RecipeStep recipeStep = null;
int stepIndex = GetFirstStepIndex(executionId);
if (stepIndex >= 0)
{
var stepPath = Path.Combine(_recipeQueueFolder, executionId + Path.DirectorySeparatorChar + stepIndex);
// string to xelement
var stepElement = XElement.Parse(_appDataFolder.ReadFile(stepPath));
var stepName = stepElement.Element("Name").Value;
var stepId = stepElement.Attr("Id");
var recipeName = stepElement.Attr("RecipeName");
Logger.Information("Dequeuing recipe step '{0}'.", stepName);
recipeStep = new RecipeStep(id: stepId, recipeName: recipeName, name: stepName, step: stepElement.Element(stepName));
_appDataFolder.DeleteFile(stepPath);
}
if (stepIndex < 0)
{
_appDataFolder.DeleteFile(Path.Combine(_recipeQueueFolder, executionId));
}
return(recipeStep);
}
public async Task <ActionResult <RecipeStep> > PostRecipeStep(RecipeStep recipeStep)
{
_context.RecipeSteps.Add(recipeStep);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetRecipeStep", new { id = recipeStep.Id }, recipeStep));
}
public async Task <IActionResult> PutRecipeStep(int id, RecipeStep recipeStep)
{
if (id != recipeStep.Id)
{
return(BadRequest());
}
_context.Entry(recipeStep).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!RecipeStepExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
/// <summary>
/// Gets the list of steps related to the recipe with the given ID
/// </summary>
/// <param name="recipeId">
/// the ID for the recipe to get steps for
/// </param>
/// <returns>
/// a list of the steps for the related recipe
/// </returns>
public static ObservableCollection <RecipeStep> getSteps(long recipeId)
{
ObservableCollection <RecipeStep> savedSteps = new ObservableCollection <RecipeStep>();
SqliteConnection db = new SqliteConnection("Filename=RecipeBook.db");
db.Open();
SqliteCommand selectCommand = new SqliteCommand("SELECT * from STEPS WHERE RID = " + recipeId +
" ORDER BY STEPORDER ASC", db);
SqliteDataReader query = selectCommand.ExecuteReader();
while (query.Read())
{
long id = query.GetInt64(0);
int order = query.GetInt32(1);
String description = query.GetString(2);
long rid = query.GetInt64(3);
RecipeStep savedStep = new RecipeStep(id, order, description);
savedStep.setRecipeId(rid);
savedSteps.Add(savedStep);
}
db.Close();
return(savedSteps);
}
public static RecipeStep FromBundle(Bundle bundle)
{
var recipeStep = new RecipeStep();
recipeStep.StepText = bundle.GetString(Constants.RecipeFieldStepText);
recipeStep.StepImage = bundle.GetString(Constants.RecipeFieldStepImage);
return(recipeStep);
}
public ActionResult DeleteConfirmed(int id)
{
RecipeStep recipeStep = db.RecipeSteps.Find(id);
db.RecipeSteps.Remove(recipeStep);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public static Pipe <R> WhenRecipe <T, R>(this Pipe <T> pipe, RecipeStep <T, R> recipeStepFunc)
{
if (recipeStepFunc == null)
{
throw new ArgumentNullException(nameof(recipeStepFunc));
}
return(recipeStepFunc(new Recipe <T, R>(pipe, Step.When)));
}
public async Task DeleteStepByIdAsync(int stepId)
{
RecipeStep toDelete = await UnitOfWork.Repository.GetByIdAsync <RecipeStep>(stepId);
if (toDelete == null)
{
throw new EntryNotFoundException("This step doesn't exist in database.");
}
await UnitOfWork.Repository.DeleteAsync <RecipeStep>(toDelete);
}
public void GivenRecipe_OfUnitRecipeStepFuncNull_ThrowsArgNullException()
{
RecipeStep <Unit, int> stepFunc = null;
Action call = () => GivenRecipe(stepFunc);
call.Should().ThrowExactly <ArgumentNullException>()
.Which
.ParamName.Should().Be("recipeStepFunc");
}
public RecipeStepViewModel(RecipeViewModel recipeDisplay, RecipeStep step, bool isDone)
{
if (step is null)
{
throw new ArgumentNullException(nameof(step));
}
RecipeDisplay = recipeDisplay;
RecipeStep = step;
_isDone = isDone;
}
public ActionResult Edit([Bind(Include = "Id,StepNo,StepDesc,RecipeId")] RecipeStep recipeStep)
{
if (ModelState.IsValid)
{
db.Entry(recipeStep).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.RecipeId = new SelectList(db.RecipeModels, "Id", "Description", recipeStep.RecipeId);
return(View(recipeStep));
}
public static Pipe <R> GivenRecipe <R>(RecipeStep <Unit, R> recipeStepFunc)
{
if (recipeStepFunc == null)
{
throw new ArgumentNullException(nameof(recipeStepFunc));
}
var pipe = Runner.CreatePipe();
return(recipeStepFunc(new Recipe <Unit, R>(pipe, Step.Given)));
}
public IHttpActionResult GetRecipeStep(int id)
{
RecipeStep recipeStep = db.RecipeSteps.Find(id);
if (recipeStep == null)
{
return(NotFound());
}
return(Ok(recipeStep));
}
public void SearchUstencils(RecipeStep step, int backX, int backY)
{
this.Sprite.Move(materialStock.Sprite.PositionX, materialStock.Sprite.PositionY);
for (int i = 0; i < step.ListUstencils.Count; i++)
{
step.ListUstencils.ElementAt(i).getMaterial();
}
Thread.Sleep(100);
this.Sprite.Move(backX, backY);
}
public void GivenRecipe_OfScenarioScenarioNull_ThrowsArgNullException()
{
RecipeStep <Scenario, int> stepFunc = null;
Scenario scenario = null;
Action call = () => scenario.GivenRecipe(RecipeStepReturnsDefault <Scenario, int>(GivenStepTitle));
call.Should().ThrowExactly <ArgumentNullException>()
.Which
.ParamName.Should().Be("scenario");
}
public IHttpActionResult PostRecipeStep(RecipeStep recipeStep)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
db.RecipeSteps.Add(recipeStep);
db.SaveChanges();
return(CreatedAtRoute("DefaultApi", new { id = recipeStep.ID }, recipeStep));
}
public static RecipeStep FromBundle(Bundle bundle) {
var recipeStep = new RecipeStep ();
recipeStep.StepText = bundle.GetString (Constants.RecipeFieldStepText);
recipeStep.StepImage = bundle.GetString (Constants.RecipeFieldStepImage);
return recipeStep;
}
