public async virtual Task <IActionResult> DeleteAsync(int id)
{
if (!User.IsAuthorized(ResourceType))
{
return(Unauthorized());
}
var deleteResourceEvent = new DeleteResource <TResource>(id);
var cancelDelete = await _mediator.Send(deleteResourceEvent);
if (cancelDelete)
{
return(Forbid());
}
var delete = await _repository.DeleteAsync(id, UserID);
if (delete <= 0)
{
return(BadRequest());
}
_logger.LogResourceDeleted(ResourceType, id);
var resourceDeletedEvent = new ResourceDeleted <TResource>(id);
await _mediator.Publish(resourceDeletedEvent);
var resourcePersistedEvent = new ResourcePersisted <TResource>();
await _mediator.Publish(resourcePersistedEvent);
return(NoContent());
}
public async virtual Task <IActionResult> UpdateAsync(ResourceModel <TResource> resourceModel)
{
if (!User.IsAuthorized(ResourceType))
{
return(Unauthorized());
}
var updateResourceEvent = new UpdateResource <TResource>(resourceModel);
var context = await _mediator.Send(updateResourceEvent);
if (context != null)
{
resourceModel = context;
}
if (resourceModel.Errors.Any())
{
foreach (var error in resourceModel.Errors)
{
ModelState.AddModelError(error.Key, error.Value);
}
}
if (!ModelState.IsValid)
{
return(PartialView("_Editor", resourceModel));
}
var update = await _repository.UpdateAsync(resourceModel.Resource, UserID);
if (update <= 0)
{
return(BadRequest());
}
_logger.LogResourceUpdated(ResourceType, resourceModel.ID);
var updatedResource = await _repository.ReadAsync(resourceModel.ID);
var resourceUpdatedEvent = new ResourceUpdated <TResource>(updatedResource);
await _mediator.Publish(resourceUpdatedEvent);
var resourcePersistedEvent = new ResourcePersisted <TResource>();
await _mediator.Publish(resourcePersistedEvent);
var result = new ResourceModel <TResource>()
{
ID = resourceModel.ID,
Resource = updatedResource
};
return(PartialView("_Editor", result));
}
public async virtual Task <IActionResult> CreateAsync(ResourceModel <TResource> resourceModel)
{
if (!User.IsAuthorized(ResourceType))
{
return(Unauthorized());
}
var createResourceEvent = new CreateResource <TResource>(resourceModel);
var context = await _mediator.Send(createResourceEvent);
if (context != null)
{
resourceModel = context;
}
if (resourceModel.Errors.Any())
{
foreach (var error in resourceModel.Errors)
{
ModelState.AddModelError(error.Key, error.Value);
}
}
if (!ModelState.IsValid)
{
return(PartialView("_Editor", resourceModel));
}
int newResourceID = await _repository.CreateAsync(resourceModel.Resource, UserID);
if (newResourceID == 0)
{
return(NoContent());
}
_logger.LogResourceCreated(ResourceType, resourceModel.ID);
var resourceCreatedEvent = new ResourceCreated <TResource>(resourceModel.Resource);
await _mediator.Publish(resourceCreatedEvent);
var resourcePersistedEvent = new ResourcePersisted <TResource>();
await _mediator.Publish(resourcePersistedEvent);
var controllerName = ControllerContext.RouteData.Values["controller"].ToString();
return(Created(Url.Action("ReadAsync", controllerName, new { id = newResourceID }), newResourceID));
}
public async virtual Task <IActionResult> SetOrderAsync(ResourceOrderModel <TResource> resourceOrderModel)
{
if (!User.IsAuthorized(ResourceType))
{
return(Unauthorized());
}
var orderResourceEvent = new OrderResource <TResource>(resourceOrderModel);
var context = await _mediator.Send(orderResourceEvent);
if (context != null)
{
resourceOrderModel = context;
}
if (resourceOrderModel.Errors.Any())
{
foreach (var error in resourceOrderModel.Errors)
{
ModelState.AddModelError(error.Key, error.Value);
}
}
if (!ModelState.IsValid)
{
return(PartialView("_Order", resourceOrderModel));
}
var update = await _repository.SetOrderAsync(resourceOrderModel);
if (update <= 0)
{
return(BadRequest());
}
_logger.LogResourceOrdered(ResourceType);
var resourceOrderedEvent = new ResourceOrdered <TResource>();
await _mediator.Publish(resourceOrderedEvent);
var resourcePersistedEvent = new ResourcePersisted <TResource>();
await _mediator.Publish(resourcePersistedEvent);
return(Ok());
}
