public async Task Get_with_authorized_user_should_retrieve_the_right_user(string url)
{
HttpClient client = _factory.CreateClient();
SignInRequest signInRequest = new SignInRequest {
Email = "*****@*****.**", Password = "******"
};
StringContent httpContent =
new StringContent(JsonConvert.SerializeObject(signInRequest), Encoding.UTF8, "application/json");
HttpResponseMessage response = await client.PostAsync(url + "/auth?api-version=1.0", httpContent);
string responseContent = await response.Content.ReadAsStringAsync();
response.EnsureSuccessStatusCode();
RespContainer <TokenResponse> tokenResponse = JsonConvert.DeserializeObject <RespContainer <TokenResponse> >(responseContent);
client.DefaultRequestHeaders.Authorization =
new AuthenticationHeaderValue("Bearer", tokenResponse.Data.Token);
HttpResponseMessage restrictedResponse = await client.GetAsync(url + "?api-version=1.0");
restrictedResponse.EnsureSuccessStatusCode();
restrictedResponse.StatusCode.ShouldBe(HttpStatusCode.OK);
}
public async Task <RespContainer <EmptyResponse> > Handle(DelteCompanyTypeCommand request, CancellationToken cancellationToken)
{
await _companyTypeService.DeleteCompanyTypeAsync(request.Data);
_logger.LogInformation($"Entity with { request.Data.Id} deleted");
return(RespContainer.Ok(new EmptyResponse(), "CompanyType deleted"));
}
public void OnException(ExceptionContext context)
{
int statusCode = -1;
EventId eventId = new EventId(context.Exception.HResult);
_logger.LogError(eventId,
context.Exception,
context.Exception.Message);
switch (context.Exception.GetType().Name)
{
case "StackException":
statusCode = (int)HttpStatusCode.BadRequest;
break;
case "NotFoundException":
statusCode = (int)HttpStatusCode.NotFound;
break;
default:
statusCode = (int)HttpStatusCode.InternalServerError;
break;
}
RespContainer <JsonException> container = RespContainer.Fail(new JsonException {
EventId = statusCode
}, Regex.Unescape(context.Exception.Message));
if (context.Exception is StackException we && (we.Errors.Count > 0))
{
container.Data.DetailedMessages = we.Errors;
}
/// <summary>
/// AddArtistRequest
/// </summary>
/// <returns></returns>
public RespContainer <ApiResult <ItemResponse> > GetExamples()
{
List <ItemResponse> itemList = new List <ItemResponse>
{
new ItemResponse
{
Id = Guid.NewGuid(),
Name = "DAMN.",
Description = "DAMN. by Kendrick Lamar",
LabelName = "TDE, Top Dawg Entertainment",
Price = new PriceResponse
{
Amount = Convert.ToDecimal(34.5),
Currency = "EUR"
},
PictureUri = "https://mycdn.com/pictures/45345345",
ReleaseDate = DateTime.Parse("2016-01-01T00:00:00+00:00"),
Format = "Vinyl 33g",
AvailableStock = 5,
GenreId = Guid.Parse("673cc719-6443-4d06-f21e-08d806d69e5d"),
ArtistId = Guid.Parse("95982efe-e0ff-4560-fc53-08d806d6ac61"),
}
};
Task <ApiResult <ItemResponse> > pagedItemsTask = Task.Run(() => ApiResult <ItemResponse> .CreateAsync(itemList.AsQueryable(), 20, 10, "Name", "ASC"));
return(RespContainer.Ok(pagedItemsTask.Result, string.Format(@"{0} Items found", itemList.Count())));
}
public async Task <RespContainer <EmptyResponse> > Handle(DelteArticleInventoryCommand request, CancellationToken cancellationToken)
{
await _articleInventoryService.DeleteArticleInventoryAsync(request.Data);
_logger.LogInformation($"Entity with { request.Data.Id} deleted");
return(RespContainer.Ok(new EmptyResponse(), "ArticleInventory deleted"));
}
public async Task <RespContainer <EmptyResponse> > Handle(DelteDocumentPositionCommand request, CancellationToken cancellationToken)
{
await _documentPositionService.DeleteDocumentPositionAsync(request.Data);
_logger.LogInformation($"Entity with { request.Data.Id} deleted");
return(RespContainer.Ok(new EmptyResponse(), "DocumentPosition deleted"));
}
/// <summary>
/// AddArtistRequest
/// </summary>
/// <returns></returns>
public RespContainer <ItemResponse> GetExamples()
{
ItemResponse itemResponse = new ItemResponse
{
Id = Guid.NewGuid(),
Name = "DAMN.",
Description = "DAMN. by Kendrick Lamar",
LabelName = "TDE, Top Dawg Entertainment",
Price = new PriceResponse
{
Amount = Convert.ToDecimal(34.5),
Currency = "EUR"
},
PictureUri = "https://mycdn.com/pictures/45345345",
ReleaseDate = DateTime.Parse("2016-01-01T00:00:00+00:00"),
Format = "Vinyl 33g",
AvailableStock = 5,
GenreId = Guid.Parse("673cc719-6443-4d06-f21e-08d806d69e5d"),
Genre = new GenreResponse
{
GenreId = Guid.Parse("673cc719-6443-4d06-f21e-08d806d69e5d"),
GenreDescription = "Hip-Hop"
},
ArtistId = Guid.Parse("95982efe-e0ff-4560-fc53-08d806d6ac61"),
Artist = new ArtistResponse
{
ArtistId = Guid.Parse("95982efe-e0ff-4560-fc53-08d806d6ac61"),
ArtistName = "Anderson Paak."
}
};
return(RespContainer.Ok <ItemResponse>(itemResponse, "Item found"));
}
/// <summary>
/// GetExamples
/// </summary>
/// <returns></returns>
public RespContainer <JsonException> GetExamples()
{
JsonException exception = new JsonException
{
EventId = 400
};
exception.DetailedMessages.Add("Username or Password is wrong");
return(RespContainer.Fail(exception, "Credentials not sufficient"));
}
public async Task <RespContainer <ArticleRangeResponse> > Handle(AddArticleRangeCommand request, CancellationToken cancellationToken)
{
Models.ArticleRange articleRange = _articleRangeMapper.Map(request.Data);
Models.ArticleRange result = _articleRangeRespository.Add(articleRange);
int modifiedRecords = await _articleRangeRespository.UnitOfWork.SaveChangesAsync();
_logger.LogInformation(Events.Add, Messages.NumberOfRecordAffected_modifiedRecords, modifiedRecords);
_logger.LogInformation(Events.Add, Messages.ChangesApplied_id, result?.Id);
return(RespContainer.Ok(_articleRangeMapper.Map(result), "ArticleRange Created"));
}
public async Task <RespContainer <CountryResponse> > Handle(AddCountryCommand request, CancellationToken cancellationToken)
{
Models.Country country = _countryMapper.Map(request.Data);
Models.Country result = _countryRespository.Add(country);
int modifiedRecords = await _countryRespository.UnitOfWork.SaveChangesAsync();
_logger.LogInformation(Events.Add, Messages.NumberOfRecordAffected_modifiedRecords, modifiedRecords);
_logger.LogInformation(Events.Add, Messages.ChangesApplied_id, result?.Id);
return(RespContainer.Ok(_countryMapper.Map(result), "Country Created"));
}
public async Task <RespContainer <DocumentPositionResponse> > Handle(AddDocumentPositionCommand request, CancellationToken cancellationToken)
{
Models.DocumentPosition documentPosition = _documentPositionMapper.Map(request.Data);
Models.DocumentPosition result = _documentPositionRespository.Add(documentPosition);
int modifiedRecords = await _documentPositionRespository.UnitOfWork.SaveChangesAsync();
_logger.LogInformation(Events.Add, Messages.NumberOfRecordAffected_modifiedRecords, modifiedRecords);
_logger.LogInformation(Events.Add, Messages.ChangesApplied_id, result?.Id);
return(RespContainer.Ok(_documentPositionMapper.Map(result), "DocumentPosition Created"));
}
public async Task <IActionResult> Get()
{
Claim claim = HttpContext.User.Claims.FirstOrDefault(x => x.Type == ClaimTypes.Email);
if (claim == null)
{
return(Unauthorized());
}
return(Ok(RespContainer.Ok(await _userService.GetUserAsync(new GetUserRequest {
Email = claim.Value
}), "user found")));
}
public async Task <RespContainer <FAGTextResponse> > Handle(AddFAGTextCommand request, CancellationToken cancellationToken)
{
Models.FAGText fagText = _fagTextMapper.Map(request.Data);
Models.FAGText result = _fagTextRespository.Add(fagText);
int modifiedRecords = await _fagTextRespository.UnitOfWork.SaveChangesAsync();
_logger.LogInformation(Events.Add, Messages.NumberOfRecordAffected_modifiedRecords, modifiedRecords);
_logger.LogInformation(Events.Add, Messages.ChangesApplied_id, result?.Id);
return(RespContainer.Ok(_fagTextMapper.Map(result), "FAGText Created"));
}
public async Task Delete_should_returns_ok_when_called_with_right_id(DeleteItemRequest request)
{
HttpClient client = _factory.CreateClient();
AddAuthToken(ref client);
HttpResponseMessage response = await client.DeleteAsync($"/api/items/{request.Id}?api-version=1.0");
string responseContent = await response.Content.ReadAsStringAsync();
RespContainer <ItemResponse> responseEntity = JsonConvert.DeserializeObject <RespContainer <ItemResponse> >(responseContent);
responseEntity.Error.ShouldBeFalse();
response.StatusCode.ShouldBe(HttpStatusCode.OK);
}
public async Task Update_should_modify_existing_items(EditItemRequest request)
{
HttpClient client = _factory.CreateClient();
AddAuthToken(ref client);
StringContent httpContent =
new StringContent(JsonConvert.SerializeObject(request), Encoding.UTF8, "application/json");
HttpResponseMessage response = await client.PutAsync($"/api/items/{request.Id}?api-version=1.0", httpContent);
response.EnsureSuccessStatusCode();
string responseContent = await response.Content.ReadAsStringAsync();
RespContainer <ItemResponse> responseEntity = JsonConvert.DeserializeObject <RespContainer <ItemResponse> >(responseContent);
responseEntity.Error.ShouldBeFalse();
responseEntity.Data.Name.ShouldBe(request.Name);
responseEntity.Data.Description.ShouldBe(request.Description);
responseEntity.Data.Format.ShouldBe(request.Format);
responseEntity.Data.PictureUri.ShouldBe(request.PictureUri);
responseEntity.Data.GenreId.ShouldBe(request.GenreId);
responseEntity.Data.ArtistId.ShouldBe(request.ArtistId);
}
public async Task <RespContainer <ArticleInventoryResponse> > Handle(EditArticleInventoryCommand request, CancellationToken cancellationToken)
{
ArticleInventoryResponse result = await _articleInventoryService.EditArticleInventoryAsync(request.Data);
return(RespContainer.Ok(result, "ArticleInventory Updated"));
}
public async Task <RespContainer <DocumentPositionResponse> > Handle(EditDocumentPositionCommand request, CancellationToken cancellationToken)
{
DocumentPositionResponse result = await _documentPositionService.EditDocumentPositionAsync(request.Data);
return(RespContainer.Ok(result, "DocumentPosition Updated"));
}
public async Task <RespContainer <PersonResponse> > Handle(EditPersonCommand request, CancellationToken cancellationToken)
{
PersonResponse result = await _personService.EditPersonAsync(request.Data);
return(RespContainer.Ok(result, "Person Updated"));
}
public async Task <IActionResult> Post(AddFAGBinaryRequest request)
{
RespContainer <FAGBinaryResponse> result = await _mediator.Send(new AddFAGBinaryCommand(request));
return(CreatedAtAction(nameof(GetById), new { id = result.Data.Id }, result));
}
public async Task <IActionResult> SignIn(SignInRequest request)
{
return(Ok(RespContainer.Ok(await _userService.SignInAsync(request), "authorized")));
}
public async Task <RespContainer <CountryResponse> > Handle(EditCountryCommand request, CancellationToken cancellationToken)
{
CountryResponse result = await _countryService.EditCountryAsync(request.Data);
return(RespContainer.Ok(result, "Country Updated"));
}
public async Task <RespContainer <ItemResponse> > Handle(EditItemCommand request, CancellationToken cancellationToken)
{
ItemResponse result = await _itemService.EditItemAsync(request.Data);
return(RespContainer.Ok(result, "Item Updated"));
}
public async Task <RespContainer <FAGTextResponse> > Handle(EditFAGTextCommand request, CancellationToken cancellationToken)
{
FAGTextResponse result = await _fagTextService.EditFAGTextAsync(request.Data);
return(RespContainer.Ok(result, "FAGText Updated"));
}
public async Task <RespContainer <ArticlePriceListInResponse> > Handle(EditArticlePriceListInCommand request, CancellationToken cancellationToken)
{
ArticlePriceListInResponse result = await _articlePriceListInService.EditArticlePriceListInAsync(request.Data);
return(RespContainer.Ok(result, "ArticlePriceListIn Updated"));
}
