public async Task <BaseResponseDto <Basket> > Handle(CreateBasketRequest request, CancellationToken cancellationToken)
{
BaseResponseDto <Basket> response = new BaseResponseDto <Basket>();
try
{
var basket = new Basket
{
UserName = request.UserName
};
var result = await _repository.Create(basket);
if (result != null)
{
response.Data = result;
}
else
{
response.Errors.Add("An error occured while saving data to the database");
}
}
catch (Exception exception)
{
Console.WriteLine(exception);
response.Errors.Add(exception.Message);
}
return(response);
}
public IActionResult Post(CreateBasketRequest request)
{
var createMessage = _mapper.Map <CreateBasketMessage>(request);
var result = _mediator.Send <CreateBasketMessage, IBasket>(createMessage);
return(CreatedAtAction(nameof(GetById), new { basketId = result.BasketId }, null));
}
public async Task <IActionResult> Post()
{
var request = new CreateBasketRequest();
var basket = await _mediator.Send(request);
return(CreatedAtAction("Get", new { id = basket.Id }, basket));
}
public async Task <HttpResponse <CreateBasketResponse> > CreateBasketAsync(CreateBasketRequest request)
{
var response = await PostAsync <CreateBasketResponse>($"{ApiRoot}/BasketApi/Create", request);
if (response.ResponseContent.ResponseCode == "99999")
{
response.StatusCode = HttpStatusCode.BadRequest;
}
return(response);
}
public async Task <IActionResult> Save([FromBody] CreateBasketRequest request)
{
try
{
request.UserId = User.GetUserId();
var result = await BasketService.Save(request);
return(Ok(result));
}
catch (Exception ex)
{
Logger.LogException(ex, "Fox.Basket.Api");
return(BadRequest(ex));
}
}
public JsonResult AddToBasket(int productId)
{
BasketSummaryView basketSummaryView = new BasketSummaryView();
Guid basketId = base.GetBasketId();
bool createNewBasket = basketId == Guid.Empty;
if (createNewBasket == false)
{
ModifyBasketRequest modifyBasketRequest =
new ModifyBasketRequest();
modifyBasketRequest.ProductsToAdd.Add(productId);
modifyBasketRequest.BasketId = basketId;
try
{
ModifyBasketResponse response = _basketService
.ModifyBasket(modifyBasketRequest);
basketSummaryView = response.Basket.ConvertToSummary();
SaveBasketSummaryToCookie(basketSummaryView.NumberOfItems,
basketSummaryView.BasketTotal);
}
catch (BasketDoesNotExistException ex)
{
createNewBasket = true;
}
}
if (createNewBasket)
{
CreateBasketRequest createBasketRequest =
new CreateBasketRequest();
createBasketRequest.ProductsToAdd.Add(productId);
CreateBasketResponse response = _basketService
.CreateBasket(createBasketRequest);
SaveBasketIdToCookie(response.Basket.Id);
basketSummaryView = response.Basket.ConvertToSummary();
SaveBasketSummaryToCookie(basketSummaryView.NumberOfItems,
basketSummaryView.BasketTotal);
}
return(Json(basketSummaryView));
}
public CreateBasketResponse CreateBasket(CreateBasketRequest request)
{
CreateBasketResponse response = new CreateBasketResponse();
Basket basket = new Basket();
basket.SetDeliveryOption(GetCheapestDeliveryOption());
AddProductsToBasket(request.ProductsToAdd, basket);
ThrowExceptionIfBasketIsInvalid(basket);
_basketRepository.Save(basket);
_uow.Commit();
response.Basket = basket.ConvertToBasketView();
return(response);
}
public async Task <IActionResult> Create([FromBody] CreateBasketRequest request)
{
var validation = new CreateBasketValidator().Validate(request);
if (!validation.IsValid)
{
return(BadRequest(validation.Errors));
}
var basketId = BasketId.New;
var task = await commandBus.PublishAsync(new CreateBasket(basketId, request.CustomerId), CancellationToken.None);
if (task.IsSuccess)
{
return(CreatedAtRoute("GetBasket", new { basketId = basketId.ToString() }, basketId.ToString()));
}
return(BadRequest());
}
public BasketSummaryView AddToBasket(int productId)
{
BasketSummaryView basketSummaryView = new BasketSummaryView();
Guid basketId = base.GetBasketId();
bool createNewBasket = basketId == Guid.Empty;
if (createNewBasket == false)
{
var modifyBasketRequest = new ModifyBasketRequest();
modifyBasketRequest.ProductsToAdd.Add(productId);
modifyBasketRequest.BasketId = basketId;
try {
var response = _basketService.ModifyBasket(modifyBasketRequest);
basketSummaryView = DTOs.BasketMapper.ConvertToSummary(response.Basket);
SaveBasketSummaryToCookie(basketSummaryView.NumberOfItems,
basketSummaryView.BasketTotal);
} catch (BasketDoesNotExistException ex) {
LoggingFactory.GetLogger().Log(
String.Format("Creating new basket because exception. {0}", ex.ToString()));
createNewBasket = true;
}
}
if (createNewBasket)
{
var createBasketRequest = new CreateBasketRequest();
createBasketRequest.ProductsToAdd.Add(productId);
var response = _basketService.CreateBasket(createBasketRequest);
SaveBasketIdToCookie(response.Basket.Id);
basketSummaryView = DTOs.BasketMapper.ConvertToSummary(response.Basket);
SaveBasketSummaryToCookie(basketSummaryView.NumberOfItems,
basketSummaryView.BasketTotal);
}
return(basketSummaryView);
}
public CreateBasketResponse CreateBasket(CreateBasketRequest basketRequest)
{
CreateBasketResponse response = new CreateBasketResponse();
Basket basket = new Basket();
Customer customer = _customerRepository.FindBy(basketRequest.CustomerEmail);
customer.Email = basketRequest.CustomerEmail;
basket.SetDeliveryOption(GetCheapestDeliveryOption());
AddProductsToBasket(basketRequest.ProductsToAdd, basket);
basket.SetCustomer(customer);
basket.ThrowExceptionIfInvalid();
_basketRepository.Save(basket);
customer.AddBasket(basket);
customer.ThrowExceptionIfInvalid();
_customerRepository.Save(customer);
_uow.Commit();
response.Basket = _mapper.Map <Basket, BasketView>(basket);
return(response);
}
public IActionResult AddToBasket(int productId)
{
BasketSummaryView basketSummaryView = new BasketSummaryView();
Guid basketId = GetBasketId();
bool createNewBasket = basketId == Guid.Empty;
if (!createNewBasket)
{
ModifyBasketRequest modifyBasketRequest = new ModifyBasketRequest();
modifyBasketRequest.ProductsToAdd.Add(productId);
modifyBasketRequest.BasketId = basketId;
try
{
ModifyBasketResponse response = _basketService.ModifyBasket(modifyBasketRequest);
basketSummaryView = response.Basket.ConvertToSummary();
}
catch (BasketDoesNotExistException)
{
createNewBasket = true;
}
}
if (createNewBasket)
{
CreateBasketRequest createBasketRequest = new CreateBasketRequest();
createBasketRequest.CustomerEmail = _cookieAuthentication.GetAuthenticationToken();
createBasketRequest.ProductsToAdd.Add(productId);
CreateBasketResponse response = _basketService.CreateBasket(createBasketRequest);
basketSummaryView = response.Basket.ConvertToSummary();
}
return(Ok(basketSummaryView));
}
public async Task <IActionResult> Create([FromBody] CreateBasketRequest request)
{
var validation = await this.basketValidationService.ValidateCreateBasket(request);
if (!validation.Success)
{
return(BadRequest(validation.Message));
}
var unpricedItems = this.mapper.Map <IList <UnpricedBasketItemModel> >(request.Items);
var pricedItems = await this.pricingService.PriceItems(unpricedItems);
var model = this.mapper.Map <CreateBasketModel>(request);
model.Items = pricedItems;
var result = await this.basketService.CreateBasket(model);
// Strictly, this should return 201 Created, but for testing we're going to want this info immediately anyway
var basket = await this.basketService.GetBasket(result.BasketId);
return(Ok(basket));
}
public async Task <ValidationResult> ValidateCreateBasket(CreateBasketRequest basket)
{
if (basket == null)
{
return(new ValidationResult
{
Success = false,
Message = "No basket body supplied"
});
}
var stockCheck = await this.CheckStock(basket.Items);
if (!stockCheck.Success)
{
return(stockCheck);
}
return(new ValidationResult
{
Success = true
});
}
public async Task <BaseResponseDto <Basket> > CreateBasketAsync(CreateBasketRequest request)
{
return(await _mediator.Send(request));
}
public async Task <BasketResponse> Save(CreateBasketRequest request)
{
return(new BasketResponse());
}
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='request'>
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
public static async Task CreateBasketAsync(this IShoppingBasketAPI operations, CreateBasketRequest request = default(CreateBasketRequest), CancellationToken cancellationToken = default(CancellationToken))
{
(await operations.CreateBasketWithHttpMessagesAsync(request, null, cancellationToken).ConfigureAwait(false)).Dispose();
}
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='request'>
/// </param>
public static void CreateBasket(this IShoppingBasketAPI operations, CreateBasketRequest request = default(CreateBasketRequest))
{
operations.CreateBasketAsync(request).GetAwaiter().GetResult();
}
/// <param name='request'>
/// </param>
/// <param name='customHeaders'>
/// Headers that will be added to request.
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
/// <exception cref="HttpOperationException">
/// Thrown when the operation returned an invalid status code
/// </exception>
/// <return>
/// A response object containing the response body and response headers.
/// </return>
public async Task <HttpOperationResponse> CreateBasketWithHttpMessagesAsync(CreateBasketRequest request = default(CreateBasketRequest), Dictionary <string, List <string> > customHeaders = null, CancellationToken cancellationToken = default(CancellationToken))
{
// Tracing
bool _shouldTrace = ServiceClientTracing.IsEnabled;
string _invocationId = null;
if (_shouldTrace)
{
_invocationId = ServiceClientTracing.NextInvocationId.ToString();
Dictionary <string, object> tracingParameters = new Dictionary <string, object>();
tracingParameters.Add("request", request);
tracingParameters.Add("cancellationToken", cancellationToken);
ServiceClientTracing.Enter(_invocationId, this, "CreateBasket", tracingParameters);
}
// Construct URL
var _baseUrl = BaseUri.AbsoluteUri;
var _url = new System.Uri(new System.Uri(_baseUrl + (_baseUrl.EndsWith("/") ? "" : "/")), "api/v1/Basket").ToString();
// Create HTTP transport objects
var _httpRequest = new HttpRequestMessage();
HttpResponseMessage _httpResponse = null;
_httpRequest.Method = new HttpMethod("POST");
_httpRequest.RequestUri = new System.Uri(_url);
// Set Headers
if (customHeaders != null)
{
foreach (var _header in customHeaders)
{
if (_httpRequest.Headers.Contains(_header.Key))
{
_httpRequest.Headers.Remove(_header.Key);
}
_httpRequest.Headers.TryAddWithoutValidation(_header.Key, _header.Value);
}
}
// Serialize Request
string _requestContent = null;
if (request != null)
{
_requestContent = SafeJsonConvert.SerializeObject(request, SerializationSettings);
_httpRequest.Content = new StringContent(_requestContent, System.Text.Encoding.UTF8);
_httpRequest.Content.Headers.ContentType = System.Net.Http.Headers.MediaTypeHeaderValue.Parse("application/json-patch+json; charset=utf-8");
}
// Send Request
if (_shouldTrace)
{
ServiceClientTracing.SendRequest(_invocationId, _httpRequest);
}
cancellationToken.ThrowIfCancellationRequested();
_httpResponse = await HttpClient.SendAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
if (_shouldTrace)
{
ServiceClientTracing.ReceiveResponse(_invocationId, _httpResponse);
}
HttpStatusCode _statusCode = _httpResponse.StatusCode;
cancellationToken.ThrowIfCancellationRequested();
string _responseContent = null;
if ((int)_statusCode != 200)
{
var ex = new HttpOperationException(string.Format("Operation returned an invalid status code '{0}'", _statusCode));
if (_httpResponse.Content != null)
{
_responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
}
else
{
_responseContent = string.Empty;
}
ex.Request = new HttpRequestMessageWrapper(_httpRequest, _requestContent);
ex.Response = new HttpResponseMessageWrapper(_httpResponse, _responseContent);
if (_shouldTrace)
{
ServiceClientTracing.Error(_invocationId, ex);
}
_httpRequest.Dispose();
if (_httpResponse != null)
{
_httpResponse.Dispose();
}
throw ex;
}
// Create Result
var _result = new HttpOperationResponse();
_result.Request = _httpRequest;
_result.Response = _httpResponse;
if (_shouldTrace)
{
ServiceClientTracing.Exit(_invocationId, _result);
}
return(_result);
}
public async Task <string> Create(CreateBasketRequest request)
{
var uri = BuildUri();
return(await _client.PostAsync(uri, request));
}
