static void Main(string[] args)
{
Console.WriteLine("TextStatistics has started...");
var rabbitMq = new RabbitMq();
rabbitMq.QueueDeclare();
rabbitMq.ExchangeDeclare("text-rank-calc", ExchangeType.Fanout);
rabbitMq.BindQueueToExchange("text-rank-calc");
rabbitMq.ConsumeQueue(message =>
{
var info = message.Split('|');
var contextId = info[0];
var rank = Convert.ToDecimal(info[1]);
RedisHelper.Instance.Increment("textNum");
if (rank > (decimal)0.5)
{
RedisHelper.Instance.Increment("highRankPart");
}
RedisHelper.Instance.Increment("ranksSum", rank);
var textNum = Convert.ToDecimal(RedisHelper.Instance.Database.StringGet("textNum"));
var ranksSum = Convert.ToDecimal(RedisHelper.Instance.Database.StringGet("ranksSum"));
RedisHelper.Instance.Database.StringSet("avgRank", $"{ranksSum/textNum}");
Console.WriteLine($" [x] TextNum: {textNum}, ranksSum: {ranksSum}, rankSum: {ranksSum/textNum}");
});
Console.WriteLine(" Press [enter] to exit.");
Console.ReadKey();
}
static void Main()
{
var rabbitMq = new RabbitMq();
rabbitMq.QueueDeclare(_queueName);
rabbitMq.ExchangeDeclare(_listeningExchangeName, ExchangeType.Direct);
rabbitMq.BindQueueToExchange(_listeningExchangeName);
rabbitMq.ConsumeQueue(textId =>
{
Console.WriteLine($"New message from {_listeningExchangeName}: \"{textId}\"");
Redis.Instance.SetDatabase(Redis.Instance.CalculateDatabase(textId));
string text = Redis.Instance.Database.StringGet($"{ConstantLibrary.Redis.Prefix.Text}{textId}");
Console.WriteLine($"'{ConstantLibrary.Redis.Prefix.Text}{textId}: {text}' from redis database({Redis.Instance.Database.Database})");
VowelConsonant vowelConsonant = CalculateVowelConsonant(text);
Console.WriteLine($"'{ConstantLibrary.Redis.Prefix.Count}{textId}: {vowelConsonant.vowelCount}|{vowelConsonant.consonantCount}' to redis database({Redis.Instance.Database.Database})");
Redis.Instance.Database.StringSet($"{ConstantLibrary.Redis.Prefix.Count}{textId}", $"{vowelConsonant.vowelCount}|{vowelConsonant.consonantCount}");
Console.WriteLine($"{textId} to {_publishExchangeName} exchange");
rabbitMq.PublishToExchange(_publishExchangeName, textId);
Console.WriteLine("----------");
});
Console.WriteLine("VowelConsonantCounter has started");
Console.WriteLine("Press [enter] to exit.");
Console.ReadLine();
}
public void with_password_set_should_get()
{
var sut = new RabbitMq();
sut.Password = "******";
Assert.AreEqual("foo", sut.Password);
}
public void with_port_set_should_get()
{
var sut = new RabbitMq();
sut.Port = 1234;
Assert.AreEqual(1234, sut.Port);
}
public void with_host_set_should_get()
{
var sut = new RabbitMq();
sut.Host = "foo";
Assert.AreEqual("foo", sut.Host);
}
public ActionResult Post(List <Pagina> Paginas)
{
try
{
RabbitMq rabbitmq = new RabbitMq();
rabbitmq.Channel.QueueDeclare(queue: "FilaRabbit",
durable: false,
exclusive: false,
autoDelete: false,
arguments: null);
var msg = JsonConvert.SerializeObject(Paginas);
var body = Encoding.UTF8.GetBytes(msg);
rabbitmq.Channel.BasicPublish(exchange: "",
routingKey: "FilaRabbit",
basicProperties: null,
body: body);
return(StatusCode(200, JsonConvert.SerializeObject("Fila gravada com sucesso!")));
}
catch (RabbitMQ.Client.Exceptions.RabbitMQClientException e)
{
return(StatusCode(400, JsonConvert.SerializeObject(e.StackTrace)));
}
}
public void with_username_set_should_get()
{
var sut = new RabbitMq();
sut.Username = "******";
Assert.AreEqual("bar", sut.Username);
}
public void ConfigureServices(IServiceCollection services)
{
services.ConfigureRedis(options =>
{
Configuration.GetSection("Redis").Bind(options);
});
services.AddHealthChecks();
services.AddControllers()
.AddControllersAsServices();
services.AddMassTransit(x =>
{
x.SetKebabCaseEndpointNameFormatter();
x.UsingRabbitMq((context, cfg) =>
{
var rabbitMqConfiguration = new RabbitMq();
Configuration.GetSection("RabbitMq").Bind(rabbitMqConfiguration);
cfg.Host(rabbitMqConfiguration.HostAddress, rabbitMqConfiguration.VirtualHost, (cfg) =>
{
cfg.Username(rabbitMqConfiguration.Username);
cfg.Password(rabbitMqConfiguration.Password);
});
cfg.ConfigureEndpoints(context);
});
x.AddRequestClient <IWhoAmICommand>();
});
services.AddMassTransitHostedService();
services.AddSwaggerGen();
}
static void Main()
{
var rabbitMq = new RabbitMq();
rabbitMq.QueueDeclare();
rabbitMq.ExchangeDeclare(_listeningExchangeName, ExchangeType.Fanout);
rabbitMq.BindQueueToExchange(_listeningExchangeName);
rabbitMq.ConsumeQueue(textId =>
{
Console.WriteLine($"New message from {_listeningExchangeName}: \"{textId}\"");
Redis.Instance.SetDatabase(Redis.Instance.CalculateDatabase(textId));
double rank = Double.Parse(Redis.Instance.Database.StringGet($"{ConstantLibrary.Redis.Prefix.Rank}{textId}"));
Console.WriteLine($"'{ConstantLibrary.Redis.Prefix.Rank}{textId}: {rank}' from redis database({Redis.Instance.Database.Database})");
var stringToPublish = $"{textId}{ConstantLibrary.RabbitMq.Delimiter}" +
(rank > _successLowerBound
? ConstantLibrary.RabbitMq.TextSuccessMarker.Status.True
: ConstantLibrary.RabbitMq.TextSuccessMarker.Status.False);
Console.WriteLine($"{stringToPublish} to {_publishExchangeName} exchange");
rabbitMq.PublishToExchange(_publishExchangeName, stringToPublish);
Console.WriteLine("----------");
});
Console.WriteLine($"TextSuccessMarker has started. Success lower bound is {_successLowerBound}");
Console.WriteLine("Press [enter] to exit.");
Console.ReadLine();
}
static void Main()
{
var rabbitMq = new RabbitMq();
rabbitMq.QueueDeclare(queueName);
rabbitMq.ExchangeDeclare(exchangeName, ExchangeType.Direct);
rabbitMq.BindQueueToExchange(exchangeName);
rabbitMq.ConsumeQueue(textId =>
{
Redis.Instance.SetDatabase(Redis.Instance.CalculateDatabase(textId));
string countKey = $"{ConstantLibrary.Redis.Prefix.Count}{textId}";
string countDataString = Redis.Instance.Database.StringGet(countKey);
Console.WriteLine($"'{ConstantLibrary.Redis.Prefix.Count}{textId}: {countDataString}' from redis database({Redis.Instance.Database.Database})");
Redis.Instance.Database.KeyDelete(countKey);
Console.WriteLine($"'{ConstantLibrary.Redis.Prefix.Count}{textId}: {countDataString}' deleted rfrom redis database({Redis.Instance.Database.Database})");
string[] countData = countDataString.Split('|');
int vowelCount;
int consonantCount;
if (Int32.TryParse(countData[0], out vowelCount) && Int32.TryParse(countData[1], out consonantCount))
{
string rank = CalculateRank(vowelCount, consonantCount);
Redis.Instance.Database.StringSet($"{ConstantLibrary.Redis.Prefix.Rank}{textId}", rank);
Console.WriteLine($"'{ConstantLibrary.Redis.Prefix.Rank}{textId}: {rank}' to redis database({Redis.Instance.Database.Database})");
}
});
Console.WriteLine("VowelConsonantRater has started");
Console.WriteLine("Press [enter] to exit.");
Console.ReadLine();
}
public Consumer()
{
if (_rabbitMQService == null)
{
_rabbitMQService = new RabbitMq();
}
}
static void Main(string[] args)
{
Console.WriteLine("TextStatistics has started...");
var rabbitMq = new RabbitMq();
rabbitMq.QueueDeclare();
rabbitMq.ExchangeDeclare("text-success-marker", ExchangeType.Fanout);
rabbitMq.BindQueueToExchange("text-success-marker");
rabbitMq.ConsumeQueue(message =>
{
Console.WriteLine($" [x] message: {message}");
var info = message.Split('|');
var contextId = info[0];
var isSuccess = info[1];
Console.WriteLine($" [x] contextId: {contextId}, isSuccess: {isSuccess}");
RedisHelper.Instance.Increment("textNum");
if (isSuccess == "True")
{
RedisHelper.Instance.Increment("highRankPart");
}
var rank = Convert.ToDecimal(RedisHelper.Instance.Database.StringGet($"rank_{contextId}"));
RedisHelper.Instance.Increment("ranksSum", rank);
var textNum = Convert.ToDecimal(RedisHelper.Instance.Database.StringGet("textNum"));
var ranksSum = Convert.ToDecimal(RedisHelper.Instance.Database.StringGet("ranksSum"));
RedisHelper.Instance.Database.StringSet("avgRank", $"{ranksSum/textNum}");
Console.WriteLine($" [x] TextNum: {textNum}, ranksSum: {ranksSum}, rankSum: {ranksSum/textNum}");
});
Console.WriteLine(" Press [enter] to exit.");
Console.ReadKey();
}
static void Main(string[] args)
{
RedisHelper redishelper = new RedisHelper();
var rabbitMq = new RabbitMq();
rabbitMq.QueueDeclare();
rabbitMq.ExchangeDeclare("backend-api", ExchangeType.Fanout);
rabbitMq.BindQueueToExchange("backend-api");
rabbitMq.ConsumeQueue(message =>
{
string redisValue = String.Empty;
redisValue = redishelper.Database.StringGet(message);
Console.WriteLine(" [x] Received from redis {0} with key: {1}", redisValue, message);
});
Console.WriteLine(" Press [enter] to exit.");
Console.ReadKey();
/* using(var channel = RabbitMQ.RabbitMq.GetModel())
* {
* RabbitMQHelper.DeclareExchangeQueue("backend-api", channel);
* string queueName = channel.QueueDeclare().QueueName;
*
* RabbitMQHelper.BindQueueToExchange("backend-api", channel, queueName);
* var consumer = RabbitMQHelper.GetConsumer(channel);
* consumer.Received += (model, ea) =>
* {
*
* };
*
* RabbitMQHelper.ConsumeQueue("backend-api", consumer, channel);
*
* } */
}
static void Main(string[] args)
{
var mq = new RabbitMq();
mq.Send("kevin sending from vs");
#region create exchange/queue/binding
var queueName = "myqueuefromvs";
//model.QueueDeclare(queueName, true, false, false, null);
//Console.WriteLine("queue created");
//var exchangeName = "myexchangefromvs";
var exchangeName = "";
//model.ExchangeDeclare(exchangeName, ExchangeType.Topic);
//Console.WriteLine("exchange created");
//var routingKey = "cars";
//model.QueueBind(queueName, exchangeName, routingKey);
//Console.WriteLine("exchage and queue bound");
#endregion
#region sending
//var properties = model.CreateBasicProperties();
//properties.Persistent = false
Console.WriteLine("Message sent");
#endregion
Console.ReadLine();
}
static void Main()
{
var rabbitMq = new RabbitMq();
rabbitMq.QueueDeclare(queueName);
rabbitMq.ExchangeDeclare(exchangeName, ExchangeType.Direct);
rabbitMq.BindQueueToExchange(exchangeName);
rabbitMq.ConsumeQueue(countId =>
{
string[] countData = Redis.Instance.Database.StringGet(countId).ToString().Split('|');
string text = Redis.Instance.Database.StringGet(countData[0]);
int vowelCount;
int consonantCount;
if (Int32.TryParse(countData[1], out vowelCount) && Int32.TryParse(countData[2], out consonantCount))
{
string rate = CalculateRate(vowelCount, consonantCount);
Console.WriteLine($"'{text}: {rate}' to redis");
Redis.Instance.Database.StringSet(text, rate);
}
});
Console.WriteLine("VowelConsonantRater has started");
Console.WriteLine("Press [enter] to exit.");
Console.ReadLine();
}
static void Main(string[] args)
{
Console.WriteLine("VowelConsCounter has started...");
RedisHelper redis = new RedisHelper();
var rabbitMq = new RabbitMq();
rabbitMq.QueueDeclare();
rabbitMq.ExchangeDeclare("text-rank-tasks", ExchangeType.Direct);
rabbitMq.ExchangeDeclare("vowel-cons-counter", ExchangeType.Direct);
rabbitMq.BindQueueToExchange("text-rank-tasks");
rabbitMq.ConsumeQueue(message =>
{
string redisValue = String.Empty;
redisValue = redis.Database.StringGet(message);
var vowelConsNum = TextRankCalc.Calc(redisValue);
rabbitMq.PublishToExchange("vowel-cons-counter", $"{message}|{vowelConsNum.Consonants}|{vowelConsNum.Vowels}");
Console.WriteLine(" [x] Received from redis {0} with key: {1} equals {2}", redisValue, message, $"{vowelConsNum.Consonants}|{vowelConsNum.Vowels}");
});
Console.WriteLine(" Press [enter] to exit.");
Console.ReadKey();
}
static void Main(string[] args)
{
Console.WriteLine("VowelConsRater has started...");
var rabbitMq = new RabbitMq();
string rankPrefix = "rank_";
rabbitMq.QueueDeclare();
rabbitMq.ExchangeDeclare("vowel-cons-counter", ExchangeType.Direct);
rabbitMq.ExchangeDeclare("text-rank-calc", ExchangeType.Fanout);
rabbitMq.BindQueueToExchange("vowel-cons-counter");
rabbitMq.ConsumeQueue(message =>
{
var info = message.Split('|');
var contextId = info[0];
var volwes = info[1];
var cons = info[2];
var rank = TextRankCalc.Calc(Decimal.Parse(volwes), Decimal.Parse(cons));
var databaseId = RedisHelper.Instance.CalculateDatabase(contextId);
RedisHelper.Instance.SetDatabase(databaseId);
RedisHelper.Instance.Database.StringSet($"{rankPrefix}{contextId}", $"{rank.ToString()}");
rabbitMq.PublishToExchange("text-rank-calc", $"{contextId}|{rank}");
Console.WriteLine(" [x] Received from redis {0} with key: {1} equals {2}", message, rank);
});
Console.WriteLine(" Press [enter] to exit.");
Console.ReadKey();
}
static void Main(string[] args)
{
Console.WriteLine("TextRankCalck has started...");
RedisHelper redis = RedisHelper.Instance;
var rabbitMq = new RabbitMq();
rabbitMq.QueueDeclare();
rabbitMq.ExchangeDeclare("processing-limiter", ExchangeType.Fanout);
rabbitMq.ExchangeDeclare("text-rank-tasks", ExchangeType.Direct);
rabbitMq.BindQueueToExchange("processing-limiter");
rabbitMq.ConsumeQueue(message =>
{
Console.WriteLine($"Acepted message {message}");
string[] splittedMessage = message.Split('|');
string textId = splittedMessage[0];
bool doesTextAllowed = splittedMessage[1] == "True";
if (!doesTextAllowed)
{
Console.WriteLine($"{message} not allowed");
return;
}
RedisHelper.Instance.SetDatabase(RedisHelper.Instance.CalculateDatabase(textId));
if (RedisHelper.Instance.Database.StringGet($"status_{textId}") != Status.Accepted)
{
Console.WriteLine($"'status_{textId}: {Status.Processing}' to redis database({RedisHelper.Instance.Database.Database})");
RedisHelper.Instance.Database.StringSet($"status_{textId}", Status.Processing);
}
rabbitMq.PublishToExchange("text-rank-tasks", textId);
});
Console.WriteLine(" Press [enter] to exit.");
Console.ReadKey();
}
static void Main(string[] args)
{
string rankString = "rank_";
RedisHelper redishelper = RedisHelper.Instance;
var rabbitMq = new RabbitMq();
rabbitMq.QueueDeclare();
rabbitMq.ExchangeDeclare(_listeningExchangeName, ExchangeType.Fanout);
rabbitMq.BindQueueToExchange(_listeningExchangeName);
rabbitMq.ConsumeQueue(message =>
{
Console.WriteLine($"New message from {_listeningExchangeName}: \"{message}\"");
var info = message.Split('|');
var textId = info[0];
var rank = Double.Parse(info[1]);
redishelper.SetDatabase(redishelper.CalculateDatabase(textId));
Console.WriteLine($"'{rankString}{textId}: {rank}'");
var stringToPublish = $"{textId}|" +
(rank > _successLowerBound
? "True"
: "False");
Console.WriteLine($"{stringToPublish} to {_publishExchangeName} exchange");
rabbitMq.PublishToExchange(_publishExchangeName, stringToPublish);
Console.WriteLine("----------");
});
Console.WriteLine($"TextSuccessMarker has started. Success lower bound is {_successLowerBound}");
Console.WriteLine("Press [enter] to exit.");
Console.ReadLine();
}
public void with_no_value_should_set_default_values()
{
var sut = new RabbitMq();
Assert.AreEqual("localhost", sut.Host);
Assert.AreEqual(5672, sut.Port);
Assert.IsNull(sut.Username);
Assert.IsNull(sut.Password);
}
protected override Task ExecuteAsync(CancellationToken stoppingToken)
{
stoppingToken.ThrowIfCancellationRequested();
RabbitMq.Consume <CreateFinancialTransactionCommand>(Received <CreateFinancialTransactionCommand, Result <CreateFinancialTransactionResult> >);
RabbitMq.Consume <ListFinancialTransactionsQuery>(Received <ListFinancialTransactionsQuery, Result <ListFinancialTransactionsResult> >);
return(base.ExecuteAsync(stoppingToken));
}
static void Main(string[] args)
{
string statusOfText = "status_";
RedisHelper redishelper = RedisHelper.Instance;
var rabbitMq = new RabbitMq();
rabbitMq.QueueDeclare();
rabbitMq.ExchangeDeclare("backend-api", ExchangeType.Fanout);
rabbitMq.BindQueueToExchange("backend-api");
rabbitMq.ConsumeQueue(message =>
{
Console.WriteLine($"New message from text-rank-calc: \"{message}\"");
redishelper.SetDatabase(redishelper.CalculateDatabase(message));
bool status = _succeededTextCount < _limit;
if (status)
{
++_succeededTextCount;
Console.WriteLine($"'{statusOfText}{message}: {Status.Accepted}', redishelper.Database: {redishelper.Database.Database}");
redishelper.Database.StringSet($"{statusOfText}{message}", Status.Accepted);
}
else
{
Console.WriteLine($"'{statusOfText}{message}: {Status.Rejected}'redishelper.Database: {redishelper.Database.Database}");
redishelper.Database.StringSet($"{statusOfText}{message}", Status.Rejected);
}
var stringToPublish = $"{message}|" +
(status ? "True" : "False");
Console.WriteLine($"{stringToPublish} to 'processing-limiter' exchange");
rabbitMq.PublishToExchange("processing-limiter", stringToPublish);
});
rabbitMq.QueueDeclare();
rabbitMq.ExchangeDeclare("text-success-marker", ExchangeType.Fanout);
rabbitMq.BindQueueToExchange("text-success-marker");
rabbitMq.ConsumeQueue(message =>
{
Console.WriteLine($"New message from 'text-success-marker': \"{message}\"");
string[] data = message.Split('|');
bool isTextSucceeded = data[1] == "True";
if (!isTextSucceeded)
{
Console.WriteLine("Succeeded text count reset");
_succeededTextCount -= 1;
}
Console.WriteLine("----------");
});
Console.WriteLine("TextProcessingLimiter has started");
Console.WriteLine("Press [enter] to exit.");
Console.ReadLine();
}
protected override Task ExecuteAsync(CancellationToken stoppingToken)
{
stoppingToken.ThrowIfCancellationRequested();
RabbitMq.Consume <SignUpCommand>(Received <SignUpCommand, Result <SignUpResult> >);
RabbitMq.Consume <SignInCommand>(Received <SignInCommand, Result <SignInResult> >);
RabbitMq.Consume <ValidateTokenCommand>(Received <ValidateTokenCommand, Result <ValidateTokenResult> >);
return(base.ExecuteAsync(stoppingToken));
}
static void Main(string[] args)
{
Console.WriteLine("Starting service...");
var mq = new RabbitMq();
var queueName = "kevinQueue";
mq.Receive(queueName);
Console.WriteLine("press enter to exit");
Console.ReadLine();
}
static void Main()
{
var rabbitMq = new RabbitMq();
rabbitMq.QueueDeclare();
rabbitMq.ExchangeDeclare(_textListeningExchangeName, ExchangeType.Fanout);
rabbitMq.BindQueueToExchange(_textListeningExchangeName);
rabbitMq.ConsumeQueue(textId =>
{
Console.WriteLine($"New message from {_textListeningExchangeName}: \"{textId}\"");
Redis.Instance.SetDatabase(Redis.Instance.CalculateDatabase(textId));
bool status = _succeededTextCount < _limit;
if (status)
{
++_succeededTextCount;
Console.WriteLine($"'{ConstantLibrary.Redis.Prefix.Status}{textId}: {ConstantLibrary.Redis.Status.Accepted}' to redis database({Redis.Instance.Database.Database})");
Redis.Instance.Database.StringSet($"{ConstantLibrary.Redis.Prefix.Status}{textId}", ConstantLibrary.Redis.Status.Accepted);
}
else
{
Console.WriteLine($"'{ConstantLibrary.Redis.Prefix.Status}{textId}: {ConstantLibrary.Redis.Status.Rejected}' to redis database({Redis.Instance.Database.Database})");
Redis.Instance.Database.StringSet($"{ConstantLibrary.Redis.Prefix.Status}{textId}", ConstantLibrary.Redis.Status.Rejected);
}
var stringToPublish = $"{textId}{ConstantLibrary.RabbitMq.Delimiter}" +
(status ? ConstantLibrary.RabbitMq.ProcessingLimiter.Status.True : ConstantLibrary.RabbitMq.ProcessingLimiter.Status.False);
Console.WriteLine($"{stringToPublish} to {_publishExchangeName} exchange");
rabbitMq.PublishToExchange(_publishExchangeName, stringToPublish);
Console.WriteLine("----------");
});
rabbitMq.QueueDeclare();
rabbitMq.ExchangeDeclare(_textMarkersListeningExchangeName, ExchangeType.Fanout);
rabbitMq.BindQueueToExchange(_textMarkersListeningExchangeName);
rabbitMq.ConsumeQueue(textIdMarker =>
{
Console.WriteLine($"New message from {_textMarkersListeningExchangeName}: \"{textIdMarker}\"");
string[] data = textIdMarker.Split(ConstantLibrary.RabbitMq.Delimiter);
bool isTextSucceeded = data[1] == ConstantLibrary.RabbitMq.TextSuccessMarker.Status.True;
if (!isTextSucceeded)
{
Console.WriteLine("Succeeded text count reset");
_succeededTextCount = 0;
}
Console.WriteLine("----------");
});
Console.WriteLine("TextProcessingLimiter has started");
Console.WriteLine("Press [enter] to exit.");
Console.ReadLine();
}
private static void Main()
{
Console.WriteLine("RabbitMQ and CloudAMQP");
//var rmqSend = new RabbitMq();
//Console.WriteLine(rmqSend.Publish("Tiago Pariz | " + DateTime.Now));
var rmqRead = new RabbitMq();
Console.WriteLine(rmqRead.Get());
Console.ReadKey();
}
public IActionResult Create([FromBody] CreateRoomReserveInput input)
{
ApiResponse response;
var command = new CreateRoomReserveCommand(input.RoomNumber, input.CustomerName, input.ReservedFor);
var result = RabbitMq.Publish <CreateRoomReserveCommand, Result <CreateRoomReserveResult> >(command);
if (!result.IsSucceeded)
{
response = new ApiResponse(result.Error.Code, result.Error.Description);
return(BadRequest(response));
}
response = new ApiResponse("OK", "Success");
return(Ok(response));
}
public IActionResult SignUp([FromBody] SignUpInput input)
{
ApiResponse response;
var command = new SignUpCommand(input.UserName, input.Password);
var result = RabbitMq.Publish <SignUpCommand, Result <SignUpResult> >(command);
if (!result.IsSucceeded)
{
response = new ApiResponse(result.Error.Code, result.Error.Description);
return(BadRequest(response));
}
response = new ApiResponse("OK", "Success");
return(Ok(response));
}
static void Main()
{
var rabbitMq = new RabbitMq();
rabbitMq.QueueDeclare();
rabbitMq.ExchangeDeclare(exchangeName, ExchangeType.Fanout);
rabbitMq.BindQueueToExchange(exchangeName);
rabbitMq.ConsumeQueue(message =>
{
Console.WriteLine($"{message}: {Redis.Instance.Database.StringGet(message)}");
});
Console.WriteLine("TextListener has started");
Console.WriteLine("Press [enter] to exit.");
Console.ReadLine();
}
public IActionResult Create([FromBody] CreateFinancialTransactionInput input)
{
ApiResponse response;
var command = new CreateFinancialTransactionCommand(input.About, input.Amount, (byte)input.Type);
var result = RabbitMq.Publish <CreateFinancialTransactionCommand, Result <CreateFinancialTransactionResult> >(command);
if (!result.IsSucceeded)
{
response = new ApiResponse(result.Error.Code, result.Error.Description);
return(BadRequest(response));
}
response = new ApiResponse("OK", "Success");
return(Ok(response));
}
