public async Task AddToQueue(ProcessQueueHistory request)
{
this._db.ProcessQueuesHistory.Add(request);
await this._db.SaveChangesAsync();
var routingKey = GetRoutingKeyFromProcessType();
var factory = new ConnectionFactory()
{
HostName = "localhost",
//UserName = _configuration["RabbitMQ:username"],
//Password = _configuration["RabbitMQ:password"]
};
using (var connection = factory.CreateConnection())
using (var channel = connection.CreateModel())
{
channel.ExchangeDeclare(exchange: this._settings.RabbitMQ.Exchange, type: "topic");
var properties = channel.CreateBasicProperties();
properties.Persistent = true;
var body = Encoding.UTF8.GetBytes(request.Id.ToString());
channel.BasicPublish(exchange: this._settings.RabbitMQ.Exchange, routingKey: routingKey, basicProperties: properties, body: body);
}
}
private async Task <bool> NotifyApi(ProcessQueueHistory request, QueueResult response)
{
//Call web api for notification update
for (int i = 1; i <= 3; i++)
{
using (var client = new HttpClient())
{
var stringContent = new StringContent(JsonConvert.SerializeObject(response), Encoding.UTF8, "application/json");
try
{
HttpResponseMessage httpResponse = await client.PostAsync($"{this.settings.WebApplicationUrl}/api/notifications", stringContent);
if (httpResponse.StatusCode == HttpStatusCode.OK)
{
return(true);
}
else if (i == 3)
{
this.logger.LogError($"Method NotifyApi: Failed to notify api for request {JsonConvert.SerializeObject(response)}");
return(false);
}
}
catch (Exception ex)
{
this.logger.LogError($"Method NotifyApi: Error while calling signalR api {JsonConvert.SerializeObject(response)}. MESSAGE: {ex.Message}");
}
}
}
return(false);
}
private async Task DoWork(string message, IModel channel, ulong deliveryTag, GymOrganizerContext db)
{
if (string.IsNullOrEmpty(message))
{
Nack(channel, deliveryTag);
return;
}
ProcessQueueHistory request = null;
try
{
var queueRequestId = Guid.Parse(message);
request = await db.ProcessQueuesHistory.Where(x => x.Id == queueRequestId).FirstOrDefaultAsync();
using (GymOrganizerContext processContext = new GymOrganizerContext(this.settings.Data.Model.ConnectionString))
{
IHandler handler = HandlerFactory.GetHandler(request.Type, this.loggerFactory, processContext, this.settings);
if (handler == null)
{
this.logger.LogError($"Method DoWork: Error processing request: {message}. Request type is not supported.");
Nack(channel, deliveryTag);
}
QueueResult response = await handler.Handle(request.Data);
response.TenantId = request.TenantId;
response.UserId = request.AddedById;
response.RequestOueueId = request.Id;
await NotifyApi(request, response);
Ack(channel, deliveryTag);
request.FinishedAt = DateTime.UtcNow;
request.Status = Data.Enums.ResultStatus.Ok;
await db.SaveChangesAsync();
}
}
catch (Exception ex)
{
this.logger.LogError($"Method DoWork: Error processing request: {message}. MEESAGE: {ex.Message}");
if (request != null)
{
request.Status = Data.Enums.ResultStatus.Error;
request.FinishedAt = DateTime.UtcNow;
request.ErrorMesage = ex.Message;
await db.SaveChangesAsync();
}
Nack(channel, deliveryTag);
}
}
public async Task AddUser(UserVM user)
{
UserQueue userQueue = Mapper.Map <UserVM, UserQueue>(user, options => {
options.AfterMap((src, dest) => dest.UserPerformingAction = this.UserId);
options.AfterMap((src, dest) => dest.TenantId = this.TenantId);
});
ProcessQueueHistory processQueueHistory = new ProcessQueueHistory()
{
Data = JsonConvert.SerializeObject(userQueue),
AddedById = this.UserId,
TenantId = this.TenantId,
Status = Data.Enums.ResultStatus.Waiting,
Type = Data.Enums.ProcessType.AddUser
};
await this.queueHandler.AddToQueue(processQueueHistory);
}
public async Task EditTerm(TermVM term)
{
TermQueue termQueue = Mapper.Map <TermVM, TermQueue>(term, options => {
options.AfterMap((src, dest) => dest.UserPerformingAction = this.UserId);
options.AfterMap((src, dest) => dest.TenantId = this.TenantId);
});
ProcessQueueHistory processQueueHistory = new ProcessQueueHistory()
{
Data = JsonConvert.SerializeObject(termQueue),
AddedById = this.UserId,
TenantId = this.TenantId,
Status = Data.Enums.ResultStatus.Waiting,
Type = Data.Enums.ProcessType.EditTerm
};
await this.queueHandler.AddToQueue(processQueueHistory);
}
private async Task SendDummyTask()
{
HealthCheckQueue healthCheckQueue = new HealthCheckQueue()
{
UserPerformingAction = Guid.Empty,
TenantId = Guid.Empty
};
ProcessQueueHistory processQueueHistory = new ProcessQueueHistory()
{
Data = JsonConvert.SerializeObject(healthCheckQueue),
AddedById = null,
TenantId = null,
Status = Data.Enums.ResultStatus.Waiting,
Type = Data.Enums.ProcessType.HealthCheck
};
await this.queueHandler.AddToQueue(processQueueHistory);
}
public async Task DeleteUser(Guid id)
{
UserQueue userQueue = new UserQueue()
{
Id = id,
TenantId = this.TenantId,
UserPerformingAction = this.UserId
};
ProcessQueueHistory processQueueHistory = new ProcessQueueHistory()
{
Data = JsonConvert.SerializeObject(userQueue),
AddedById = this.UserId,
TenantId = this.TenantId,
Status = Data.Enums.ResultStatus.Waiting,
Type = Data.Enums.ProcessType.DeleteUser
};
await this.queueHandler.AddToQueue(processQueueHistory);
}
