public async Task <IActionResult> Search([FromBody] SearchRequest <EventModelDTO> genericRequestDTO = null)
{
try
{
if (genericRequestDTO == null)
{
genericRequestDTO = new SearchRequest <EventModelDTO>();
}
SearchRequest <EventModel> genericRequest = this._mapper.Map <SearchRequest <EventModel> >(genericRequestDTO);
ResultHandler <IAsyncEnumerable <EventModel> > getResultHandler = this._eventsService.Get(genericRequest.Filters, genericRequest.OrderBy, genericRequest.IncludeProperties);
if (getResultHandler.Success)
{
List <EventModelDTO> result = new List <EventModelDTO>();
await foreach (EventModel eventModel in getResultHandler.Value)
{
EventModelDTO eventModelDTO = this._mapper.Map <EventModelDTO>(eventModel);
result.Add(eventModelDTO);
}
return(Ok(result));
}
else
{
return(StatusCode(500, getResultHandler.ErrorCode));
}
}
catch (Exception ex)
{
this._log.LogError(ex, "EventsController.Get");
return(StatusCode(500, ErrorCode.Exception));
}
}
public async Task <IActionResult> GetById(Guid id)
{
try
{
if (id == Guid.Empty)
{
return(BadRequest(ModelState));
}
ResultHandler <EventModel> result = await this._eventsService.GetById(id);
if (result.Success)
{
EventModel eventModel = result.Value as EventModel;
EventModelDTO eventModelDTO = this._mapper.Map <EventModelDTO>(eventModel);
return(Ok(eventModelDTO));
}
else if (result.ErrorCode == ErrorCode.EntityNotFound)
{
return(NotFound($"Not found entity with Id: {id}"));
}
else
{
return(StatusCode(500, result.ErrorCode));
}
}
catch (Exception ex)
{
this._log.LogError(ex, "EventsController.Get");
return(StatusCode(500, ErrorCode.Exception));
}
}
public async Task GetById_WhenCalled_ShouldReturnOk(string access_token)
{
try
{
// Arrange
this._expectedItem = TestsFacade.EventsFacade.BuildEventModels().First();
_context.Events.Add(this._expectedItem);
await _context.SaveChangesAsync();
HttpMethod httpMethod = HttpMethod.Get;
Uri uri = new Uri($"http://localhost/api/events/getbyid?id={_expectedItem.Id}");
HttpRequestMessage httpRequestMessage = new HttpRequestMessage(httpMethod, uri);
httpRequestMessage.SetBearerToken(access_token);
HttpCompletionOption httpCompletionOption = HttpCompletionOption.ResponseHeadersRead;
CancellationToken cancellationToken = new CancellationToken();
// Act
_client.DefaultRequestHeaders.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("application/json"));
var response = await _client.SendAsync(httpRequestMessage, httpCompletionOption, cancellationToken);
// Assert
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
string jsonResult = await response.Content.ReadAsStringAsync();
EventModelDTO resultItem = JsonConvert.DeserializeObject <EventModelDTO>(jsonResult);
Assert.IsTrue(resultItem.Id == this._expectedItem.Id);
}
catch (Exception ex)
{
Assert.Fail(ex.Message);
}
}
public ActionResult <EventModelDTO> Get(Guid id)
{
try
{
if (id == Guid.Empty)
{
return(BadRequest());
}
ResultService <EventModel> result = this._eventsService.GetById(id);
if (result.Success)
{
EventModel eventModel = result.Value as EventModel;
EventModelDTO eventModelDTO = _mapper.Map <EventModelDTO>(eventModel);
return(Ok(eventModelDTO));
}
else
{
return(StatusCode(500, result.ErrorCode));
}
}
catch (Exception ex)
{
return(StatusCode(500, ErrorCode.Unknown));
//TODO: Log the Exception.
}
}
[Test] public void GetById_WhenCalled_ShouldReturnOk()
{
//Arrange
EventModel expectedItem = TestsFacade.EventsFacade.BuildEventModelItem();
ResultService <EventModel> expectedResultService = ResultService.Ok(expectedItem);
EventModelDTO expectedItemDTO = TestsFacade.EventsFacade.BuildEventModelDTOItem();
_mock.Mock <IGenericService <EventModel> >()
.Setup(items => items.GetById(It.IsAny <Guid>()))
.Returns(() => expectedResultService);
_mock.Mock <IMapper>()
.Setup(items => items.Map <EventModelDTO>(It.IsAny <EventModel>()))
.Returns(() => expectedItemDTO);
var controller = _mock.Create <EventsController>();
//Act
ActionResult <EventModelDTO> actionResult = controller.Get(Guid.NewGuid());
//Assert
Assert.IsNotNull(actionResult);
Assert.IsInstanceOf <OkObjectResult>(actionResult.Result);
var okResult = actionResult.Result as OkObjectResult;
Assert.IsNotNull(okResult.Value);
EventModelDTO okResultItem = okResult.Value as EventModelDTO;
Assert.IsNotNull(okResultItem);
Assert.AreEqual(okResultItem.GetHashCode(), expectedItemDTO.GetHashCode());
}
public async Task <IActionResult> Update(EventPutRequest request)
{
try
{
if (request == null || !ModelState.IsValid)
{
return(BadRequest(request));
}
ResultHandler <EventModel> getByIdResult = await this._eventsService.GetById(request.Id);
if (!getByIdResult.Success)
{
return(StatusCode(500, getByIdResult.ErrorCode));
}
EventModel item = getByIdResult.Value as EventModel;
string ownerId = this._userService.OwnerId.ToString();
if (!item.OwnerId.Equals(ownerId))
{
return(Unauthorized(request));
}
item.End = request.End;
item.IsAllDay = request.IsAllDay;
item.Title = request.Name;
item.Start = request.Start;
item.URL = request.URL;
item.Base64Id = request.Base64Id;
item.Description = request.Description;
item.Details = request.Details;
item.ImagePath = request.ImagePath;
item.UpdateDate = DateTime.UtcNow;
ResultHandler result = await this._eventsService.Update(item);
if (result.Success)
{
EventModelDTO eventModelDTO = this._mapper.Map <EventModelDTO>(item);
return(Ok(eventModelDTO));
}
else
{
return(StatusCode(500, result.ErrorCode));
}
}
catch (Exception ex)
{
this._log.LogError(ex, "EventsController.Put");
return(StatusCode(500, ErrorCode.Exception));
}
}
[Test] public async void Get_WhenCalled_ShouldReturnOk()
{
// Arrange
EventModel expectedItem = TestsFacade.EventsFacade.BuildEventModelItem();
_context.Events.Add(expectedItem);
_context.SaveChanges();
// Act
var response = await _client.GetAsync($"/api/events/{expectedItem.Id}");
// Assert
Assert.Equals(HttpStatusCode.OK, response.StatusCode);
string jsonResult = await response.Content.ReadAsStringAsync();
EventModelDTO resultItem = JsonConvert.DeserializeObject <EventModelDTO>(jsonResult);
Assert.Equals(expectedItem.Id, resultItem.Id);
}
