public OrderReplyMessage PlaceOrder(Customer c)
{
bool gotReply;
var order = new CustomerOrderRequest()
{
CountryCode = c.Countrycode, CustomerId = c.Id, ProductId = c.ProductID
};
bus.Send("ReplyQueueCustomer", order);
Console.WriteLine("Sent order to retailer, waiting for response...");
lock (this)
{
gotReply = Monitor.Wait(this, 10000);
}
if (gotReply)
{
return(reply);
}
else
{
throw new Exception("Timeout. The requested product is out of stock!");
}
}
public CustomerOrderResponse HandleCustomerOrder(CustomerOrderRequest request)
{
if (!_owner.Info.Enabled)
{
return(_custResponseFac.CMCurrentlyDisabled());
}
if (!_owner.Info.HasRecipe(request.RecipeName))
{
return(_custResponseFac.RecipeNotAvailable());
}
lock (_queue)
{
if (_queue.Count >= _queueCapacity)
{
return(_custResponseFac.FullQueue());
}
var newOrder = new Order()
{
CustomerEmail = request.CustomerEmail,
RecipeName = request.RecipeName,
Reference = (new Random((int)DateTime.Now.ToBinary()).Next()).ToString("X"),
Status = OrderStatusEnum.InQueue,
CreationTime = DateTime.UtcNow
};
_queue.Enqueue(newOrder);
var positionInQueue = _queue.Count;
Dashboard.Sgt.LogAsync($"{_owner.Info.UniqueName}'s waitress has got a new order! Recipe: {newOrder.RecipeName}, ref: {newOrder.Reference}.");
return(_custResponseFac.OrderReceived(positionInQueue, request.CustomerEmail));
}
}
public async Task <IActionResult> AddCustomerOrder(
[FromRoute] Guid customerId,
[FromBody] CustomerOrderRequest request)
{
await _mediator.Send(new PlaceCustomerOrderCommand(customerId, request.Products, request.Currency));
return(Created(string.Empty, null));
}
public async Task <IActionResult> ChangeCustomerOrder(
[FromRoute] Guid customerId,
[FromRoute] Guid orderId,
[FromBody] CustomerOrderRequest request)
{
await _mediator.Send(new ChangeCustomerOrderCommand(customerId, orderId, request.Products, request.Currency));
return(Ok());
}
private void HandleReply(CustomerOrderRequest reply)
{
replyMessage = reply;
lock (this)
{
Monitor.Pulse(this);
}
}
public CustomerOrderResponse Order([FromBody] CustomerOrderRequest request)
{
var cmName = request.MachineUniqueName;
var mac = CMProxyHub.Sgt.GetMac(cmName);
if (mac == null)
{
return(_custResponsefac.InexistentCoffeeMachine());
}
var response = Waitress.GetWaitress(mac)?.HandleCustomerOrder(request);
return(response);
}
static void HandleReplyCustomer(CustomerOrderRequest requestMessage)
{
Console.WriteLine(string.Format("Got customer order request: Customer id: {0} Country code: {1} Product id {2}\n" +
"trying to send to local warehouse", requestMessage.CustomerId, requestMessage.CountryCode, requestMessage.ProductId));
OrderRequestMessageToLocalWarehouse ormtlw = new OrderRequestMessageToLocalWarehouse();
ormtlw.CountryCode = requestMessage.CountryCode;
ormtlw.CustomerId = requestMessage.CustomerId;
ormtlw.ProductId = requestMessage.ProductId;
ormtlw.ReplyTo = requestMessage.CustomerId + "";
bus.Publish <OrderRequestMessageToLocalWarehouse>(ormtlw, ormtlw.CountryCode);
outstandingOrders.Add(requestMessage.CustomerId);
Console.WriteLine("Send to local warehouse: " + requestMessage.CountryCode);
}
public async Task <ActionResult <ReturnResponse> > PostCustomerOrder([FromBody] CustomerOrderRequest customerOrderRequest)
{
var dbTransaction = await _dataContext.Database.BeginTransactionAsync();
var result = await _customerOrderRepository.CreateCustomerOrder(customerOrderRequest);
if (result.StatusCode == Utils.Success)
{
result.ObjectValue = _mapper.Map <CustomerOrderResponse>((CustomerOrder)result.ObjectValue);
await dbTransaction.CommitAsync();
return(StatusCode(StatusCodes.Status200OK, result));
}
else
{
await dbTransaction.RollbackAsync();
return(StatusCode(StatusCodes.Status400BadRequest, result));
}
}
public string SendRequest(string message, string topic)
{
CustomerOrderRequest requestMessage = new CustomerOrderRequest {
Name = message, CountryCode = topic
}; //CustomerId
bool gotReply;
bus.Publish <CustomerOrderRequest>(requestMessage, topic);
lock (this)
{
gotReply = Monitor.Wait(this, timeout);
}
if (gotReply)
{
return(replyMessage.ProductId);
}
else
{
throw new Exception("Timeout!");
}
}
public async Task <ReturnResponse> CreateCustomerOrder(CustomerOrderRequest customerOrderRequest)
{
if (customerOrderRequest == null)
{
return(new ReturnResponse()
{
StatusCode = Utils.ObjectNull,
StatusMessage = Utils.StatusMessageObjectNull
});
}
if (customerOrderRequest.CustomerOrderGroups == null)
{
return(new ReturnResponse()
{
StatusCode = Utils.ObjectNull,
StatusMessage = Utils.StatusMessageObjectNull
});
}
var loggedInUser = _globalRepository.GetUserInformation();
if (loggedInUser.UserTypeId == Utils.UserClaim_Null)
{
return(new ReturnResponse()
{
StatusCode = Utils.UserClaimNotFound,
StatusMessage = Utils.StatusMessageUserClaimNotFound
});
}
var customer = await _globalRepository.Get <Customer>(loggedInUser.UserTypeId);
if (customer == null)
{
return(new ReturnResponse()
{
StatusCode = Utils.NotFound,
StatusMessage = Utils.StatusMessageNotFound
});
}
var customerOrder = _mapper.Map <CustomerOrder>(customerOrderRequest);
customerOrder.CustomerId = customer.CustomerId;
var assignmentResult = await AssignProductsToCustomerOrderGroupItems(customerOrder.CustomerOrderGroups, customer.CustomerId);
if (assignmentResult.StatusCode != Utils.Success)
{
return(assignmentResult);
}
customerOrder.CustomerOrderGroups = (List <CustomerOrderGroup>)assignmentResult.ObjectValue;
customerOrder.OrderStatus = Utils.CurrentOrderNumberStatus_Pending;
customerOrder.DeliveryStatus = Utils.CurrentOrderNumberStatus_Pending;
var creationResult = _globalRepository.Add(customerOrder);
if (!creationResult)
{
return(new ReturnResponse()
{
StatusCode = Utils.NotSucceeded,
StatusMessage = Utils.StatusMessageNotSucceeded
});
}
var saveResult = await _globalRepository.SaveAll();
if (!saveResult.HasValue)
{
return(new ReturnResponse()
{
StatusCode = Utils.SaveError,
StatusMessage = Utils.StatusMessageSaveError
});
}
if (!saveResult.Value)
{
return(new ReturnResponse()
{
StatusCode = Utils.SaveNoRowAffected,
StatusMessage = Utils.StatusMessageSaveNoRowAffected
});
}
//FINALLY CREATE ORDER AND UPDATE ORDER STATUS
//UPDATE DELIVERY STATUS
var updateStatus = await UpdateCustomerOrderStatusAndDeliveryStatus(customerOrder.CustomerOrderId, true, true);
if (updateStatus.StatusCode != Utils.Success)
{
return(new ReturnResponse()
{
StatusCode = Utils.NotSucceeded,
StatusMessage = Utils.StatusMessageNotSucceeded
});
}
//SEND MAIL TO CUSTOMER WITH ORDER DETAILS
var emailMessage1 = "Your Order was placed successfully. Thank you for shopping with us.";
var emailMessage2 = "";
string emailBody = _globalRepository.GetMailBodyTemplate(customer.FullName, "", "", emailMessage1, emailMessage2, "activation.html");
var emailSubject = "ORDER PLACED SUCCESSFULLY";
//SEND MAIL TO CUSTOMER
MailModel mailObj = new MailModel(_configuration.GetValue <string>("MercuryMartEmailAddress"), _configuration.GetValue <string>("MercuryMartEmailName"), customer.EmailAddress, emailSubject, emailBody);
var response = await _mailRepository.SendMail(mailObj);
if (!response.StatusCode.Equals(HttpStatusCode.Accepted))
{
return(new ReturnResponse()
{
StatusCode = Utils.MailFailure,
StatusMessage = Utils.StatusMessageMailFailure
});
}
return(new ReturnResponse()
{
StatusCode = Utils.Success,
StatusMessage = Utils.StatusMessageSuccess,
ObjectValue = customerOrder
});
}
