public async Task <IActionResult> Post([FromBody] RecipeHistory recipeHistory)
{
var recipe = await this._recipeRepository.GetRecipe(recipeHistory.RecipeId);
if (recipe == null)
{
return(new NotFoundResult());
}
foreach (var medicine in recipeHistory.Sold)
{
var rec = recipe.RecipeItems.Where(med => med.MedicineId == medicine.MedicineId).First();
if (rec.LeftCount < medicine.Count)
{
return(new StatusCodeResult(StatusCodes.Status400BadRequest));
}
else
{
rec.LeftCount -= medicine.Count;
}
}
var response = await this._recipeRepository.Update(recipe);
if (!response)
{
return(new StatusCodeResult(StatusCodes.Status400BadRequest));
}
return(new OkObjectResult(recipeHistory));
}
/// <summary>
/// Updates the recipe history.
/// </summary>
/// <param name="recipeHistory">The recipe history.</param>
/// <returns>Returns a task whose result is true if update was succeed.</returns>
public async Task <bool> Update(RecipeHistory recipeHistory)
{
ReplaceOneResult updateResult = await this._context
.RecipeHistories
.ReplaceOneAsync(filter : r => r.Id == recipeHistory.Id, replacement : recipeHistory);
return(updateResult.IsAcknowledged && updateResult.ModifiedCount > 0);
}
/// <summary>
/// Executes command operation.
/// </summary>
/// <param name="parameter">Command parameter.</param>
public async override void Execute(object parameter)
{
if (!this._isDoneAvailable)
{
return;
}
this._isDoneAvailable = false;
this.viewModel.SetVisibilities(Visibility.Visible, true);
var dictionary = App.Current.Resources;
try
{
var historyItems = (IEnumerable <RecipeHistoryItem>) this.viewModel.HistoryItems;
var response = await((App)App.Current).UserApiClient.GetPharmacistByIdAsync(User.Default.Id);
if (response.Status == Status.Error)
{
RecipeMessageBox.Show((string)dictionary["pharmacy_find_fail"]);
return;
}
var pharmacyId = response.Result.PharmacyId;
var recipeHistory = new RecipeHistory
{
CreatedOn = DateTime.Now,
RecipeId = this.viewModel.Recipe.First().Id,
PharmacyId = pharmacyId,
Sold = historyItems.ToList <RecipeHistoryItem>()
};
var sellResponse = await this.ExecuteAsync(recipeHistory);
this.viewModel.Start();
this.viewModel.Recipe = null;
this.viewModel.RecipeId = null;
if (!sellResponse.IsSuccessStatusCode)
{
RecipeMessageBox.Show((string)dictionary["sell_medicines_fail"]);
return;
}
RecipeMessageBox.Show((string)dictionary["sell_medicines_success"]);
}
catch
{
RecipeMessageBox.Show((string)dictionary["recipe_unknown_error"]);
}
finally
{
this._isDoneAvailable = true;
this.viewModel.SetVisibilities(Visibility.Collapsed, false);
}
}
internal RecipeDto EntityToDto(RecipeHistory recipeEntity)
{
RecipeDto recipeDto = EntityToDtoBase(recipeEntity);
recipeDto.RecipeId = recipeEntity.RecipeId;
recipeDto.Versions = null;
return(recipeDto);
}
public async Task DeleteAsync(RecipeHistory item)
{
var query = "delete from recipe_histories where id = @id";
using (var connection = await CreateConnection())
{
await connection.ExecuteAsync(query, new { id = item.ID });
}
}
public async Task <IActionResult> Put(string id, [FromBody] RecipeHistory recipeHistory)
{
var dbRecipeHistory = await this._recipeHistoryRepository.GetRecipeHistory(id);
if (dbRecipeHistory == null)
{
return(new NotFoundResult());
}
recipeHistory.Id = dbRecipeHistory.Id;
await this._recipeHistoryRepository.Update(recipeHistory);
return(new OkObjectResult(recipeHistory));
}
public override Task <int> SaveChangesAsync()
{
var modifiedEntries = ChangeTracker.Entries().Where(x => x.State == EntityState.Modified);
foreach (var modifiedEntry in modifiedEntries.Where(x => x.Entity.GetType() == typeof(Recipe)))
{
RecipeHistory history = CreateHistoryRecord(modifiedEntry.Entity as Recipe, modifiedEntry);
if (history != null)
{
RecipesHistory.Add(history);
}
}
return(base.SaveChangesAsync());
}
public RecipeHistory Create(RecipeHistory item)
{
var query =
@"insert into recipe_histories (version, fulltext, createdby, modifiedby) values ( @version, @fulltext, @createdby, @modifiedby) returning *";
var record = new
{
version = item.Version,
fulltext = item.FullText,
createdby = item.CreatedBy,
modifiedby = item.ModifiedBy
};
using (var connection = CreateConnectionSynchronous())
{
return(connection.QuerySingle <RecipeHistory>(query, record));
}
}
public async Task <RecipeHistory> UpdateAsync(RecipeHistory item)
{
var query =
@"update recipe_histories set recipeid = @recipeid, modifiedby = @modifiedby, modifieddate = now() where id = @id returning *";
var record = new
{
id = item.ID,
recipeid = item.RecipeID,
createdby = item.CreatedBy,
modifiedby = item.ModifiedBy
};
using (var connection = await CreateConnection())
{
return(await connection.QuerySingleAsync <RecipeHistory>(query, record));
}
}
public async Task <ParserResult> ParseFull(string input)
{
var output = RecipeParser.Parse(input);
var recipeHistory = new RecipeHistory
{
FullText = input,
CreatedBy = await SecurityService.GetCurrentUserName(),
ModifiedBy = await SecurityService.GetCurrentUserName(),
Version = 1
};
var history = RecipeHistoryRepository.Create(recipeHistory);
await RecipeHistoryRepository.UpdateSearchIndex(history.ID);
output.Output.FullTextReference = history.ID;
return(output);
}
public async Task <RecipeHistory> CreateAsync(RecipeHistory item)
{
var query =
@"insert into recipe_histories (recipeid, version, fulltext, document, createdby, modifiedby) values (@recipeid, @version, @fulltext, to_tsvector(@fulltext), @createdby, @modifiedby) returning *";
var record = new
{
recipeid = item.RecipeID,
version = item.Version,
fulltext = item.FullText,
createdby = item.CreatedBy,
modifiedby = item.ModifiedBy
};
using (var connection = await CreateConnection())
{
return(await connection.QuerySingleAsync <RecipeHistory>(query, record));
}
}
private RecipeHistory CreateHistoryRecord(Recipe recipe, DbEntityEntry modifiedEntry)
{
RecipeHistory history = null;
try
{
history = new RecipeHistory
{
RecipeId = recipe.Id,
Title = modifiedEntry.OriginalValues["Title"].ToString(),
CookTime = (int)modifiedEntry.OriginalValues["CookTime"],
Description = modifiedEntry.OriginalValues["Description"].ToString(),
Ingredients = modifiedEntry.OriginalValues["Ingredients"].ToString(),
StepDetails = modifiedEntry.OriginalValues["StepDetails"].ToString(),
CreationDate = (DateTime)modifiedEntry.OriginalValues["CreationDate"]
};
}
catch (Exception ex)
{
Debug.WriteLine("Failed to create history record");
}
return(history);
}
/// <summary>
/// Creates a new recipe history.
/// </summary>
/// <param name="recipeHistory">A new recipe history.</param>
/// <returns>Returns a task.</returns>
public async Task Create(RecipeHistory recipeHistory)
{
await this._context.RecipeHistories.InsertOneAsync(recipeHistory);
}
