public async Task <IActionResult> PutAsync(int id, [FromBody] SaveCategoryResource resource)
{
var category = mapper.Map <SaveCategoryResource, Category>(resource);
var result = await categoryService.UpdateAsync(id, category);
return(result.ToHttpResponse());
}
public async Task <IActionResult> PostAsync([FromBody] SaveCategoryResource resource)
{
try
{
Log.Logger.Information("Add new category {@resource} was executed", resource);
var category = _mapper.Map <SaveCategoryResource, Category>(resource);
var result = await _categoryService.SaveAsync(category);
if (!result.Success)
{
return(BadRequest(new ErrorResource(result.Message)));
}
var categoryResource = _mapper.Map <Category, CategoryResource>(result.Resource);
Log.Logger.Information("Category {@resource} added successfully", categoryResource);
return(Ok(categoryResource));
}
catch (Exception ex)
{
Log.Logger.Error(ex, "Error trying to add new category: {@resource}. Error: {error}", resource, ex.Message);
return(BadRequest(ex.Message));
}
}
public IActionResult SaveCategory([FromBody] SaveCategoryResource resource)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.GetErrorMessages()));
}
var category = _mapper.Map <SaveCategoryResource, Category>(resource);
var result = _categoryService.SaveCategory(category);
if (!result.Success)
{
return(BadRequest(result.Success));
}
var categoryResource = _mapper.Map <Category, CategoryResource>(result.Category);
return(Ok(categoryResource));
}
catch (Exception e)
{
_logger.LogInformation(e, "An error occurred when saving the category");
return(ValidationProblem(e.Message));
}
}
public async Task <IActionResult> PostAsync([FromBody] SaveCategoryResource resource)
{
var category = this.mapper.Map <SaveCategoryResource, Category>(resource);
var result = await this.categoryService.SaveAsync(category);
return(result.ToHttpResponse());
}
public IActionResult UpdateCategory(Guid id, [FromBody] SaveCategoryResource resource)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.GetErrorMessages()));
}
var category = _mapper.Map <SaveCategoryResource, Category>(resource);
var result = _categoryService.UpdateCategory(id, category);
if (result == null || !result.Success)
{
return(NotFound());
}
var categoryResource = _mapper.Map <Category, CategoryResource>(result.Category);
// Updating Id in case of update
categoryResource.Id = id;
return(Ok(categoryResource));
}
catch (Exception e)
{
_logger.LogInformation(e, "An error occurred when saving the category");
return(ValidationProblem(e.Message));
}
}
public async Task <ActionResult <CategoryResource> > UpdateCategory(int id, [FromBody] SaveCategoryResource SaveCategoryResource)
{
var validator = new SaveCategoryResourceValidator();
var validationResult = await validator.ValidateAsync(SaveCategoryResource);
if (!validationResult.IsValid)
{
return(BadRequest(validationResult.Errors));
}
var categoryToBeUpdated = await _categoryService.GetCategoryById(id);
if (categoryToBeUpdated == null)
{
return(NotFound());
}
var Category = _mapper.Map <SaveCategoryResource, Category>(SaveCategoryResource);
await _categoryService.UpdateCategory(categoryToBeUpdated, Category);
var updatedCategory = await _categoryService.GetCategoryById(id);
var updatedCategoryResource = _mapper.Map <Category, CategoryResource>(updatedCategory);
return(Ok(updatedCategoryResource));
}
public async Task <IActionResult> PostAsync([FromBody] SaveCategoryResource resource)
{
// Use the built in MVC Model Binding to get any errors from the request,
// call extension to extract message strings
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.GetErrorMessages()));
}
// Map the save category request to a Category entity
var category = _mapper.Map <SaveCategoryResource, Category>(resource);
// now actually attempt to save the new category to the db
var result = await _categoryService.SaveAsync(category);
// no success return the error message
if (!result.Success)
{
return(BadRequest(result.Message));
}
// if success map the category entity back to a resource we want the front end to use
var categoryResource = _mapper.Map <Category, CategoryResource>(result.Category);
// return ok
return(Ok(categoryResource));
}
public async Task <IActionResult> PostAsync([FromBody] SaveCategoryResource resource)
{
if (ModelState.IsValid)
{
return(BadRequest(ModelState.GetErrorMessages()));
}
}
public async Task <IActionResult> PutAsync(int id, [FromBody] SaveCategoryResource resource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.GetErrorMessages()));
}
//Json example.
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
var jsonString = JsonConvert.SerializeObject(resource);
var backToResource = JsonConvert.DeserializeObject <SaveCategoryResource>(jsonString);
stopwatch.Stop();
Console.WriteLine("Time elapsed for old Json: {0:hh\\:mm\\:ss}", stopwatch.Elapsed);
var category = _mapper.Map <SaveCategoryResource, Category>(resource);
var result = await _categoryService.UpdateAsync(id, category);
if (!result.Success)
{
return(BadRequest(result.Message));
}
var categoryResource = _mapper.Map <Category, CategoryResource>(result.Category);
return(Ok(categoryResource));
}
public async Task <IActionResult> PostAsync([FromBody] SaveCategoryResource resource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.GetErrorMessages()));
}
var category = _mapper.Map <SaveCategoryResource, Category>(resource);
}
public async Task <IActionResult> PutAsync(int id, [FromBody] SaveCategoryResource resource)
{
var appoint = _mapper.Map <SaveCategoryResource, Category>(resource);
var result = await _categoryService.UpdateAsync(id, appoint);
if (!result.Success)
{
return(BadRequest(result.Message));
}
var mTaskResource = _mapper.Map <Category, CategoryResource>(result.Resource);
return(Ok(mTaskResource));
}
public async Task <IActionResult> DeleteAsync(int id, [FromBody] SaveCategoryResource resource)
{
var result = await _categoryService.DeleteAsync(id);
if (!result.Success)
{
return(BadRequest(result.Message));
}
var categoryResource = _mapper.Map <Category, CategoryResource>(result.Category);
return(Ok(categoryResource));
}
public async Task<IActionResult> PutAsync(int id, [FromBody] SaveCategoryResource resource)
{
if (!ModelState.IsValid)
return BadRequest(ModelState.GetErrorMessages());
var category = _mapper.Map<SaveCategoryResource, Category>(resource);
var result = await _categoryService.UpdateAsync(id, category);
if (!result.Success)
return BadRequest(result.Message);
var categoryResource = _mapper.Map<Category, CategoryResource>(result.Category);
return Ok(categoryResource);
}
public async Task <IActionResult> PutAsync(int id, [FromBody] SaveCategoryResource resource)
{
var category = _mapper.Map <SaveCategoryResource, Category>(resource);
var result = await _categoryService.UpdateAsync(id, category);
if (!result.Success)
{
return(result.GetResponse());
}
var categoryResource = _mapper.Map <Category, CategoryResource>(result.Category);
return(Ok(categoryResource));
}
public async Task <IActionResult> PutAsync(int id, [FromBody] SaveCategoryResource resource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.GetErrorMessages()));
}
var category = _mapper.Map <SaveCategoryResource, Category>(resource);
await _categoryRepo.Update(category);
//var categoryResource = _mapper.Map<Category, CategoryResource>(result.Category);
return(Ok());
}
public async Task <IActionResult> PostAsync([FromBody] SaveCategoryResource resource)
{
var category = _mapper.Map <SaveCategoryResource, Category>(resource);
var result = await _categoryService.SaveAsync(category);
if (!result.Success)
{
return(BadRequest(new ErrorResource(result.Message)));
}
var categoryResource = _mapper.Map <Category, CategoryResource>(result.Resource);
return(Ok(categoryResource));
}
public async Task <IActionResult> PutAsync(int id, SaveCategoryResource resource)
{
var category = _mapper.Map <Category>(resource);
var response = await _categoryService.UpdateAsync(id, category);
if (!response.Success)
{
return(BadRequest(response));
}
var categoryResource = _mapper.Map <CategoryResource>(response.Category);
return(Ok(categoryResource));
}
public async Task <IActionResult> PutAsync(int id, [FromBody] SaveCategoryResource resource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.GetErrorMessages()));
}
var category = mapper.Map <SaveCategoryResource, Category>(resource);
var categoryResponse = await categoryService.UpdateAsync(id, category);
var categoryResource = mapper.Map <Category, CategoryResource>(categoryResponse.Category);
var result = categoryResponse.GetResponseResult(categoryResource);
return(Ok(result));
}
public async Task <IActionResult> PostAsync([FromBody] SaveCategoryResource resource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.GetErrorMessages()));
}
var category = _mapper.Map <SaveCategoryResource, Category>(resource);
var result = await _categoryServices.SaveAsync(category);
if (!result.Success)
{
return(BadRequest(result.Message));
}
var categoryResult = _mapper.Map <Category, CategoryResource>(result.Category);
return(Ok(categoryResult));
}
public async Task <IActionResult> PostAsync([FromBody] SaveCategoryResource resource)
{
if (!ModelState.IsValid)
{
//TODO:ErrValid
var category = _mapper.Map <SaveCategoryResource, Category>(resource);
}
if (!result.Success)
{
//TODO:ErrValid
var categoryResource = _mapper.Map <Category, CategoryResource>(result.Category);
}
return(Ok(categoryResource));
}
public async Task <IActionResult> PutAsync(int id, [FromBody] SaveCategoryResource resource)
{
if (!ModelState.IsValid)
{
//TODO:ErrValid
var category = _mapper.Map <SaveCategoryResource, Category>(resource);
}
var result = await _categoryService.UpdateAsync(id, category);
if (!result.Success)
{
//TODO:ErrValid
var categoryResource = _mapper.Map <Category, CategoryResource>(result.Category);
}
return(Ok(categoryResource));
}
public async Task <IActionResult> PutAsync(int id, [FromBody] SaveCategoryResource resource, CancellationToken cancellationToken)
{
if (!ModelState.IsValid)
{
return(BadRequest(new ErrorResource("invalid request")));
}
var category = _mapper.Map <SaveCategoryResource, Category>(resource);
var result = await _categoryService.UpdateAsync(id, category, cancellationToken);
if (!result.Success)
{
return(BadRequest(new ErrorResource(result.Message)));
}
var categoryResource = _mapper.Map <Category, CategoryResource>(result.Resource);
return(Ok(categoryResource));
}
public async Task <IActionResult> CreateAsync([FromBody] SaveCategoryResource resource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.GetErrorMessages()));
}
var category = mapper.Map <SaveCategoryResource, Category>(resource);
var result = await categoryService.SaveAsync(category);
if (!result.Success)
{
return(BadRequest(result.Message));
}
var categoryResource = mapper.Map <Category, CategoryForm>(result.Category);
return(Created($"/api/categories/{categoryResource.Id}", categoryResource));
}
public async Task <IActionResult> PutAsync(int id, [FromBody] SaveCategoryResource resource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.GetErrorMessages()));
}
var resources = _mapper.Map <SaveCategoryResource, Category>(resource);
var result = await _categoryService.UpdateCategoryAsync(id, resources);
//check if response is successful
if (!result._isSuccessful)
{
return(BadRequest(result._message));
}
//map
var CategoryResource = _mapper.Map <Category, CategoryResource>(result.Category);
return(Ok(CategoryResource));
}
public async Task <IActionResult> UpdateCategoryAsync(long id, [FromBody] SaveCategoryResource categoryResource)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var category = _mapper.Map <SaveCategoryResource, Category>(categoryResource);
var result = await _categoryService.UpdateCategoryAsync(id, category);
if (!result.Success)
{
return(BadRequest(result.Message));
}
var resource = _mapper.Map <Category, CategoryResource>(result.Category);
return(Ok(resource));
}
public async Task <IActionResult> PostAsync([FromBody] SaveCategoryResource resource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.GetErrorMessages()));
}
var category = _mapper.Map <SaveCategoryResource, Category>(resource);
var result = await _categoryService.SaveAsync(category);
if (!result.Success)
{
return(BadRequest(result.Message));
}
var categoryResource = (List <CategoryResource>)_mapper.Map <IEnumerable <Category>, IEnumerable <CategoryResource> >(result.Category);
return(CreatedAtRoute("NewCategory", new { id = categoryResource[0].Id.ToString() }, categoryResource));
//return Ok(categoryResource);
}
public async Task <IActionResult> PostAsync([FromBody] SaveCategoryResource resource)
{
// if (!ModelState.IsValid)
// {
// Console.WriteLine("Bad model state\n");
// return BadRequest(ModelState.GetErrorMessages());
// }
var category = _mapper.Map <SaveCategoryResource, Category>(resource);
var result = await _categoryService.SaveAsync(category);
if (!result.Success)
{
return(BadRequest(result.Message));
}
var categoryResource = _mapper.Map <Category, CategoryResource>(result.Category);
return(Ok(categoryResource));
}
public async Task <ActionResult <CategoryResource> > CreateCategory([FromBody] SaveCategoryResource SaveCategoryResource)
{
var validator = new SaveCategoryResourceValidator();
var validationResult = await validator.ValidateAsync(SaveCategoryResource);
if (!validationResult.IsValid)
{
return(BadRequest(validationResult.Errors));
}
var categoryToCreate = _mapper.Map <SaveCategoryResource, Category>(SaveCategoryResource);
var newCategory = await _categoryService.CreateCategory(categoryToCreate);
var Category = await _categoryService.GetCategoryById(newCategory.Id);
var CategoryResource = _mapper.Map <Category, CategoryResource>(Category);
return(Ok(CategoryResource));
}
public async Task <IActionResult> PutAsync(int id, [FromBody] SaveCategoryResource resource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.GetErrorMessages()));
}
var category = _mapper.Map <SaveCategoryResource, Category> (resource);
var result = await _categoryService.UpdateAsync(id, category);
_logger.LogInformation($"This is the result for put {result}");
if (!result._success)
{
return(BadRequest(result._message));
}
var categoryResource = _mapper.Map <Category, CategoryResource> (result.Category);
return(Ok(categoryResource));
}
public void PostNewCategoryBadRequestTest()
{
var saveCategoryResource = new SaveCategoryResource()
{
Name = "Beer"
};
var categoryResource = new CategoryResource()
{
Name = "Beer"
};
var categoryResponse = new Mock <CategoryResponse>("Error trying to create Category");
categoryService.Setup(p => p.SaveAsync(It.IsAny <Category>())).ReturnsAsync(categoryResponse.Object);
// Act
var badResult = categoryController.PostAsync(saveCategoryResource);
// Assert
Assert.IsType <BadRequestObjectResult>(badResult.Result);
}
