async Task <CurbsideOrder> IDoCurbsideCommands.AddOrder(PostCurbsideOrderRequest orderToPlace, bool doAsync)
{
//await Task.Delay(3000);
var order = _mapper.Map <CurbsideOrder>(orderToPlace);
_context.CurbsideOrders.Add(order);
await _context.SaveChangesAsync();
if (doAsync)
{
try
{
await _channel.AddCurbside(new CurbsideChannelRequest { OrderId = order.Id });
}
catch (OperationCanceledException ex)
{
// for some reason the background worker puched you in the nose (more likely the channel)
throw;
}
}
else
{
var numberOfItems = order.Items.Split(',').Count();
for (var t = 0; t < numberOfItems; t++)
{
await Task.Delay(300);
}
}
return(order);
}
public async Task <CurbsideOrder> AddOrder(PostCurbsideOrderRequest orderToPlace, bool doAsync)
{
var order = _mapper.Map <CurbsideOrder>(orderToPlace);
_context.CurbsideOrders.Add(order);
await _context.SaveChangesAsync();
if (doAsync)
{
try
{
await _channel.AddCurbside(new CurbsideChannelRequest { OrderId = order.Id });
}
catch (OperationCanceledException ex)
{
// do something?
throw;
}
}
else
{
var numberOfItems = order.Items.Split(',').Count();
for (var t = 0; t < numberOfItems; t++)
{
await Task.Delay(300);
}
}
return(order);
}
async Task <CurbsideOrder> IDoCurbsideCommands.AddOrder(PostCurbsideOrderRequest orderToPlace, bool doAsync)
{
// place that order..
// await Task.Delay(3000);
// that represents all the very important things we have to do.
var order = _mapper.Map <CurbsideOrder>(orderToPlace);
_context.CurbsideOrders.Add(order);
await _context.SaveChangesAsync();
if (doAsync)
{
try
{
await _channel.AddCurbside(new CurbsideChannelRequest { OrderId = order.Id });
}
catch (OperationCanceledException ex)
{
// for some reason the background worker punched you in the nose (more likely the channel).
// Do some cleanup.. Whatever.
throw;
}
}
else
{
var numberOfItems = order.Items.Split(',').Count();
for (var t = 0; t < numberOfItems; t++)
{
await Task.Delay(300); // what important work needs to happen.
}
}
return(order);
}
public async Task<ActionResult> AddAnOrder([FromBody] PostCurbsideOrderRequest orderToPlace)
{
if(!ModelState.IsValid)
{
return BadRequest(ModelState);
} else
{
CurbsideOrder response = await _curbsideCommands.AddOrder(orderToPlace,true);
// I'll pause here.. for dramatic effect.
return CreatedAtRoute("curbside#getbyid", new { orderId = response.Id }, response);
}
}
public async Task <ActionResult> AddAnOrderSync([FromBody] PostCurbsideOrderRequest orderToPlace)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
else
{
CurbsideOrder response = await _curbsideCommands.AddOrder(orderToPlace, false);
return(CreatedAtRoute("curbside#getbyid", new { orderId = response.Id }, response));
}
}
//public async Task<CurbsideOrder> AddOrder(PostCurbsideOrderRequest orderToPlace)
async Task <CurbsideOrder> IDoCurbsideCommands.AddOrder(PostCurbsideOrderRequest orderToPlace)
{
// place the order...
//await Task.Delay(3000);
var order = _mapper.Map <CurbsideOrder>(orderToPlace);
_context.CurbsideOrders.Add(order);
await _context.SaveChangesAsync();
try
{
await _channel.AddCurbside(new CurbsideChannelRequest { OrderId = order.Id });
} catch (OperationCanceledException ex)
{
throw;
}
return(order);
}
public async Task <CurbsideOrder> AddOrderWs(PostCurbsideOrderRequest orderToBePlaced, string connectionId)
{
var order = _mapper.Map <CurbsideOrder>(orderToBePlaced);
_context.CurbsideOrders.Add(order);
await _context.SaveChangesAsync();
try
{
await _channel.AddCurbside(new CurbsideChannelRequest { OrderId = order.Id, ClientId = connectionId });
}
catch (OperationCanceledException ex)
{
// do something?
throw;
}
return(order);
}
async Task <CurbsideOrder> IDoCurbsideCommands.AddOrder(PostCurbsideOrderRequest orderToPlace)
{
await Task.Delay(300);
var order = _mapper.Map <CurbsideOrder>(orderToPlace);
_context.CurbsideOrders.Add(order);
await _context.SaveChangesAsync();
try
{
await _channel.AddCurbside(new CurbsideChannelRequest { OrderId = order.Id });
}catch (OperationCanceledException ex)
{
// for some reason the background worker punched you in the nose
// do some cleanup
throw;
}
return(order);
}
async Task <CurbsideOrder> IDoCurbsideCommands.AddOrder(PostCurbsideOrderRequest orderToPlace)
{
// place that order..
// await Task.Delay(3000);
// that represents all the very important things we have to do.
var order = _mapper.Map <CurbsideOrder>(orderToPlace);
_context.CurbsideOrders.Add(order);
await _context.SaveChangesAsync();
try
{
await _channel.AddCurbside(new CurbsideChannelRequest { OrderId = order.Id });
} catch (OperationCanceledException ex)
{
// for some reason the background worker punched you in the nose (more likely the channel).
// Do some cleanup.. Whatever.
throw;
}
return(order);
}
public async Task PlaceOrder(PostCurbsideOrderRequest orderToBePlaced)
{
CurbsideOrder order = await _commands.AddOrderWs(orderToBePlaced, Context.ConnectionId);
await Clients.Caller.SendAsync("OrderPlaced", order);
}
