public void PublishBasketCheckout(string queueName, BasketCheckoutEvent publishModel)
{
using (var channel = _connection.CreateModel())
{
// durable: false -> dar memory , true -> dar database
// exclusive: permission mide baraye estefade be baghie connectionha
channel.QueueDeclare(queueName, durable: false, exclusive: false, autoDelete: false); // elam mikone ke ye queue hast
var message = JsonConvert.SerializeObject(publishModel);
var body = Encoding.UTF8.GetBytes(message);
IBasicProperties properties = channel.CreateBasicProperties(); // properties haro sakhtan
properties.Persistent = true;
properties.DeliveryMode = 2;
channel.ConfirmSelect(); // tayidie publisher
channel.BasicPublish(exchange: "", routingKey: queueName, mandatory: true, basicProperties: properties, body: body); // ye message ro publish mikone
channel.WaitForConfirmsOrDie(); // vaymise ta tayidie migire ke hameye message ha publish shode
channel.BasicAcks += (sender, eventArgs) =>
{
Console.WriteLine("Sent to rabbit mq."); // vaqti ye acks az broker miad samte ma in call mishe baraye tayidie
};
channel.ConfirmSelect();
}
}
public void PublishBasketCheckout(string queueName, BasketCheckoutEvent publishModel)
{
using var channel = _connection.CreateModel();
channel.QueueDeclare(queue: queueName, durable: false, // durable means if it is stored in in-memory or disk
exclusive: false, autoDelete: false, arguments: null);
var message = JsonConvert.SerializeObject(publishModel);
var body = Encoding.UTF8.GetBytes(message);
IBasicProperties properties = channel.CreateBasicProperties();
properties.Persistent = true;
properties.DeliveryMode = 2;
channel.ConfirmSelect();
channel.BasicPublish(exchange: "", routingKey: queueName, mandatory: true,
basicProperties: properties, body: body);
channel.WaitForConfirmsOrDie();
channel.BasicAcks += (sender, eventArgs) =>
{
Console.WriteLine("Sent RabbitMQ");
// implement ack handle
};
channel.ConfirmSelect(); // creates a queue inside rabbit mq
}
public void PublishBasketCheckout(string queueName, BasketCheckoutEvent publishModel)
{
using (var channel = rabbitMQConnection.CreateModel())
{
channel.QueueDeclare(queue: queueName,
durable: false,
exclusive: false,
autoDelete: false,
arguments: null);
var message = JsonConvert.SerializeObject(publishModel);
var body = Encoding.UTF8.GetBytes(message);
IBasicProperties basicProperties = channel.CreateBasicProperties();
basicProperties.Persistent = true;
basicProperties.DeliveryMode = 2;
channel.ConfirmSelect();
channel.BasicPublish(
exchange: "",
routingKey: queueName,
mandatory: false,
basicProperties: basicProperties,
body: body
);
channel.WaitForConfirmsOrDie();
channel.BasicAcks += (sender, eventArgs) => {
Console.WriteLine("Sent Message RabbitMQ");
};
channel.ConfirmSelect();
}
}
public void PublishBasketCheckout(string queueName, BasketCheckoutEvent publishModel)
{
using (var channel = _connection.CreateModel())
{
//Name
//Durable(the queue will survive a broker restart)
//Exclusive(used by only one connection and the queue will be deleted when that connection closes)
//Auto - delete(queue that has had at least one consumer is deleted when last consumer unsubscribes)
//Arguments(optional; used by plugins and broker - specific features such as message TTL, queue length limit, etc)
channel.QueueDeclare(queue: queueName, durable: false, exclusive: false, autoDelete: false, arguments: null);
var message = JsonConvert.SerializeObject(publishModel);
var body = Encoding.UTF8.GetBytes(message);
//2 for "persistent", 1 for "transient".Some client libraries expose this property as a boolean or enum.
IBasicProperties properties = channel.CreateBasicProperties();
properties.Persistent = true;
properties.DeliveryMode = 2;
channel.ConfirmSelect();
channel.BasicPublish(exchange: "", routingKey: queueName, mandatory: true, basicProperties: properties, body: body);
channel.WaitForConfirmsOrDie();
channel.BasicAcks += (sender, eventArgs) =>
{
Console.WriteLine("Send RabbitMQ");
};
channel.ConfirmSelect();
}
}
public async Task <IActionResult> Checkout([FromBody] BasketCheckout basketCheckout)
{
BasketCart basketCart = await _repository.GetBasket(basketCheckout.UserName);
if (basketCart == null)
{
return(BadRequest());
}
bool deleteWasSuccessful = await _repository.DeleteBasket(basketCart.UserName);
if (deleteWasSuccessful == false)
{
return(BadRequest());
}
BasketCheckoutEvent basketCheckoutEvent = _mapper.Map <BasketCheckoutEvent>(basketCheckout);
basketCheckoutEvent.RequestId = Guid.NewGuid();
basketCheckoutEvent.TotalPrice = basketCart.TotalPrice;
try
{
_eventBusProducer.PublishBasketCheckout(EventBusConstants.BasketCheckoutQueue, basketCheckoutEvent);
}
catch (Exception)
{
throw;
}
return(Accepted());
}
public void PublishBasketCheckout(string queueName, BasketCheckoutEvent basketCheckoutEvent)
{
using var channel = this.connection.CreateModel();
channel.QueueDeclare(queueName, false, false, false, null);
var message = JsonConvert.SerializeObject(basketCheckoutEvent);
var body = Encoding.UTF8.GetBytes(message);
var properties = channel.CreateBasicProperties();
properties.Persistent = true;
properties.DeliveryMode = 2;
channel.ConfirmSelect();
channel.BasicPublish(
exchange: "",
routingKey: queueName,
mandatory: true,
basicProperties: null,
body: body);
channel.WaitForConfirmsOrDie();
channel.BasicAcks += Channel_BasicAcks;
channel.ConfirmSelect();
}
public async Task Handle(BasketCheckoutEvent @event)
{
var orderId = Guid.NewGuid();
var order = new Order
{
UserId = @event.UserId,
Id = orderId,
OrderPaid = false,
OrderPlaced = DateTime.Now,
OrderTotal = @event.BasketTotal
};
await _mediator.Send(new AddOrderCommand(order));
// Отправляем запрос на оплату заказа.
var orderPaymentRequestEvent = new OrderPaymentRequestEvent
{
CardExpiration = @event.CardExpiration,
CardName = @event.CardName,
CardNumber = @event.CardNumber,
OrderId = orderId,
Total = @event.BasketTotal
};
try
{
_eventBus.Publish(orderPaymentRequestEvent);
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
public void PublishBasketChckout(string queueName, BasketCheckoutEvent publishModel)
{
//https://www.rabbitmq.com/tutorials/tutorial-one-dotnet.html
using (var channel = _connection.CreateModel())
{
channel.QueueDeclare(queue: queueName, durable: false, exclusive: false, autoDelete: false, arguments: null);
/*
* durable:false ==> inmemory if you set true ==> save physicaly
*
*/
var message = JsonSerializer.Serialize(publishModel);
var body = Encoding.UTF8.GetBytes(message);
IBasicProperties properties = channel.CreateBasicProperties();
properties.Persistent = true;
properties.DeliveryMode = 2;
channel.ConfirmSelect();
channel.BasicPublish(exchange: "", routingKey: queueName, mandatory: true, basicProperties: properties, body: body);
channel.WaitForConfirmsOrDie();
channel.BasicAcks += (sender, eventArgs) =>
{
Console.WriteLine("Sent RabbitMQ");
//implement ack handle
};
channel.ConfirmSelect();
}
}
public void PublishBasketCheckout(string queueName, BasketCheckoutEvent checkoutEvent)
{
using var channel = connection.CreateModel();
channel.QueueDeclare(
queue: queueName,
durable: false,
exclusive: false,
autoDelete: false,
null);
var message = JsonConvert.SerializeObject(checkoutEvent);
var body = Encoding.UTF8.GetBytes(message);
IBasicProperties properties = channel.CreateBasicProperties();
properties.Persistent = true;
properties.DeliveryMode = 2;
channel.ConfirmSelect();
channel.BasicPublish(
exchange: string.Empty,
routingKey: queueName,
mandatory: true,
basicProperties: properties,
body: body);
channel.WaitForConfirmsOrDie();
channel.BasicAcks += (sender, eventArgs) =>
{
Console.WriteLine("Sent checkout event to RabbitMQ");
// implement ack handle
};
channel.ConfirmSelect();
}
public void PublishBasketCheckout(string queueName, BasketCheckoutEvent publishModel)
{
using var channel = _connection.CreateModel();
channel.QueueDeclare(queueName, false, false, false, null);
var message = JsonConvert.SerializeObject(publishModel);
var body = Encoding.UTF8.GetBytes(message);
IBasicProperties properties = channel.CreateBasicProperties();
properties.Persistent = true;
properties.DeliveryMode = 2;
channel.ConfirmSelect();
channel.BasicPublish("", queueName, true, properties, body);
channel.WaitForConfirmsOrDie();
channel.BasicAcks += (sender, eventArgs) =>
{
Console.WriteLine("Send rabbitMQ");
};
channel.ConfirmSelect();
}
/// <summary>
/// ایجاد کردن کانال برای صف بندی رویداد های مدل شده از سوی سبد
/// و فرستادن آن به رببیت ام کیو
/// </summary>
/// <param name="queueName">نام صف</param>
/// <param name="publishModel">مدل درخواستی از سوی سبد</param>
public void PublishBasketCheckout(string queueName, BasketCheckoutEvent publishModel)
{
IModel channel = _connection.CreateModel();
using (channel)
{
// ساخت صف برای ذخیره پیام که همان مدل سبد ما می باشد
// در هنگام ساخت صف مشخصاتی از قبیل ذخیره شدن صف در دیتابیس
// حذف کردن صف به صورت خودکار و یکسری مشخصات دیگه می شه اضافه کرد
// که آن ها را مقداردهی کرده ایم
channel.QueueDeclare(queue: queueName, durable: false, exclusive: false, autoDelete: false, arguments: null);
string message = JsonConvert.SerializeObject(publishModel);
byte[] body = Encoding.UTF8.GetBytes(message);
IBasicProperties properties = channel.CreateBasicProperties();
properties.Persistent = true;
properties.DeliveryMode = 2;
/// در اینجا بعد از ساخت صف و درست کردن پیام ارسالی
/// زمان آن رسیده است که آن را انتشار بدیم، برای اینکار
/// یک سری پارامترها رو باید ست کنیم، در اینجا نوع ایکس چنج
/// را حالت پیش فرض در نظر گرفته ایم
channel.ConfirmSelect();
channel.BasicPublish(exchange: "", routingKey: queueName, mandatory: true, basicProperties: properties, body: body);
channel.WaitForConfirmsOrDie();
channel.BasicAcks += (sender, eventArgs) =>
{
Console.WriteLine("Sent RabbitMQ");
// implement ack handle
};
channel.ConfirmSelect();
}
}
public async void CheckoutReturnOkResult()
{
// Arrange
var basketCheckout = new BasketCheckout
{
UserName = "******",
TotalPrice = 1000
};
var basketCheckoutEvent = new BasketCheckoutEvent
{
UserName = "******",
TotalPrice = 500
};
var userName = "******";
//
_mockPublishEndpoint.Setup(x => x.Publish(basketCheckoutEvent, default)).Returns(Task.CompletedTask);
_mockBasketRepository.Setup(x => x.GetBasket(userName)).ReturnsAsync(new ShoppingCart());
_mockBasketRepository.Setup(x => x.DeleteBasket(userName)).Returns(Task.CompletedTask);
this.IntialieBasketController();
// Act
var result = await _sut.Checkout(basketCheckout);
// Assert OkResult
Assert.NotNull(result);
var acceptedResult = Assert.IsType <AcceptedResult>(result);
Assert.Equal(202, acceptedResult.StatusCode);
}
public async void CheckoutReturnInternalServerError()
{
// Arrange
var basketCheckout = new BasketCheckout
{
UserName = "******",
TotalPrice = 1000
};
var basketCheckoutEvent = new BasketCheckoutEvent
{
UserName = "******",
TotalPrice = 500
};
var userName = "******";
//
_mockPublishEndpoint.Setup(x => x.Publish(basketCheckoutEvent, default)).Returns(Task.CompletedTask);
_mockBasketRepository.Setup(x => x.GetBasket(userName)).ReturnsAsync(new ShoppingCart());
_mockBasketRepository.Setup(x => x.DeleteBasket(userName)).ThrowsAsync(new System.Exception());
this.IntialieBasketController();
// Act
var result = await _sut.Checkout(basketCheckout);
// Assert OkResult
Assert.NotNull(result);
var objResult = Assert.IsType <ObjectResult>(result);
Assert.Equal(500, objResult.StatusCode.Value);
}
public async Task <IActionResult> Checkout([FromBody] BasketCheckout basketCheckout)
{
BasketCart basket = await _repository.GetBasket(basketCheckout.UserName);
if (basket == null)
{
return(BadRequest());
}
bool basketRemoved = await _repository.DeleteBasket(basket.UserName);
if (!basketRemoved)
{
return(BadRequest());
}
BasketCheckoutEvent eventMessage = _mapper.Map <BasketCheckoutEvent>(basketCheckout);
eventMessage.RequestId = Guid.NewGuid();
eventMessage.TotalPrice = basket.TotalPrice;
try
{
_eventBus.PublishBasketCheckout(EventBusConstants.BasketCheckoutQueue, eventMessage);
}
catch (Exception)
{
throw;
}
return(Accepted());
}
public void PublishBasketCheckout(string queueName, BasketCheckoutEvent publishModel)
{
using (var channel = _connection.CreateModel())
{
// Declare queue
// durable - to be stored in memory of physical, default is memory
// exclusive - giving permission to use with other connection
channel.QueueDeclare(queue: queueName, durable: false, exclusive: false, autoDelete: false, arguments: null);
var message = JsonConvert.SerializeObject(publishModel); // Checkout event
var body = Encoding.UTF8.GetBytes(message);
// Basic properties
IBasicProperties properties = channel.CreateBasicProperties();
properties.Persistent = true;
properties.DeliveryMode = 2;
// Publish queue to rabbit mq
channel.ConfirmSelect();
// Allows message to be recieved and sent queue.
channel.BasicPublish(exchange: "", routingKey: queueName, mandatory: true, basicProperties: properties, body: body);
channel.WaitForConfirmsOrDie();
// Ack definition - Хүлээн авалтыг батлах тэмдэгт
channel.BasicAcks += (sender, EventArgs) =>
{
Console.WriteLine("Sent RabbitMQ");
};
channel.ConfirmSelect();
}
}
public async Task OnCheckout(BasketCheckoutEvent message)
{
foreach (var item in message.Source.Items)
{
await DecrementStock(item.SKU, item.Quantity);
}
}
public async Task <ActionResult> SendToQueue()
{
var basketCheckout = new BasketCheckoutEvent();
_eventBusRabbitMqProducer.Publish(basketCheckout);
return(Ok());
}
public static BasketCheckoutEvent ToEvent(
this BasketCheckoutModel source,
ICollection <BasketLine> basketLines = null,
CouponModel coupon = null)
{
if (source == null)
{
return(null);
}
var basketCheckoutEvent = new BasketCheckoutEvent
{
Address = source.Address,
City = source.City,
Country = source.Country,
Email = source.Email,
BasketId = source.BasketId,
BasketTotal = 0,
CardExpiration = source.CardExpiration,
CardName = source.CardName,
CardNumber = source.CardNumber,
FirstName = source.FirstName,
LastName = source.LastName,
UserId = source.UserId,
ZipCode = source.ZipCode
};
if (basketLines == null || !basketLines.Any())
{
return(basketCheckoutEvent);
}
basketCheckoutEvent.BasketLines = new List <BasketLineEvent>();
foreach (var basketLine in basketLines.ToList())
{
var basketLineEvent = new BasketLineEvent
{
BasketLineId = basketLine.BasketLineId,
Price = basketLine.Price,
TicketAmount = basketLine.TicketAmount
};
basketCheckoutEvent.BasketTotal += basketLine.Price * basketLine.TicketAmount;
basketCheckoutEvent.BasketLines.Add(basketLineEvent);
}
if (coupon == null)
{
return(basketCheckoutEvent);
}
basketCheckoutEvent.BasketTotal -= coupon.Amount;
return(basketCheckoutEvent);
}
private async void ReceivedEvent(object sender, BasicDeliverEventArgs e)
{
if (e.RoutingKey == EventBusConstants.BasketCheckoutQueue)
{
string message = Encoding.UTF8.GetString(e.Body.Span);
BasketCheckoutEvent basketCheckoutEvent = JsonConvert.DeserializeObject <BasketCheckoutEvent>(message);
CheckoutOrderCommand command = mapper.Map <CheckoutOrderCommand>(basketCheckoutEvent);
Application.Responses.OrderResponse result = await mediator.Send(command);
}
}
public IIntegrationMessage OnCheckout(BasketCheckoutEvent message) =>
new Integration.Events.BasketCheckoutEvent
{
Items = message.Source.Items.Select(i =>
new BasketItemDto
{
Name = i.Name,
SKU = i.SKU,
Quantity = i.Quantity,
UnitPrice = i.UnitPrice
}).ToList()
};
/**
* Event used for microservices
* CLASS 59
*/
public void PublishBasketCheckout(string queueName, BasketCheckoutEvent publishModel)
{
using (var channel = _connection.CreateModel())
{
// Durable :
// TRUE: that means you would like to save this queue with physically memory
// FALSE: store data in memory
// Exclusive
// It is giving you permission to use of its other connection
// false: we don't need to use and this queue with other connections
// AutoDelete:
// Its determined to automate deletion or not
// Arguments
// is parameters related with determined to exchange, if you have any additional args with these queue and exchange
channel.QueueDeclare(queue: queueName, durable: false, exclusive: false, autoDelete: false,
arguments: null);
// before use JsonConvert.SerializeObject install Newtonsoft.Json
var message = JsonConvert.SerializeObject(publishModel);
// converting the byte format our published model basketCheckoutEvent
var body = Encoding.UTF8.GetBytes(message);
//=====================================================================================================
// for more information about this params, check RabbitMQ documentation
IBasicProperties properties = channel.CreateBasicProperties();
properties.Persistent = true;
properties.DeliveryMode = 2;
//====================================================================================================
//properties: we give the basic properties, body also define it in here
// queueName: is mandatory
// BasicPublish(): allow to message to be received and sent to queue
// It is using the root algorithm
// exchange: direct - fanout - topic
channel.ConfirmSelect();
channel.BasicPublish(exchange: "", routingKey: queueName, mandatory: true, basicProperties: properties,
body: body);
channel.WaitForConfirmsOrDie();
//====================================================================================================
//A C K definition
// these operation provide to create a queue inside the rabbitMQ
// REVIEW MORE IN RABBITMQ DOC
channel.BasicAcks += (sender, eventArgs) => { Console.WriteLine("SENT_____R A B B I T MQ"); };
channel.ConfirmSelect();
}
}
public async Task <IActionResult> Checkout(BasketCheckout checkout)
{
BasketCart basket = await _basketRepository.GetBasket(checkout.userName);
if (basket == null)
{
return(BadRequest());
}
var basketRemoved = await _basketRepository.DeleteBasket(basket.UserName);
if (!basketRemoved)
{
return(BadRequest());
}
//var eventMessage = _mapper.Map <BasketCheckoutEvent>(basket);
var eventMessage = new BasketCheckoutEvent {
AddressLine = checkout.AddressLine,
CardName = checkout.CardName,
CardNumber = checkout.CardNumber,
Country = checkout.Country,
CVV = checkout.CVV,
EmailAddress = checkout.EmailAddress,
Expiration = checkout.Expiration,
FirstName = checkout.FirstName,
LastName = checkout.LastName,
PaymentMethod = checkout.PaymentMethod,
State = checkout.State,
TotalPrice = checkout.TotalPrice,
userName = checkout.userName,
ZipCode = checkout.ZipCode
};
eventMessage.RequestId = Guid.NewGuid();
eventMessage.TotalPrice = basket.TotalPrice;
try
{
_eventBus.PublishBasketCheckout(EventBusConstants.BasketCheckoutQueue, eventMessage);
}
catch (Exception ex)
{
return(BadRequest());
}
return(Accepted(basket));
}
public void PublishBasketCheckout(string queueName, BasketCheckoutEvent checkoutEvent)
{
using IModel channel = connection.CreateModel();
channel.QueueDeclare(queue: queueName, durable: false, exclusive: false, autoDelete: false, arguments: null);
string message = JsonConvert.SerializeObject(checkoutEvent);
byte[] body = Encoding.UTF8.GetBytes(message);
IBasicProperties properties = channel.CreateBasicProperties();
properties.Persistent = true;
properties.DeliveryMode = 2;
channel.ConfirmSelect();
channel.BasicPublish(exchange: "", routingKey: queueName, mandatory: true, basicProperties: properties, body: body);
channel.WaitForConfirmsOrDie();
channel.BasicAcks += (sender, ebentArgs) =>
{
Console.WriteLine("Sent RabitMQ");
//implement acks handle
};
channel.ConfirmSelect();
//using (IModel channel = connection.CreateModel())
//{
// channel.QueueDeclare(queue: queueName, durable: false, exclusive: false, autoDelete: false, arguments: null);
// string message = JsonConvert.SerializeObject(checkoutEvent);
// byte[] body = Encoding.UTF8.GetBytes(message);
// IBasicProperties properties = channel.CreateBasicProperties();
// properties.Persistent = true;
// properties.DeliveryMode = 2;
// channel.ConfirmSelect();
// channel.BasicPublish(exchange: "", routingKey: queueName, mandatory: true, basicProperties: properties, body: body);
// channel.WaitForConfirmsOrDie();
// channel.BasicAcks += (sender, ebentArgs) =>
// {
// Console.WriteLine("Sent RabitMQ");
// //implement acks handle
// };
// channel.ConfirmSelect();
//}
}
private async void ReceivedEvent(object sender, BasicDeliverEventArgs eventArgs)
{
Console.WriteLine($"ReceivedEvent {eventArgs.RoutingKey}");
if (eventArgs.RoutingKey == EventBusConstant.BasketCheckoutQueue)
{
// get message
var message = Encoding.UTF8.GetString(eventArgs.Body.Span);
// deserialize it
BasketCheckoutEvent basketCheckoutEvent = JsonConvert.DeserializeObject <BasketCheckoutEvent>(message);
// map this event to command
CheckoutOrderCommand command = basketCheckoutEvent.Adapt <CheckoutOrderCommand>();
var response = await _mediator.Send(command);
}
}
public void PublishBasketCheckout(EventBusEnum queueName, BasketCheckoutEvent publishModel)
{
using var channel = _mqConnection.CreateModel();
channel.QueueDeclare(queueName.ToString(), durable: false, exclusive: false, autoDelete: false, arguments: null);
var message = JsonSerializer.Serialize(publishModel);
var body = Encoding.UTF8.GetBytes(message);
var bp = channel.CreateBasicProperties();
bp.Persistent = true;
bp.DeliveryMode = 2;
channel.ConfirmSelect();
channel.BasicPublish(exchange: "", routingKey: queueName.ToString(), mandatory: true, basicProperties: bp, body: body);
channel.WaitForConfirmsOrDie();
channel.BasicAcks += (sender, args) => { Console.WriteLine($"sent rabbit MQ {publishModel}"); };
channel.ConfirmSelect();
}
public void PublishBasketCheckout(string queueName, BasketCheckoutEvent publishModel)
{
using (var channel = _connection.CreateModel())
{
channel.QueueDeclare
(
queue: queueName,
durable: false,
exclusive: false,
autoDelete: false,
arguments: null
);
string serializedMessage = JsonConvert.SerializeObject(publishModel);
Console.WriteLine("[EventBusRabbitMQProducer][PublishBasketCheckout] => (serializedMessage): ");
Console.WriteLine(serializedMessage);
Console.WriteLine("");
byte[] messageByteArray = Encoding.UTF8.GetBytes(serializedMessage);
IBasicProperties basicProps = channel.CreateBasicProperties();
basicProps.Persistent = true;
basicProps.DeliveryMode = 2;
channel.ConfirmSelect();
channel.BasicPublish
(
exchange: "",
routingKey: queueName,
mandatory: true,
basicProperties: basicProps,
body: messageByteArray
);
channel.WaitForConfirmsOrDie();
channel.BasicAcks += (sender, eventArgs) =>
{
Console.WriteLine("[EventBusRabbitMQProducer][PublishBasketCheckout] => (IN 'channel.BasicAcks')");
};
channel.ConfirmSelect();
}
}
public void PublishBasketCheckout(string queueName, BasketCheckoutEvent model)
{
using (var channel = _connection.CreateModel())
{
channel.QueueDeclare(queueName, false, false, false, null);
var properties = channel.CreateBasicProperties();
properties.Persistent = true;
properties.DeliveryMode = 2; // persistent
var message = JsonConvert.SerializeObject(model);
var body = Encoding.UTF8.GetBytes(message);
channel.ConfirmSelect();
channel.BasicPublish("", queueName, true, properties, body);
channel.WaitForConfirmsOrDie();
channel.BasicAcks += Channel_BasicAcks;
channel.ConfirmSelect();
}
}
public async Task <ActionResult <BasketCart> > Checkout([FromBody] BasketCheckout basketCheckout)
{
try
{
// get basket
BasketCart basketCart = await _basketRepository.GetBasket(basketCheckout.UserName);
if (basketCart == null)
{
return(BadRequest());
}
// remove basket
// bool result = await _basketRepository.DeleteBasket(basketCheckout.UserName);
//
// if (result == false)
// {
// return BadRequest();
// }
BasketCheckoutEvent basketCheckoutEvent = basketCheckout.Adapt <BasketCheckoutEvent>();
basketCheckoutEvent.RequestId = Guid.NewGuid();
basketCheckoutEvent.TotalPrice = basketCart.TotalPrice.ToString(CultureInfo.InvariantCulture);
try
{
_eventBus.PublishBasketCheckout(EventBusConstant.BasketCheckoutQueue, basketCheckoutEvent);
}
catch (Exception)
{
throw;
}
return(Accepted());
}
catch (Exception)
{
return(BadRequest());
}
}
public void Publish(BasketCheckoutEvent basketCheckoutEvent)
{
//TODO channel confirmation etc...
string json = JsonConvert.SerializeObject(basketCheckoutEvent);
var body = Encoding.UTF8.GetBytes(json);
var channel = _rabbitMqConnection.CreateModel();
channel.QueueDeclare(queue: "test",
durable: false,
exclusive: false,
autoDelete: false,
arguments: null);
channel.BasicPublish(exchange: "",
routingKey: "test",
basicProperties: null,
body: body);
}
public void PublishBasketCheckout(string queueName, BasketCheckoutEvent publishModel)
{
using (var channel = _connection.CreateModel())
{
channel.QueueDeclare(
queue: queueName,
durable: false,
exclusive: false,
autoDelete: false,
arguments: null
);
var message = JsonConvert.SerializeObject(publishModel);
var body = Encoding.UTF8.GetBytes(message);
IBasicProperties properties = channel.CreateBasicProperties();
properties.Persistent = true;
properties.DeliveryMode = 2;
// https://rabbitmq.com/tutorials/amqp-concepts.html
channel.ConfirmSelect();
channel.BasicPublish(
exchange: "", // Direct exchg (empty str == amq.direct)
routingKey: queueName,
mandatory: true,
basicProperties: properties,
body: body
);
channel.WaitForConfirmsOrDie();
channel.BasicAcks += (sender, EventArgs) =>
{
Console.WriteLine("Sent msg acknowledge to RabbitMQ");
//implement ack handle
};
channel.ConfirmSelect();
}
}
