protected async Task SendRequest(BehaviorContext <TInstance> context, ConsumeContext consumeContext, TRequest requestMessage)
{
var pipe = new SendRequestPipe(consumeContext.ReceiveContext.InputAddress);
var endpoint = await consumeContext.GetSendEndpoint(_request.Settings.ServiceAddress).ConfigureAwait(false);
await endpoint.Send(requestMessage, pipe).ConfigureAwait(false);
_request.SetRequestId(context.Instance, pipe.RequestId);
if (_request.Settings.Timeout > TimeSpan.Zero)
{
var now = DateTime.UtcNow;
var expirationTime = now + _request.Settings.Timeout;
RequestTimeoutExpired message = new TimeoutExpired(now, expirationTime, context.Instance.CorrelationId, pipe.RequestId);
MessageSchedulerContext schedulerContext;
if (_request.Settings.SchedulingServiceAddress != null)
{
var scheduleEndpoint = await consumeContext.GetSendEndpoint(_request.Settings.SchedulingServiceAddress).ConfigureAwait(false);
await scheduleEndpoint.ScheduleSend(consumeContext.ReceiveContext.InputAddress, expirationTime, message).ConfigureAwait(false);
}
else if (consumeContext.TryGetPayload(out schedulerContext))
{
await schedulerContext.ScheduleSend(expirationTime, message).ConfigureAwait(false);
}
else
{
throw new ConfigurationException("A request timeout was specified but no message scheduler was specified or available");
}
}
}
public async Task Consume(ConsumeContext <CreateJobsCommand> context)
{
var redisDB = _connectionMultiplexer.GetDatabase(_redisOptions.Database);
/// the reason we don't use the in-memory inbox is because for use we process thousands of jobs
/// if the process fails, then we start all over again and lose any processing
/// instead, we keep track of jobs that we've enqueued in a redis set
/// if something goes wrong, we can skip what we've already processed
/// choice is yours though how to go. your mileage may vary
/// also, I have fud over what guarantees the inbox offers
var alreadyEnqueued = (await redisDB.SetMembersAsync($"{context.Message.CorrelationId}:JobList").ConfigureAwait(false))
.Select(m => (string)m)
.ToHashSet();
var jobs = alreadyEnqueued.Any()
? context.Message.Jobs.Where(j => !alreadyEnqueued.Contains(j)).ToArray()
: context.Message.Jobs;
_logger.LogInformation("Enqueuing jobs");
var doJobEndpoint = await context.GetSendEndpoint(new Uri("loopback://localhost/do_job")).ConfigureAwait(false);
foreach (var job in jobs)
{
/// if we want, we can add all items before we start
/// we add the job id before enqueuing the job to prevent cases where the job finishes be we add it to the queue
/// in this case, the id will never get removed and we would be stuck in limbo
await redisDB.SetAddAsync($"{context.Message.CorrelationId}:JobList", job).ConfigureAwait(false);
//_logger.LogInformation("Enqueued: {Job}", job);
await doJobEndpoint.Send(new DoJobCommand
{
CorrelationId = context.Message.CorrelationId,
Job = job,
}).ConfigureAwait(false);
}
_logger.LogInformation("All jobs enqueued");
_logger.LogInformation("Starting job tracker");
/// no need to check immediately. let's give it some time
var trackJobsEndpoint = await context.GetSendEndpoint(new Uri("loopback://localhost/quartz")).ConfigureAwait(false);
await trackJobsEndpoint.ScheduleSend(new Uri("loopback://localhost/track_jobs"), TimeSpan.FromSeconds(2), new TrackJobsCommand
{
CorrelationId = context.Message.CorrelationId,
}).ConfigureAwait(false);
_logger.LogInformation("tracker started");
}
public async Task Consume(ConsumeContext <IRegisterOrderCommand> context)
{
var result = context.Message;
if (result.OrderId != null)
{
SaveOrder(result);
await _hubConntext.Clients.All.SendAsync("UpdateOrders", "New order created", result.OrderId);
var client = _clientFactory.CreateClient();
Tuple <List <byte[]>, Guid> orderDetailData = await GetFacesFromFaceApiAsync(client, result.ImageData, result.OrderId);
List <byte[]> faces = orderDetailData.Item1;
Guid orderId = orderDetailData.Item2;
SaveOrderDetails(orderId, faces);
await _hubConntext.Clients.All.SendAsync("UpdateOrders", "Order processedd", result.OrderId);
var sendToUri = new Uri($"{RabbitMqMassiveTransitConstants.RabbitMqUri }/" +
$"{RabbitMqMassiveTransitConstants.NotificationServiceQueue}");
var endPoint = await context.GetSendEndpoint(sendToUri);
await endPoint.Send <IOrderProcessedEvent>(
new
{
context.Message.OrderId,
faces,
context.Message.Email
});
}
}
public async Task Consume(ConsumeContext <ProceedBeautifiedPoem> context)
{
Console.WriteLine("Poem filtering completed");
bool isPoemSaved = false;
try
{
_storage.Save(context.Message.UserId, context.Message.CorrId, string.Join("\n", context.Message.Poem));
isPoemSaved = true;
}
catch (Exception)
{
}
if (!isPoemSaved)
{
Console.WriteLine("Failed to save poem to database");
Uri sendEndpointUri = new Uri(string.Concat(ConfigurationManager.AppSettings["RabbitMQHost"], ConfigurationManager.AppSettings["PoemBeatifierManagerQueueName"]));
var endpoint = await context.GetSendEndpoint(sendEndpointUri);
await endpoint.Send <RejectPoem>(new
{
CorrId = context.Message.CorrId,
});
}
else
{
await Task.FromResult(1);
}
}
public async Task Consume(ConsumeContext <RoutingSlipFaulted> context)
{
var request = context.Message.GetVariable <TRequest>("Request");
var requestId = context.Message.GetVariable <Guid>("RequestId");
Uri responseAddress = null;
if (context.Message.Variables.ContainsKey("FaultAddress"))
{
responseAddress = context.Message.GetVariable <Uri>("FaultAddress");
}
if (responseAddress == null && context.Message.Variables.ContainsKey("ResponseAddress"))
{
responseAddress = context.Message.GetVariable <Uri>("ResponseAddress");
}
if (responseAddress == null)
{
throw new ArgumentException($"The response address could not be found for the faulted routing slip: {context.Message.TrackingNumber}");
}
var endpoint = await context.GetSendEndpoint(responseAddress).ConfigureAwait(false);
var response = await CreateFaultedResponseMessage(context, request, requestId);
await endpoint.Send(response, x => x.RequestId = requestId)
.ConfigureAwait(false);
}
/// <summary>
/// Send a message
/// </summary>
/// <typeparam name="T">The message type</typeparam>
/// <param name="context"></param>
/// <param name="endpointAddress"></param>
/// <param name="message">The message</param>
/// <returns>The task which is completed once the Send is acknowledged by the broker</returns>
public static async Task Send <T>(this ConsumeContext context, Uri endpointAddress, T message)
where T : class
{
ISendEndpoint endpoint = await context.GetSendEndpoint(endpointAddress).ConfigureAwait(false);
await endpoint.Send(message, context.CancellationToken).ConfigureAwait(false);
}
public async Task Consume(ConsumeContext <RoutingSlipFaulted> context)
{
var request = context.Message.GetVariable <TRequest>("Request");
var requestId = context.Message.GetVariable <Guid>("RequestId");
Uri responseAddress = null;
if (context.Message.Variables.ContainsKey("FaultAddress"))
{
responseAddress = context.Message.GetVariable <Uri>("FaultAddress");
}
if (responseAddress == null && context.Message.Variables.ContainsKey("ResponseAddress"))
{
responseAddress = context.Message.GetVariable <Uri>("ResponseAddress");
}
if (responseAddress == null)
{
throw new ArgumentException($"The response address could not be found for the faulted routing slip: {context.Message.TrackingNumber}");
}
var endpoint = await context.GetSendEndpoint(responseAddress).ConfigureAwait(false);
ActivityException[] exceptions = context.Message.ActivityExceptions;
await endpoint.Send <Fault <TRequest> >(new FaultEvent <TRequest>(request, requestId, context.Host, exceptions.Select(x => x.ExceptionInfo)),
x => x.RequestId = requestId)
.ConfigureAwait(false);
}
async Task Execute(BehaviorContext <TInstance> context)
{
ConsumeContext consumeContext = context.CreateConsumeContext();
Guid?requestId = _request.GetRequestId(context.Instance);
if (requestId.HasValue && _request.Settings.Timeout > TimeSpan.Zero)
{
MessageSchedulerContext schedulerContext;
if (_request.Settings.SchedulingServiceAddress != null)
{
var scheduleEndpoint = await consumeContext.GetSendEndpoint(_request.Settings.SchedulingServiceAddress).ConfigureAwait(false);
await scheduleEndpoint.CancelScheduledSend(requestId.Value).ConfigureAwait(false);
}
else if (consumeContext.TryGetPayload(out schedulerContext))
{
await schedulerContext.CancelScheduledSend(consumeContext.ReceiveContext.InputAddress, requestId.Value).ConfigureAwait(false);
}
else
{
throw new ConfigurationException("A scheduler was not available to cancel the scheduled request timeout");
}
}
}
/// <summary>
/// Send a message
/// </summary>
/// <typeparam name="T">The message type</typeparam>
/// <param name="context"></param>
/// <param name="endpointAddress"></param>
/// <param name="values"></param>
/// <param name="pipe"></param>
/// <returns>The task which is completed once the Send is acknowledged by the broker</returns>
public static async Task Send <T>(this ConsumeContext context, Uri endpointAddress, object values, IPipe <SendContext> pipe)
where T : class
{
ISendEndpoint endpoint = await context.GetSendEndpoint(endpointAddress).ConfigureAwait(false);
await endpoint.Send <T>(values, pipe, context.CancellationToken).ConfigureAwait(false);
}
/// <summary>
/// Deletes the scheduled message with the specified group and name.
/// </summary>
/// <param name="context"></param>
/// <param name="groupName"></param>
/// <param name="name"></param>
/// <returns></returns>
public static async Task DeleteSchedule(
this ConsumeContext context,
string groupName,
string name)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (groupName == null)
{
throw new ArgumentNullException(nameof(groupName));
}
if (name == null)
{
throw new ArgumentNullException(nameof(name));
}
// endpoint of scheduler
var i = await context.GetSendEndpoint(new Uri(context.ReceiveContext.InputAddress, "/scheduler"));
if (i == null)
{
throw new InvalidOperationException("Could not resolve scheduler endpoint.");
}
await i.Send(new DeleteSchedule()
{
GroupName = groupName,
Name = name,
});
}
public static async Task Forward <T>(this ConsumeContext context, Uri address, T message)
where T : class
{
var endpoint = await context.GetSendEndpoint(address).ConfigureAwait(false);
await Forward(context, endpoint, message).ConfigureAwait(false);
}
/// <summary>
/// Send a message
/// </summary>
/// <typeparam name="T">The message type</typeparam>
/// <param name="context"></param>
/// <param name="destinationAddress"></param>
/// <param name="message">The message</param>
/// <param name="pipe"></param>
/// <returns>The task which is completed once the Send is acknowledged by the broker</returns>
public static async Task Send <T>(this ConsumeContext context, Uri destinationAddress, T message, IPipe <SendContext> pipe)
where T : class
{
var endpoint = await context.GetSendEndpoint(destinationAddress).ConfigureAwait(false);
await endpoint.Send(message, pipe, context.CancellationToken).ConfigureAwait(false);
}
/// <summary>
/// Send a message
/// </summary>
/// <typeparam name="T">The message type</typeparam>
/// <param name="context"></param>
/// <param name="destinationAddress"></param>
/// <param name="values"></param>
/// <returns>The task which is completed once the Send is acknowledged by the broker</returns>
public static async Task Send <T>(this ConsumeContext context, Uri destinationAddress, object values)
where T : class
{
var endpoint = await context.GetSendEndpoint(destinationAddress).ConfigureAwait(false);
await endpoint.Send <T>(values, context.CancellationToken).ConfigureAwait(false);
}
/// <summary>
/// Prepare for game
/// - Guesses
/// - GuessedWord
/// - WordLeft
/// </summary>
/// <param name="ctx"></param>
/// <returns></returns>
public async Task Consume(ConsumeContext <SetupProcessing> ctx)
{
var msg = ctx.Message;
var ep = await ctx.GetSendEndpoint(rmqConfig.GetEndpoint(Queues.GameSaga));
using (var scope = logger.BeginScope($"CorrelationId={msg.CorrelationId}"))
{
var word = msg.Word.ToLowerInvariant();
var game = await dbContext.GameSagas.Find(x => x.CorrelationId == msg.CorrelationId)
.FirstAsync();
game.Word = word;
game.WordLeft = word;
game.GuessedWord = Enumerable.Range(0, word.Length)
.Select(x => '-')
.ToArray();
game.Guesses = new List <char>();
await dbContext.GameSagas.ReplaceOneAsync(x => x.CorrelationId == game.CorrelationId, game);
logger.LogInformation("Processing setup done");
await ep.Send(new ProcessingSetup
{
CorrelationId = msg.CorrelationId,
GuessedWord = string.Join("", game.GuessedWord)
});
}
}
public async Task Consume(ConsumeContext <IDownloadPackage> context)
{
var conversationEnricher = new PropertyEnricher(nameof(context.ConversationId), context.ConversationId);
var archiveRecordIdEnricher = new PropertyEnricher(nameof(context.Message.ArchiveRecordId), context.Message.ArchiveRecordId);
var packageIdEnricher = new PropertyEnricher(nameof(context.Message.PackageId), context.Message.PackageId);
using (LogContext.Push(conversationEnricher, archiveRecordIdEnricher, packageIdEnricher))
{
Log.Information("Received {CommandName} command with conversationId {ConversationId} from the bus", nameof(IDownloadPackage),
context.ConversationId);
// Get the package from the repository
// We are not waiting for it to end, because we want to free the consumer as early as possible
var packageId = context.Message.PackageId;
var archiveRecordId = context.Message.ArchiveRecordId;
var result = await repositoryManager.GetPackage(packageId, archiveRecordId, context.Message.PrimaerdatenAuftragId);
// Do we have a valid package?
if (result.Success && result.Valid)
{
// Forward the downloaded package to the asset manager for transformation
var endpoint = await context.GetSendEndpoint(new Uri(bus.Address, BusConstants.AssetManagerPrepareForTransformation));
await endpoint.Send(new PrepareForTransformationMessage
{
AssetType = AssetType.Gebrauchskopie,
CallerId = context.Message.CallerId,
RetentionCategory = context.Message.RetentionCategory,
Recipient = context.Message.Recipient,
Language = context.Message.Language,
ProtectWithPassword = context.Message.RetentionCategory != CacheRetentionCategory.UsageCopyPublic,
PrimaerdatenAuftragId = context.Message.PrimaerdatenAuftragId,
RepositoryPackage = result.PackageDetails
});
// also publish the event, that the package is downloaded
await context.Publish <IPackageDownloaded>(
new
{
PackageInfo = result
});
}
else
{
// Publish the download asset failure event
await context.Publish <IAssetReady>(new AssetReady
{
Valid = false,
ErrorMessage = result.ErrorMessage,
AssetType = AssetType.Gebrauchskopie,
CallerId = context.Message.CallerId,
ArchiveRecordId = context.Message.ArchiveRecordId,
RetentionCategory = context.Message.RetentionCategory,
Recipient = context.Message.Recipient,
PrimaerdatenAuftragId = context.Message.PrimaerdatenAuftragId
});
}
}
}
public async Task Consume(ConsumeContext <PaymentAcceptedEvent> context)
{
var sendEndpoint = await context.GetSendEndpoint(createBaseCoffeeEndpoint);
await sendEndpoint.Send <CreateBaseCoffeeCommand>(new { this.CorrelationId, CoffeeType = this.CoffeeTypeRequested, NoTopping = string.IsNullOrWhiteSpace(this.ToppingsRequested) });
this.State = "Paid";
}
public async Task Consume(ConsumeContext <IAmlValidationEvent> context)
{
AmlDataAccess amlDataAccess = new AmlDataAccess();
var remitterData = context.Message;
if (remitterData.RemitterFirstName.Contains("modi"))
{
amlDataAccess.SaveData(new Models.AmlData
{
AmlStatus = "Block",
CountryName = remitterData.RemitterCountry,
CustomerName = String.Format($"{remitterData.RemitterFirstName} {remitterData.RemitterLastName}"),
RemitterID = remitterData.RemitterID
});
var endpoint = await context.GetSendEndpoint(new Uri("queue:" + BusConfiguration.AmlQueueName));
await endpoint.Send <IAmlData>(new
{
RemitterID = remitterData.RemitterID,
AmlStatus = "Block",
});
await Task.FromResult(true);
}
else
{
amlDataAccess.SaveData(new Models.AmlData
{
AmlStatus = "Allow",
CountryName = remitterData.RemitterCountry,
CustomerName = String.Format($"{remitterData.RemitterFirstName} {remitterData.RemitterLastName}"),
RemitterID = remitterData.RemitterID
});
var endpoint = await context.GetSendEndpoint(new Uri("queue:" + BusConfiguration.AmlQueueName));
await endpoint.Send <IAmlData>(new
{
RemitterID = remitterData.RemitterID,
AmlStatus = "Allow",
});
await Task.FromResult(true);
}
await Task.FromResult(false);
}
/// <summary>
/// Consumes the specified message from the bus.
/// </summary>
/// <param name="context">The context.</param>
/// <returns>Task.</returns>
public async Task Consume(ConsumeContext <IUpdateArchiveRecord> context)
{
var currentStatus = AufbereitungsStatusEnum.OCRAbgeschlossen;
using (LogContext.PushProperty(nameof(context.ConversationId), context.ConversationId))
{
Log.Information("Received {CommandName} command with conversationId {ConversationId} from the bus", nameof(IUpdateArchiveRecord),
context.ConversationId);
try
{
indexManager.UpdateArchiveRecord(context);
Log.Information($"Updated archive record {context.Message.ArchiveRecord.ArchiveRecordId} in elastic index.");
currentStatus = AufbereitungsStatusEnum.IndizierungAbgeschlossen;
await UpdatePrimaerdatenAuftragStatus(context, AufbereitungsServices.IndexService, currentStatus);
// update the individual tokens for download and access
// these tokens need to be updated even if the record has no primary data.
// Use case: Ö2 user asks for Einsichtsgesuch. It gets approved, but record may not (yet) have primary data.
var ep = await context.GetSendEndpoint(new Uri(context.SourceAddress, BusConstants.RecalcIndivTokens));
await ep.Send(new RecalcIndivTokens
{
ArchiveRecordId = Convert.ToInt32(context.Message.ArchiveRecord.ArchiveRecordId),
ExistingMetadataAccessTokens = context.Message.ArchiveRecord.Security.MetadataAccessToken.ToArray(),
ExistingPrimaryDataDownloadAccessTokens = context.Message.ArchiveRecord.Security.PrimaryDataDownloadAccessToken.ToArray(),
ExistingPrimaryDataFulltextAccessTokens = context.Message.ArchiveRecord.Security.PrimaryDataFulltextAccessToken.ToArray()
});
Log.Information(
$"Recalculated and updated individual tokens for archive record {context.Message.ArchiveRecord.ArchiveRecordId} in elastic index.");
await context.Publish <IArchiveRecordUpdated>(new
{
context.Message.MutationId,
context.Message.ArchiveRecord.ArchiveRecordId,
ActionSuccessful = true,
context.Message.PrimaerdatenAuftragId
});
}
catch (Exception ex)
{
Log.Error(ex, "Failed to update archiveRecord with conversationId {ConversationId} in Elastic or SQL", context.ConversationId);
await context.Publish <IArchiveRecordUpdated>(new
{
context.Message.MutationId,
context.Message.ArchiveRecord.ArchiveRecordId,
ActionSuccessful = false,
context.Message.PrimaerdatenAuftragId,
ErrorMessage = ex.Message,
ex.StackTrace
});
await UpdatePrimaerdatenAuftragStatus(context, AufbereitungsServices.IndexService, currentStatus, ex.Message);
}
}
}
public async Task Consume(ConsumeContext <IArchiveRecordExtractFulltextFromPackage> context)
{
using (LogContext.PushProperty(nameof(context.ConversationId), context.ConversationId))
{
Log.Information("Received {CommandName} command with conversationId {ConversationId} from the bus",
nameof(IArchiveRecordExtractFulltextFromPackage), context.ConversationId);
// Process the package and extract the full text
var mutationId = context.Message.MutationId;
var archiveRecord = context.Message.ArchiveRecord;
var primaerdatenAuftragId = context.Message.PrimaerdatenAuftragId;
var success = await assetManager.ExtractFulltext(mutationId, archiveRecord, primaerdatenAuftragId);
if (success)
{
await UpdatePrimaerdatenAuftragStatus(context.Message, AufbereitungsServices.AssetService,
AufbereitungsStatusEnum.OCRAbgeschlossen);
// Put the final message on the queue for indexing.
// Important: use bus address here, because we are in SSZ and the original message comes
// from the BV-Zone
var ep = await context.GetSendEndpoint(new Uri(bus.Address, BusConstants.IndexManagerUpdateArchiveRecordMessageQueue));
await ep.Send <IUpdateArchiveRecord>(new
{
MutationId = mutationId,
ArchiveRecord = archiveRecord,
PrimaerdatenAuftragId = primaerdatenAuftragId
});
Log.Information("Put {CommandName} message on index queue with mutation ID: {MutationId}", nameof(IUpdateArchiveRecord),
mutationId);
}
else
{
// If package creation was not successful, stop syncing here and return failure.
Log.Error("Failed to extract fulltext for the supported file types for archiveRecord with conversationId {ConversationId}",
context.ConversationId);
var errorText = "Failed to extract fulltext. See log for further details.";
await UpdatePrimaerdatenAuftragStatus(context.Message, AufbereitungsServices.AssetService,
AufbereitungsStatusEnum.OCRAbgeschlossen, errorText);
await context.Publish <IArchiveRecordUpdated>(new
{
context.Message.MutationId,
context.Message.ArchiveRecord.ArchiveRecordId,
ActionSuccessful = false,
PrimaerdatenAuftragId = primaerdatenAuftragId,
ErrorMessage = errorText
});
Log.Information("Put {CommandName} message on index queue with mutation ID: {MutationId}", nameof(IArchiveRecordUpdated),
mutationId);
}
}
}
async Task MessageRedeliveryContext.ScheduleRedelivery(TimeSpan delay)
{
var receiveSettings = _context.ReceiveContext.GetPayload <ReceiveSettings>();
var delayExchangeAddress = GetDelayExchangeAddress(receiveSettings);
ISendEndpoint delayEndpoint = await _context.GetSendEndpoint(delayExchangeAddress).ConfigureAwait(false);
await delayEndpoint.Send(_context.Message, _context.CreateCopyContextPipe((x, y) => UpdateDeliveryContext(x, y, delay))).ConfigureAwait(false);
}
public Task Consume(ConsumeContext <EmailContentCreated> context)
{
try
{
var userName = Configuration.GetSection(Constants.SmtpSettings)[Constants.SmtpUserName];
var password = Configuration.GetSection(Constants.SmtpSettings)[Constants.SmtpPassword];
var address = Configuration.GetSection(Constants.SmtpSettings)[Constants.SmtpAddress];
var port = Configuration.GetSection(Constants.SmtpSettings)[Constants.SmtpPort];
var enableSsl = Configuration.GetSection(Constants.SmtpSettings)[Constants.SmtpEnableSsl];
var client = new SmtpClient(address, int.Parse(port))
{
Credentials = new NetworkCredential(userName, password),
EnableSsl = bool.Parse(enableSsl)
};
client.Send(context.Message.From, context.Message.To, context.Message.Subject, context.Message.Body);
var sendEndPoint = context.GetSendEndpoint(new System.Uri(Configuration.GetConnectionString(Constants.RabbitMQHost) + "/" + EventRouteConstants.LoggingService)).Result;
sendEndPoint.Send(new WriteLogEvent()
{
Level = LogLevel.Information.ToString(),
Logger = typeof(EmailNotificationConsumer).FullName,
Message = "Email was sent!",
Thread = ""
});
}
catch (System.Exception ex)
{
var sendEndPoint = context.GetSendEndpoint(new System.Uri(Configuration.GetConnectionString(Constants.RabbitMQHost) + "/" + EventRouteConstants.LoggingService)).Result;
sendEndPoint.Send(new WriteLogEvent()
{
Level = LogLevel.Error.ToString(),
Logger = typeof(EmailNotificationConsumer).FullName,
Message = $"Failure sending mail. {ex.Message} {ex.InnerException.Message}",
Thread = "",
Data = JsonConvert.SerializeObject(context.Message)
});
throw;
}
context.Respond(new { Status = true });
return(Task.CompletedTask);
}
public async Task Consume(ConsumeContext <RejectPoem> context)
{
Console.WriteLine("Poem rejected");
Uri sendEndpointUri = new Uri(string.Concat(ConfigurationManager.AppSettings["RabbitMQHost"], ConfigurationManager.AppSettings["PoemStatsQueueName"]));
var endpoint = await context.GetSendEndpoint(sendEndpointUri);
await endpoint.Send <RejectPoem>(new
{
CorrId = context.Message.CorrId,
});
}
public async Task Consume(ConsumeContext <IArchiveRecordAppendPackageMetadata> context)
{
var conversationEnricher = new PropertyEnricher(nameof(context.ConversationId), context.ConversationId);
var archiveRecordIdEnricher = new PropertyEnricher(nameof(context.Message.ArchiveRecord.ArchiveRecordId),
context.Message.ArchiveRecord?.ArchiveRecordId);
using (LogContext.Push(conversationEnricher, archiveRecordIdEnricher))
{
Log.Information("Received {CommandName} command with conversationId {ConversationId} from the bus",
nameof(IArchiveRecordAppendPackage), context.ConversationId);
if (context.Message.ArchiveRecord != null)
{
// Get the package from the repository
var result = repositoryManager.ReadPackageMetadata(context.Message.ArchiveRecord.Metadata.PrimaryDataLink,
context.Message.ArchiveRecord.ArchiveRecordId);
// Inform the world about the created package
if (result != null && result.Success && result.Valid)
{
// Add the metadata to the archive record.
context.Message.ArchiveRecord.PrimaryData.Add(result.PackageDetails);
Log.Information("Package metadata extraction was successful for packageId {packageId}", result.PackageDetails.PackageId);
var endpoint = await context.GetSendEndpoint(new Uri(context.SourceAddress,
BusConstants.AssetManagerSchdeduleForPackageSyncMessageQueue));
await endpoint.Send <IScheduleForPackageSync>(new
{
Workload = new ArchiveRecordAppendPackage
{
MutationId = context.Message.MutationId,
ArchiveRecord = context.Message.ArchiveRecord,
ElasticRecord = context.Message.ElasticRecord
}
});
}
else
{
// If package creation was not successful, stop syncing here and return failure.
Log.Error(
"Failed to extract primary metadata from repository for archiveRecord with conversationId {ConversationId} with message {ErrorMessage}",
context.ConversationId, result?.ErrorMessage);
await context.Publish <IArchiveRecordUpdated>(new
{
context.Message.MutationId,
context.Message.ArchiveRecord.ArchiveRecordId,
ActionSuccessful = false,
result?.ErrorMessage
});
}
}
}
}
private void WriteLog <T>(ConsumeContext <T> context, IConfiguration Configuration, LogLevel logLevel, string message, object data = null) where T : class
{
var sendEndPoint = context.GetSendEndpoint(new Uri($"{Configuration.GetConnectionString(MicroservicesConstants.MessageBusHost)}/{EventRouteConstants.LoggingService}")).Result;
sendEndPoint.Send(new WriteLogEvent()
{
Level = logLevel.ToString(),
Logger = typeof(T).FullName,
Message = message,
Data = data == null ? "" : JsonConvert.SerializeObject(data)
});
}
protected void WriteLog <T>(ConsumeContext <T> context, IConfiguration Configuration, LogLevel logLevel, string message, object data = null) where T : class
{
var sendEndPoint = context.GetSendEndpoint(new System.Uri(Configuration.GetConnectionString(Constants.RabbitMQHost) + "/" + EventRouteConstants.LoggingService)).Result;
sendEndPoint.Send(new WriteLogEvent()
{
Level = logLevel.ToString(),
Logger = typeof(T).FullName,
Message = message,
Data = data == null ? "" : JsonConvert.SerializeObject(data)
});
}
public static async Task <ISendEndpoint> GetSendEndpointAsync <TCommand>(this ConsumeContext context) where TCommand : class, new()
{
var busBaseAddress = context.DestinationAddress;
var className = typeof(TCommand).Name;
ValidationHelpers.EnsureNamingConventionForCommand(className);
var completeUri = BusAddressHelpers.CreateSendEndPointUri <TCommand>(busBaseAddress);
var sender = await context.GetSendEndpoint(completeUri);
return(sender);
}
public async Task Consume(ConsumeContext <OrderSubmittedEvent> context)
{
this.CustomerName = context.Message.CustomerName;
this.CoffeeTypeRequested = context.Message.CoffeeType;
this.ToppingsRequested = string.Join(",", context.Message.Toppings);
this.Amount = CoffeePriceCalculator.Compute(context.Message.CoffeeType, context.Message.Toppings);
var sendEndpoint = await context.GetSendEndpoint(requestPaymentEndpoint);
await sendEndpoint.Send <RequestPaymentCommand>(new { this.CorrelationId, this.Amount });
this.State = "AwaitingPayment";
}
private async Task SendMessage(string queue, ConsumeContext <ProceedBeautifiedPoem> context)
{
Uri sendEndpointUri = new Uri(string.Concat(ConfigurationManager.AppSettings["RabbitMQHost"], queue));
var endpoint = await context.GetSendEndpoint(sendEndpointUri);
await endpoint.Send <ProceedBeautifiedPoem>(new
{
UserId = context.Message.UserId,
CorrId = context.Message.CorrId,
Poem = context.Message.Poem
});
}
public async Task Consume(ConsumeContext <PrepareForTransformationMessage> context)
{
var conversationEnricher = new PropertyEnricher(nameof(context.ConversationId), context.ConversationId);
var archiveRecordIdEnricher = new PropertyEnricher(nameof(context.Message.RepositoryPackage.ArchiveRecordId), context.Message.RepositoryPackage.ArchiveRecordId);
var packageIdEnricher = new PropertyEnricher(nameof(context.Message.RepositoryPackage.PackageId), context.Message.RepositoryPackage.PackageId);
using (LogContext.Push(conversationEnricher, archiveRecordIdEnricher, packageIdEnricher))
{
Log.Information("Received {CommandName} command with conversationId {ConversationId} from the bus", nameof(PrepareForTransformationMessage), context.ConversationId);
// 1. Step: Extract Zip file(s)
preparationSteps.Add(ExtractRepositoryPackage);
// 2. Step: ConvertAreldaXml
preparationSteps.Add(ConvertAreldaMetadataXml);
// 3. Step: ConvertJp2ToPdf
preparationSteps.Add(ConvertSingleJp2ToPdf);
// 4. Step: Detect and mark files with large dimensions
preparationSteps.Add(DetectAndFlagLargeDimensions);
// 5. Step: Detect and optimize pdf files that need optimization
preparationSteps.Add(DetectAndOptimizePdf);
foreach (var step in preparationSteps)
{
var result = await step(context.Message);
// In case any step was not successful, fail the sync
if (!result.Success)
{
await PublishAssetReadyFailed(context, result.ErrorMessage);
return;
}
}
// Forward the prepared data to the next processing point
var endpoint = await context.GetSendEndpoint(new Uri(context.SourceAddress, BusConstants.AssetManagerTransformAssetMessageQueue));
await endpoint.Send(new TransformAsset
{
AssetType = context.Message.AssetType,
OrderItemId = context.Message.OrderItemId,
CallerId = context.Message.CallerId,
RetentionCategory = context.Message.RetentionCategory,
Recipient = context.Message.Recipient,
Language = context.Message.Language,
ProtectWithPassword = context.Message.ProtectWithPassword,
PrimaerdatenAuftragId = context.Message.PrimaerdatenAuftragId,
RepositoryPackage = context.Message.RepositoryPackage
});
}
}
public async Task Consume(ConsumeContext <OrderSubmittedEvent> context)
{
var endpoint = await context.GetSendEndpoint(new Uri($"rabbitmq://{Configuration.RabbitMqHost}/payment_initiate_payment"));
Logger.Info($"Initiating payment for customer {context.Message.CustomerId}, order {context.Message.OrderId} in total of {context.Message.Total}");
await endpoint.Send(new InitiatePaymentCommand()
{
CustomerId = context.Message.CustomerId,
OrderId = context.Message.OrderId,
Total = context.Message.Total
});
}