public IHttpActionResult CreateBasket()
{
var basketId = Guid.NewGuid();
var cmd = new CreateBasket(basketId);
var basket = _commandDispatcher.ExecuteCommand <BasketAggregate>(cmd);
return(Ok(BasketModel.FromAggregate(basket)));
}
public async Task <IActionResult> Create()
{
var basketId = Guid.NewGuid();
var useCase = new CreateBasket(basketId);
var cmd = new Command <CreateBasket>(useCase);
var basket = await _commandHandler.Execute <PendingBasket>(cmd);
return(Ok(BasketModel.FromAggregateRoot(basket)));
}
public async Task <IActionResult> Create(Basket catalog, CancellationToken cancellation)
{
var command = new CreateBasket(catalog);
var result = await mediator.Send(command);
if (result != null)
{
return(Ok(result));
}
return(BadRequest("Try again"));
}
public async Task <IActionResult> CreateBasket(string memberId, [FromBody] CreateBasket createBasket)
{
var basket = await _basketService.GetOrCreateBasket(memberId, createBasket.BasketId.Value);
if (basket == null)
{
return(NotFound("No Basket found"));
}
return(Ok(basket));
}
public Guid CreateBasket()
{
var request = new CreateBasket();
var response = request.Post();
if (string.IsNullOrWhiteSpace(response))
{
throw new ApplicationException("Internal server error");
}
var r = JsonConvert.DeserializeObject <string>(response);
return(Guid.Parse(r));
}
public void When_CreateBasket_BasketCreated()
{
var command = new CreateBasket(id);
command.Metadata.CausationId = command.Metadata.CommandId;
command.Metadata.CorrelationId = causationAndCorrelationId;
When(command);
var expectedEvent = new BasketCreated(id);
expectedEvent.Metadata.CausationId = command.Metadata.CommandId;
expectedEvent.Metadata.CorrelationId = causationAndCorrelationId;
expectedEvent.Metadata.ProcessId = command.Metadata.ProcessId;
Then(expectedEvent);
}
public async Task HandleAsync(CustomerCreated @event, ICorrelationContext context)
{
CreateBasket newBasket = new CreateBasket(Guid.NewGuid(), @event.UserId);
await _dispatcher.SendAsync(newBasket);
}
internal static BasketAggregate Create(CreateBasket cmd)
{
return(new BasketAggregate(cmd));
}
private BasketAggregate(CreateBasket cmd) : this()
{
RaiseEvent(new BasketCreated(cmd.AggregateId));
}
/// <summary>Create basket</summary>
/// <exception cref="SwaggerException">A server side error occurred.</exception>
/// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
public async System.Threading.Tasks.Task <Basket> CreateBasketAsync(string memberId, CreateBasket createBasket, System.Threading.CancellationToken cancellationToken)
{
if (memberId == null)
{
throw new System.ArgumentNullException("memberId");
}
var urlBuilder_ = new System.Text.StringBuilder();
urlBuilder_.Append(BaseUrl != null ? BaseUrl.TrimEnd('/') : "").Append("/api/v1/{memberId}/Baskets");
urlBuilder_.Replace("{memberId}", System.Uri.EscapeDataString(ConvertToString(memberId, System.Globalization.CultureInfo.InvariantCulture)));
var client_ = new System.Net.Http.HttpClient();
try
{
using (var request_ = new System.Net.Http.HttpRequestMessage())
{
var content_ = new System.Net.Http.StringContent(Newtonsoft.Json.JsonConvert.SerializeObject(createBasket, _settings.Value));
content_.Headers.ContentType = System.Net.Http.Headers.MediaTypeHeaderValue.Parse("application/json");
request_.Content = content_;
request_.Method = new System.Net.Http.HttpMethod("POST");
request_.Headers.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("application/json"));
PrepareRequest(client_, request_, urlBuilder_);
var url_ = urlBuilder_.ToString();
request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
PrepareRequest(client_, request_, url_);
var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
try
{
var headers_ = System.Linq.Enumerable.ToDictionary(response_.Headers, h_ => h_.Key, h_ => h_.Value);
if (response_.Content != null && response_.Content.Headers != null)
{
foreach (var item_ in response_.Content.Headers)
{
headers_[item_.Key] = item_.Value;
}
}
ProcessResponse(client_, response_);
var status_ = ((int)response_.StatusCode).ToString();
if (status_ == "200")
{
var responseData_ = response_.Content == null ? null : await response_.Content.ReadAsStringAsync().ConfigureAwait(false);
var result_ = default(Basket);
try
{
result_ = Newtonsoft.Json.JsonConvert.DeserializeObject <Basket>(responseData_, _settings.Value);
return(result_);
}
catch (System.Exception exception_)
{
throw new SwaggerException("Could not deserialize the response body.", (int)response_.StatusCode, responseData_, headers_, exception_);
}
}
else
if (status_ != "200" && status_ != "204")
{
var responseData_ = response_.Content == null ? null : await response_.Content.ReadAsStringAsync().ConfigureAwait(false);
throw new SwaggerException("The HTTP status code of the response was not expected (" + (int)response_.StatusCode + ").", (int)response_.StatusCode, responseData_, headers_, null);
}
return(default(Basket));
}
finally
{
if (response_ != null)
{
response_.Dispose();
}
}
}
}
finally
{
if (client_ != null)
{
client_.Dispose();
}
}
}
/// <summary>Create basket</summary>
/// <exception cref="SwaggerException">A server side error occurred.</exception>
public System.Threading.Tasks.Task <Basket> CreateBasketAsync(string memberId, CreateBasket createBasket)
{
return(CreateBasketAsync(memberId, createBasket, System.Threading.CancellationToken.None));
}
public async Task <IActionResult> CreateBasket([FromBody] CreateBasket command)
{
await _busPublisher.SendAsync(command.Bind(x => x.BasketId, Guid.NewGuid()), null);
return(Accepted());
}
public Task <IEnumerable <BasketDto> > Handle(CreateBasket request, CancellationToken cancellationToken)
{
throw new System.NotImplementedException();
}