public ActionResult <Message> PostMessage(
[FromServices] RabbitMQConfigurations configurations,
[FromBody] Message message)
{
lock (_COUNTER)
{
_COUNTER.Increment();
var factory = new ConnectionFactory()
{
HostName = configurations.HostName,
Port = configurations.Port,
UserName = configurations.UserName,
Password = configurations.Password
};
using (var connection = factory.CreateConnection())
using (var channel = connection.CreateModel())
{
message.Id = _COUNTER.Value;
message.CreatedOn = DateTime.Now;
var serializerSettings = new JsonSerializerSettings();
serializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
var body = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(message, serializerSettings));
channel.BasicPublish(exchange: "subject_logs",
routingKey: message.Type,
basicProperties: null,
body: body);
}
return(CreatedAtAction(nameof(PostMessage), new { id = _COUNTER }, message));
}
}
private void Configuracao()
{
var rabbitMQConfigurations = new RabbitMQConfigurations();
new ConfigureFromConfigurationOptions <RabbitMQConfigurations>(
Configuration.GetSection("RabbitMQConfigurations"))
.Configure(rabbitMQConfigurations);
var factory = new ConnectionFactory()
{
HostName = rabbitMQConfigurations.HostName,
Port = rabbitMQConfigurations.Port,
UserName = rabbitMQConfigurations.UserName,
Password = rabbitMQConfigurations.Password
};
_connection = factory.CreateConnection();
_channel = _connection.CreateModel();
_channel.QueueDeclare(queue: filaAdmissao,
durable: false,
exclusive: false,
autoDelete: false,
arguments: null);
var consumer = new EventingBasicConsumer(_channel);
consumer.Received += Consumer_Received;
_channel.BasicConsume(queue: filaAdmissao,
autoAck: true,
consumer: consumer);
}
public object Post([FromServices] RabbitMQConfigurations configurations, [FromBody] MessageDTO message)
{
var factory = new ConnectionFactory()
{
HostName = configurations.HostName,
Port = configurations.Port,
UserName = configurations.UserName,
Password = configurations.Password
};
using (var connection = factory.CreateConnection())
using (var channel = connection.CreateModel())
{
channel.QueueDeclare(queue: "web-api-test-queue",
durable: false,
exclusive: false,
autoDelete: false,
arguments: null);
string formattedMessage =
$"{DateTime.Now.ToString("dd/MM/yyyy HH:mm:ss")} - {Guid.NewGuid()} - Conteúdo da Mensagem: {message.Content}";
var body = Encoding.UTF8.GetBytes(formattedMessage);
channel.BasicPublish(exchange: "",
routingKey: "web-api-test-queue",
basicProperties: null,
body: body);
}
return(new
{
Result = "Mensagem encaminhada com sucesso"
});
}
public ReviewEventsManager([FromServices] RabbitMQConfigurations rabbitMQConfiguration, IServiceScopeFactory serviceScopeFactory, ILogService logger)
{
Console.WriteLine($"{nameof(ReviewEventsManager)} initialized");
_logger = logger;
try
{
_serviceScopeFactory = serviceScopeFactory;
_factory = new ConnectionFactory()
{
HostName = rabbitMQConfiguration.HostName,
Port = rabbitMQConfiguration.Port,
UserName = rabbitMQConfiguration.UserName,
Password = rabbitMQConfiguration.Password
};
_connection = _factory.CreateConnection();
_channel = _connection.CreateModel();
}
catch (Exception ex)
{
_logger.Log(ex.Message, Microsoft.Extensions.Logging.LogLevel.Error, System.Net.HttpStatusCode.InternalServerError, nameof(ReviewEventsManager));
throw ex;
}
}
public object Post([FromServices] RabbitMQConfigurations configurations, Conteudo conteudo)
{
lock (_contador)
{
_contador.Incrementar();
var factory = new ConnectionFactory()
{
HostName = configurations.HostName,
Port = configurations.Port,
UserName = configurations.UserName,
Password = configurations.Password
};
using (var connection = factory.CreateConnection())
using (var channel = connection.CreateModel())
{
channel.QueueDeclare(queue: "TestesASPNETCore", durable: false, exclusive: false, autoDelete: false, arguments: null);
string message = $"{DateTime.Now.ToLongDateString()} - Conte'udo da mensgem: {conteudo.Mensagem}";
var body = Encoding.UTF8.GetBytes(message);
channel.BasicPublish(exchange: "", routingKey: "TestesASPNETCore", basicProperties: null, body: body);
}
}
return(new
{
Resultado = "Mensagem encaminhada com sucesso"
});
}
public DeliveriesEventManager(IServiceScopeFactory serviceScopeFactory, [FromServices] RabbitMQConfigurations rabbitMQConfiguration, ILogService logger)
{
Console.WriteLine($"{nameof(DeliveriesEventManager)} initialized");
_logger = logger;
try
{
_serviceScopeFactory = serviceScopeFactory;
_factory = new ConnectionFactory()
{
HostName = rabbitMQConfiguration.HostName,
Port = rabbitMQConfiguration.Port,
UserName = rabbitMQConfiguration.UserName,
Password = rabbitMQConfiguration.Password
};
_connection = _factory.CreateConnection();
_channel = _connection.CreateModel();
_channel.QueueDeclare(queue: ApplicationEvents.OrderQueue, durable: true, exclusive: false, autoDelete: false, arguments: null);
_channel.QueueDeclare(queue: ApplicationEvents.DeliveryQueue, durable: true, exclusive: false, autoDelete: false, arguments: null);
var consumer = new EventingBasicConsumer(_channel);
consumer.Received += DeliveryEvent_Received;
_channel.BasicConsume(ApplicationEvents.DeliveryQueue, true, consumer);
}
catch (Exception ex)
{
_logger.Log(ex.Message, Microsoft.Extensions.Logging.LogLevel.Error, System.Net.HttpStatusCode.InternalServerError, nameof(DeliveriesEventManager));
throw ex;
}
}
public IActionResult StartMeasure(
[FromBody] StartMeasureModel measureModel,
[FromServices] RabbitMQConfigurations configurations
)
{
var factory = new ConnectionFactory()
{
HostName = configurations.HostName,
Port = configurations.Port,
UserName = configurations.UserName,
Password = configurations.Password,
};
using (var connection = factory.CreateConnection())
using (var channel = connection.CreateModel())
{
channel.QueueDeclare(queue: "Measure",
durable: false,
exclusive: false,
autoDelete: false,
arguments: null);
string Message = $"Mac={measureModel.MacAddress};UserId={measureModel.UserId}";
var body = Encoding.UTF8.GetBytes(Message);
channel.BasicPublish(exchange: "", "Measure", null, body);
}
return(Ok(true));
}
public static void Main(string[] args)
{
//Wait RabbitMq
Task.Delay(1000).Wait();
Console.WriteLine("Wait RabbitMq");
//Set configurations
var builder = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile($"appsettings.json");
_configuration = builder.Build();
//Import configurations from appsettings.json
var rabbitMQConfigurations = new RabbitMQConfigurations();
_configuration.GetSection("RabbitMQConfigurations").Bind(rabbitMQConfigurations);
// Start to Message Broker
MessageService messageService = new MessageService(rabbitMQConfigurations);
//Create a Consumer to listening weatherForecastResponse queue.
CreateConsumer(messageService.Channel());
CreateHostBuilder(args).Build().Run();
}
public object CarregarCotacoes(
[FromServices] RabbitMQConfigurations rabbitMQConfigurations)
{
var factory = new ConnectionFactory()
{
HostName = rabbitMQConfigurations.HostName,
Port = rabbitMQConfigurations.Port,
UserName = rabbitMQConfigurations.UserName,
Password = rabbitMQConfigurations.Password
};
using (var connection = factory.CreateConnection())
using (var channel = connection.CreateModel())
{
channel.QueueDeclare(queue: "CarregarCotacoes",
durable: false,
exclusive: false,
autoDelete: false,
arguments: null);
string message = "Hello Word - " +
$"API Cotacoes - {DateTime.Now.ToString("dd/MM/yyyy HH:mm:ss")}";
var body = Encoding.UTF8.GetBytes(message);
channel.BasicPublish(exchange: "",
routingKey: "CarregarCotacoes",
basicProperties: null,
body: body);
}
return(new
{
Resultado = "Mensagem encaminhada com sucesso"
});
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
// configure DI for application services
services.AddScoped <IPaymentService, PaymentService>();
services.AddSingleton <ILogService, LogService>();
services.AddHostedService <ReceiptService>();
services.AddDbContext <PaymentDbContext>(options =>
{
options.UseSqlServer(Configuration.GetConnectionString("FokPaymentDB"));
});
services.AddCors();
services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2);
var rabbitMQConfigurations = new RabbitMQConfigurations();
new ConfigureFromConfigurationOptions <RabbitMQConfigurations>(
Configuration.GetSection("RabbitMQConfigurations"))
.Configure(rabbitMQConfigurations);
services.AddSingleton(rabbitMQConfigurations);
var appSettingsSection = Configuration.GetSection("AppSettings");
services.Configure <AppSettings>(appSettingsSection);
Mapper.Initialize(cfg => cfg.AddProfile <MappingProfile>());
services.AddAutoMapper();
}
public void DeveriaProcessarAListaDoLegado()
{
// Arrange
var funcionariolegadoRepo = new Mock <IRepository <FornecedorLegado> >();
funcionariolegadoRepo.Setup(c => c.List())
.Returns(ObterFornecedoresVariados(10, true));
RabbitMQConfigurations config = new RabbitMQConfigurations();
config.HostName = "172.28.112.1";
config.Port = 5672;
config.UserName = "******";
config.Password = "******";
FactoryRabbitMQ _factory = new FactoryRabbitMQ(config);
MessageBroker _broker = new MessageBroker(_factory);
//List<FornecedorLegado> lista = funcionariolegadoRepo.List();
//var clienteService = new ClienteService(clienteRepo.Object, mediatr.Object);
// Act
//var clientes = clienteService.ObterTodosAtivos();
// Assert
//clienteRepo.Verify(r => r.ObterTodos(), Times.Once);
//Assert.True(clientes.Any());
//Assert.False(clientes.Count(c => !c.Ativo) > 0);
ProcessamentoDoLegadoParaBroker processInt = new ProcessamentoDoLegadoParaBroker(funcionariolegadoRepo.Object, _broker);
processInt.Process();
}
public async Task <IActionResult> ProcessMealWaiting(
[FromServices] RabbitMQConfigurations configurations,
[FromServices] ConnectionFactory factory,
[FromServices] IConnection connection,
[FromServices] IConsumeRabbitMQService consumer)
{
try{
var result = await consumer.ProcessQueue("Meal - waiting");
if (result != null)
{
using (var channel = connection.CreateModel())
{
var queue = channel.QueueDeclare(queue: "Command Queue",
durable: false,
exclusive: false,
autoDelete: false,
arguments: null);
//RabbitMQExtensions.GetAllMessages(queue ,configurations, "Side Dish - waiting");
string message = JsonConvert.SerializeObject(result);
var body = Encoding.UTF8.GetBytes(message);
channel.BasicPublish(exchange: "",
routingKey: "Meal - preparing",
basicProperties: null,
body: body);
//channel.WaitForConfirmsOrDie(new TimeSpan(0, 0, 5));
//Dictionary<string, string> headers = new Dictionary<string, string>();
var properties = channel.CreateBasicProperties();
properties.Persistent = false;
Dictionary <string, object> dictionary = new Dictionary <string, object>();
dictionary.Add("Command", "MealPreparing");
properties.Headers = dictionary;
channel.BasicPublish(exchange: "",
routingKey: "Command Queue",
basicProperties: properties,
body: body);
//channel.WaitForConfirmsOrDie(new TimeSpan(0, 0, 5));
}
}
return(Ok());
}
catch (Exception ex)
{
return(BadRequest());
}
}
public IActionResult ShowQueueItem(
[FromServices] RabbitMQConfigurations configurations,
[FromServices] ConnectionFactory factory,
[FromServices] IConnection connection,
[FromServices] IConsumeRabbitMQService consumer,
string kitchenAreaName,
string status)
{
try
{
using (var channel = connection.CreateModel())
{
var queue = channel.QueueDeclare(queue: kitchenAreaName + " - " + status,
durable: false,
exclusive: false,
autoDelete: false,
arguments: null);
var result = RabbitMQExtensions.GetAllMessages(queue, configurations, queue.QueueName);
if (result == null)
{
return(BadRequest());
}
return(Ok(result));
}
}
catch (Exception ex)
{
return(BadRequest());
}
}
public MessageService(RabbitMQConfigurations configurations)
{
Console.WriteLine("[ Manager ] connecting to rabbit");
_factory = new ConnectionFactory()
{
HostName = (InDocker) ? configurations.HostNameDocker : configurations.HostName,
Port = configurations.Port,
UserName = configurations.UserName,
Password = configurations.Password
};
if (InDocker)
{
_factory.HostName = configurations.HostNameDocker;
}
_conn = _factory.CreateConnection();
_channel = _conn.CreateModel();
_channel.QueueDeclare(queue: Constants.RabbitQueuRequest,
durable: false,
exclusive: false,
autoDelete: false,
arguments: null);
_channel.QueueDeclare(queue: Constants.RabbitQueuResponse,
durable: false,
exclusive: false,
autoDelete: false,
arguments: null);
}
private static IServiceCollection ConfigureDi(IServiceCollection services, IConfiguration config)
{
RabbitMQConfigurations.ConfigureServices(services, config);
StorageConfigurations.ConfigureServices(services, config);
return(services
.AddSingleton(config)
.AddTransient <IFileArchiver, FileArchiver>()
.Configure <FileArchiver>(config)
.AddTransient <IAzureService, AzureService>()
.Configure <AzureService>(config)
.AddTransient(x => new ProcessKiller(config))
.AddScoped <IQueueService, QueueService>()
.AddLogging(loggingBuilder =>
{
// configure Logging with NLog
loggingBuilder.ClearProviders();
loggingBuilder.SetMinimumLevel(Microsoft.Extensions.Logging.LogLevel.Trace);
loggingBuilder.AddNLog();
})
.AddTransient <IAzureService, AzureService>()
.Configure <AzureService>(config)
.AddTransient <IProjectBuilder, ProjectBuilder>()
.AddTransient <GoConsoleBuilder>()
.AddTransient <TSConsoleBuilder>()
.AddTransient <CSharpConsoleBuilder>()
.Configure <CSharpConsoleBuilder>(config)
.Configure <TSConsoleBuilder>(config)
.Configure <GoConsoleBuilder>(config));
}
public static void GetAllMessages(QueueDeclareOk queue, RabbitMQConfigurations cfg, string queueName)
{
var credentials = new NetworkCredential()
{
UserName = cfg.UserName, Password = cfg.Password
};
using (var handler = new HttpClientHandler {
Credentials = credentials
})
using (var client = new HttpClient(handler)) {
var url = $"http://{cfg.HostName}:{cfg.ManagementPort}/api/queues/{cfg.VirtualHost}/{queueName}/get";
var jsonContent = new {
ackmode = "ack_requeue_true",
count = queue.MessageCount.ToString(),
encoding = "auto",
truncate = "50000",
vhost = cfg.VirtualHost
};
var content = new StringContent(JsonConvert.SerializeObject(jsonContent), Encoding.UTF8, "application/json");
var result = client.PostAsync(url, content).Result.Content.ReadAsStringAsync().Result;
}
}
protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
var webHostBuilder = WebHost.CreateDefaultBuilder();
var rabbitMQConfigurations = new RabbitMQConfigurations();
new ConfigureFromConfigurationOptions <RabbitMQConfigurations>(
_configuration.GetSection("RabbitMQConfigurations"))
.Configure(rabbitMQConfigurations);
var mongoConfigurations = new MongoDBConfigurations();
new ConfigureFromConfigurationOptions <MongoDBConfigurations>(
_configuration.GetSection("MongoDBConfigurations"))
.Configure(mongoConfigurations);
var mongoClient = new MongoClient(string.Format("mongodb://{0}:{1}", mongoConfigurations.Host, mongoConfigurations.Port));
IMongoDatabase mongoDb = mongoClient.GetDatabase("LogsDB");
var logsCollection = mongoDb.GetCollection <BsonDocument>("Logs");
var factory = new ConnectionFactory()
{
HostName = rabbitMQConfigurations.HostName,
Port = rabbitMQConfigurations.Port,
UserName = rabbitMQConfigurations.UserName,
Password = rabbitMQConfigurations.Password
};
using (var connection = factory.CreateConnection())
using (var channel = connection.CreateModel())
{
channel.QueueDeclare(queue: "logQueue", durable: false, exclusive: false, autoDelete: false, arguments: null);
var consumer = new EventingBasicConsumer(channel);
consumer.Received += (model, ea) =>
{
var body = ea.Body;
var message = System.Text.Encoding.UTF8.GetString(body);
Console.WriteLine(" [x] Received:\n {0}", message);
BsonDocument document = BsonDocument.Parse(message);
try
{
logsCollection.InsertOne(document);
}
catch (Exception ex)
{
Console.WriteLine($"Error in mongoDB insert: {ex.Message}");
}
};
channel.BasicConsume(queue: "logQueue", autoAck: true, consumer: consumer);
while (!stoppingToken.IsCancellationRequested)
{
await Task.Delay(5000, stoppingToken);
}
}
}
public RabbitMQConsumeHelper(
RabbitMQConfigurations configurations,
ConnectionFactory factory,
IConnection connection)
{
this.configurations = configurations;
this.factory = factory;
this.connection = connection;
}
public BasketEventsManager(IServiceScopeFactory serviceScopeFactory, [FromServices] RabbitMQConfigurations rabbitMQConfiguration)
{
_serviceScopeFactory = serviceScopeFactory;
_factory = new ConnectionFactory()
{
HostName = rabbitMQConfiguration.HostName,
Port = rabbitMQConfiguration.Port
};
}
public static void RegisterCustomServices(this IServiceCollection services, IConfiguration configuration)
{
services.AddScoped <JwtIssuerOptions>();
BLLConfigurations.ConfigureServices(services, configuration);
DALConfigurations.ConfigureServices(services, configuration);
RabbitMQConfigurations.ConfigureServices(services, configuration);
}
private static ConnectionFactory GetConnectionFactory(RabbitMQConfigurations rabbitMQConfigurations)
{
return(new ConnectionFactory()
{
HostName = rabbitMQConfigurations.HostName,
Port = rabbitMQConfigurations.Port,
UserName = rabbitMQConfigurations.UserName,
Password = rabbitMQConfigurations.Password
});
}
public static void AddRabbitMQConfiguration(IServiceCollection services, IConfiguration configuration)
{
var rabbitMQConfiguration = new RabbitMQConfigurations();
new ConfigureFromConfigurationOptions <RabbitMQConfigurations>(
configuration.GetSection("RabbitMQConfigurations"))
.Configure(rabbitMQConfiguration);
services.AddSingleton(rabbitMQConfiguration);
}
public ConsumeRabbitMQHostedService(IServiceProvider serviceProvider,
ILogger <ConsumeRabbitMQHostedService> logger)
{
_logger = logger;
_serviceProvider = serviceProvider;
_channel = (IModel)_serviceProvider.GetService(typeof(IModel));
_connection = (IConnection)_serviceProvider.GetService(typeof(IConnection));
_configurations = (RabbitMQConfigurations)_serviceProvider.GetService(typeof(RabbitMQConfigurations));
_factory = (ConnectionFactory)_serviceProvider.GetService(typeof(ConnectionFactory));
}
public object ExchangeQueue(
[FromServices] RabbitMQConfigurations configurations,
[FromBody] MessageContent conteudo)
{
lock (_CONTADOR)
{
_CONTADOR.Incrementar();
var factory = new ConnectionFactory()
{
HostName = configurations.HostName,
Port = configurations.Port,
UserName = configurations.UserName,
Password = configurations.Password
};
using (var connection = factory.CreateConnection())
using (var channel = connection.CreateModel())
{
string exchangeName = "exchange1";
string queueName = "TestesASPNETCoreExchange";
string routingKey = "routing1";
channel.ExchangeDeclare(exchangeName, ExchangeType.Direct);
//channel.QueueDeclare(queueName, false, false, false, null);
channel.QueueDeclare(queue: queueName,
durable: false,
exclusive: false,
autoDelete: false,
arguments: null);
channel.QueueBind(queueName, exchangeName, routingKey, null);
string message =
$"{DateTime.Now.ToString("dd/MM/yyyy HH:mm:ss")} - " +
$"Conteúdo da Mensagem: {conteudo.Message}";
var body = Encoding.UTF8.GetBytes(message);
channel.BasicPublish(exchange: exchangeName,
routingKey: routingKey,
basicProperties: null,
body: body);
}
return(new
{
Resultado = "Mensagem encaminhada com sucesso"
});
}
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddDbContext <UserDbContext>(options =>
{
options.UseSqlServer(Configuration.GetConnectionString("FokUserDB"));
});
services.AddCors();
services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2);
services.DateTimeItFormatter();
var rabbitMQConfigurations = new RabbitMQConfigurations();
new ConfigureFromConfigurationOptions <RabbitMQConfigurations>(
Configuration.GetSection("RabbitMQConfigurations"))
.Configure(rabbitMQConfigurations);
services.AddSingleton(rabbitMQConfigurations);
var appSettingsSection = Configuration.GetSection("AppSettings");
services.Configure <AppSettings>(appSettingsSection);
// configure jwt authentication
var appSettings = appSettingsSection.Get <AppSettings>();
var key = Encoding.ASCII.GetBytes(appSettings.Secret);
services.AddAuthentication(x =>
{
x.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
x.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
})
.AddJwtBearer(x =>
{
x.RequireHttpsMetadata = false;
x.SaveToken = true;
x.TokenValidationParameters = new TokenValidationParameters
{
ValidateIssuerSigningKey = true,
IssuerSigningKey = new SymmetricSecurityKey(key),
ValidateIssuer = false,
ValidateAudience = false
};
});
// configure DI for application services
services.AddScoped <IUserService, UserService>();
services.AddScoped <ILogService, LogService>();
Mapper.Initialize(cfg => cfg.AddProfile <MappingProfile>());
services.AddAutoMapper();
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
var rabbitMQConfigurations = new RabbitMQConfigurations();
new ConfigureFromConfigurationOptions <RabbitMQConfigurations>(
Configuration.GetSection("RabbitMQConfigurations"))
.Configure(rabbitMQConfigurations);
services.AddSingleton(rabbitMQConfigurations);
services.AddSingleton <IMessageService, MessageService>();
services.AddSingleton <IWeatherForecastService, WeatherForecastService>();
services.AddControllers();
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddControllers();
services.AddSingleton <IConfiguration> (Configuration);
var rabbitMQConfigurations = new RabbitMQConfigurations();
new ConfigureFromConfigurationOptions <RabbitMQConfigurations>(
Configuration.GetSection("RabbitMQConfigurations"))
.Configure(rabbitMQConfigurations);
var factory = new ConnectionFactory()
{
HostName = rabbitMQConfigurations.HostName,
Port = rabbitMQConfigurations.Port,
UserName = rabbitMQConfigurations.UserName,
Password = rabbitMQConfigurations.Password,
VirtualHost = rabbitMQConfigurations.VirtualHost
};
services.AddSingleton(factory);
var connection = factory.CreateConnection();
RabbitMQExtensions.EnsureExistRabbitMqVirtualHost(rabbitMQConfigurations, connection);
var channel = connection.CreateModel();
services.AddScopedServices();
services.AddTransientServices();
services.AddSingletonServices(ServiceProvider);
channel.AddChannels();
channel.ConfirmSelect();
services.AddSingleton(rabbitMQConfigurations);
services.AddLogging();
services.AddSingleton(channel);
services.AddSingleton(connection);
}
public static IHostBuilder CreateHostBuilder(string[] args) =>
Host.CreateDefaultBuilder(args)
.ConfigureServices((hostContext, services) =>
{
var rabbitMQConfigurations = new RabbitMQConfigurations();
new ConfigureFromConfigurationOptions <RabbitMQConfigurations>(
hostContext.Configuration.GetSection("RabbitMQConfigurations"))
.Configure(rabbitMQConfigurations);
services.AddMessageBusConfiguration(rabbitMQConfigurations);
services.RegisterServices();
services.AddHostedService <Worker>();
});
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
var rabbitMQConfigurations = new RabbitMQConfigurations();
new ConfigureFromConfigurationOptions <RabbitMQConfigurations>(
Configuration.GetSection("RabbitMQConfigurations"))
.Configure(rabbitMQConfigurations);
var connection = Configuration["ConexaoSqlite:SqliteConnectionString"];
services.AddDbContext <ManagerWeatherContext>(options => options.UseSqlite(connection));
services.AddSingleton(rabbitMQConfigurations);
services.AddSingleton <IMessageService, MessageService>();
services.AddSingleton(new WeatherRepository(new ManagerWeatherContext()));
services.AddControllers();
}
public object Post(
[FromServices] RabbitMQConfigurations configurations,
[FromBody] Conteudo conteudo)
{
lock (_CONTADOR)
{
_CONTADOR.Incrementar();
var factory = new ConnectionFactory()
{
HostName = configurations.HostName,
Port = configurations.Port,
UserName = configurations.UserName,
Password = configurations.Password
};
using (var connection = factory.CreateConnection())
using (var channel = connection.CreateModel())
{
channel.QueueDeclare(queue: "NFeQueue",
durable: false,
exclusive: false,
autoDelete: false,
arguments: null);
string message = System.Text.Json.JsonSerializer.Serialize(conteudo);
Console.WriteLine("Chegou a mensagem " + message);
var body = Encoding.UTF8.GetBytes(message);
channel.BasicPublish(exchange: "",
routingKey: "NFeQueue",
basicProperties: null,
body: body);
}
return(new
{
Resultado = "Mensagem encaminhada com sucesso"
});
}
}