public static List <string> UnicastAddresses(this IOutgoingLogicalMessageContext context)
{
return(context.RoutingStrategies
.OfType <UnicastRoutingStrategy>()
.Select(x => ((UnicastAddressTag)x.Apply(emptyDictionary)).Destination)
.ToList());
}
public EncryptedValue Encrypt(string value, IOutgoingLogicalMessageContext context)
{
return(new EncryptedValue
{
EncryptedBase64Value = new string(value.Reverse().ToArray())
});
}
/// <summary>
/// The serializer should skip serializing the message.
/// </summary>
public static bool ShouldSkipSerialization(this IOutgoingLogicalMessageContext context)
{
Guard.AgainstNull(nameof(context), context);
if (context.Extensions.TryGet("MessageSerialization.Skip", out bool shouldSkipSerialization))
{
return(shouldSkipSerialization);
}
return(false);
}
public static IOutgoingLogicalMessageContext StorePipelineContextToOutgoingMessageHeader
(this IOutgoingLogicalMessageContext context,
string headerName)
{
if (context.Extensions.TryGet(headerName, out string headerValue))
{
context.Headers[headerName] = headerValue;
}
return(context);
}
/// <summary>
/// The serializer should skip serializing the message.
/// </summary>
public static bool ShouldSkipSerialization(this IOutgoingLogicalMessageContext context)
{
bool shouldSkipSerialization;
if (context.Extensions.TryGet("MessageSerialization.Skip", out shouldSkipSerialization))
{
return(shouldSkipSerialization);
}
return(false);
}
public static bool TryReadTransaction(this IOutgoingLogicalMessageContext context, out Transaction transaction)
{
if (context.Extensions.TryGet <TransportTransaction>(out var transportTransaction))
{
return(transportTransaction.TryGet(out transaction));
}
transaction = null;
return(false);
}
/// <summary>
/// Tries to retrieves an instance of <typeparamref name="T"/> from a <see cref="IOutgoingLogicalMessageContext"/>.
/// </summary>
public static bool TryGetDeliveryConstraint <T>(this IOutgoingLogicalMessageContext context, out T constraint) where T : DeliveryConstraint
{
List <DeliveryConstraint> constraints;
if (context.Extensions.TryGet(out constraints))
{
return(constraints.TryGet(out constraint));
}
constraint = null;
return(false);
}
public static MessageIntentEnum GetMessageIntent(this IOutgoingLogicalMessageContext message)
{
var messageIntent = default(MessageIntentEnum);
if (message.Headers.TryGetValue(Headers.MessageIntent, out var messageIntentString))
{
Enum.TryParse(messageIntentString, true, out messageIntent);
}
return(messageIntent);
}
public static string GetDestinationForUnicastMessages(this IOutgoingLogicalMessageContext context)
{
var sendAddressTags = context.RoutingStrategies
.OfType <UnicastRoutingStrategy>()
.Select(urs => urs.Apply(context.Headers))
.Cast <UnicastAddressTag>().ToList();
if (sendAddressTags.Count != 1)
{
return(null);
}
return(sendAddressTags.First().Destination);
}
public EncryptedValue Encrypt(string value, IOutgoingLogicalMessageContext context)
{
var encrypted = _client.EncryptAsync(new EncryptRequest
{
KeyId = _encryptionKeyIdentifier,
Plaintext = new System.IO.MemoryStream(Encoding.UTF8.GetBytes(value))
}).GetAwaiter().GetResult();
string base64Value = encrypted != null?Convert.ToBase64String(encrypted.CiphertextBlob.ToArray()) : null;
context.Headers[EncryptionHeaders.RijndaelKeyIdentifier] = _encryptionKeyIdentifier;
return(new EncryptedValue
{
EncryptedBase64Value = base64Value
});
}
public EncryptedValue Encrypt(string value, IOutgoingLogicalMessageContext context)
{
if (string.IsNullOrEmpty(encryptionKeyIdentifier))
{
throw new InvalidOperationException("It is required to set the rijndael key identifier.");
}
AddKeyIdentifierHeader(context);
using (var rijndael = new RijndaelManaged())
{
rijndael.Key = encryptionKey;
rijndael.Mode = CipherMode.CBC;
ConfigureIV(rijndael);
using (var encryptor = rijndael.CreateEncryptor())
{
using (var memoryStream = new MemoryStream())
{
using (var cryptoStream = new CryptoStream(memoryStream, encryptor, CryptoStreamMode.Write))
{
using (var writer = new StreamWriter(cryptoStream))
{
writer.Write(value);
writer.Flush();
cryptoStream.Flush();
cryptoStream.FlushFinalBlock();
return new EncryptedValue
{
EncryptedBase64Value = Convert.ToBase64String(memoryStream.ToArray()),
Base64Iv = Convert.ToBase64String(rijndael.IV)
};
}
}
}
}
}
}
public EncryptedValue Encrypt(string value, IOutgoingLogicalMessageContext context)
{
if (string.IsNullOrEmpty(encryptionKeyIdentifier))
{
throw new InvalidOperationException("It is required to set the rijndael key identifier.");
}
AddKeyIdentifierHeader(context);
using (var rijndael = new RijndaelManaged())
{
rijndael.Key = encryptionKey;
rijndael.Mode = CipherMode.CBC;
ConfigureIV(rijndael);
using (var encryptor = rijndael.CreateEncryptor())
{
using (var memoryStream = new MemoryStream())
{
using (var cryptoStream = new CryptoStream(memoryStream, encryptor, CryptoStreamMode.Write))
{
using (var writer = new StreamWriter(cryptoStream))
{
writer.Write(value);
writer.Flush();
cryptoStream.Flush();
cryptoStream.FlushFinalBlock();
return(new EncryptedValue
{
EncryptedBase64Value = Convert.ToBase64String(memoryStream.ToArray()),
Base64Iv = Convert.ToBase64String(rijndael.IV)
});
}
}
}
}
}
}
protected virtual void AddKeyIdentifierHeader(IOutgoingLogicalMessageContext context)
{
context.Headers[Headers.RijndaelKeyIdentifier] = encryptionKeyIdentifier;
}
protected virtual void AddKeyIdentifierHeader(IOutgoingLogicalMessageContext context)
{
context.Headers[Headers.RijndaelKeyIdentifier] = encryptionKeyIdentifier;
}
public static string MessageIntent(this IOutgoingLogicalMessageContext context) => MessageIntent(context.Headers);
public static string MessageIntent(this IOutgoingLogicalMessageContext context)
{
return(MessageIntent(context.Headers));
}
/// <summary>
/// Returns the incoming physical message if there is one currently processed.
/// </summary>
public static bool TryGetIncomingPhysicalMessage(this IOutgoingLogicalMessageContext context, out IncomingMessage message)
{
Guard.AgainstNull(nameof(context), context);
return(context.Extensions.TryGet(out message));
}
string ReturnDefaultConversationId(IOutgoingLogicalMessageContext context)
{
return(ConversationId.Default.Value);
}
public static void EncryptValue(this IEncryptionService encryptionService, ref string stringToEncrypt, IOutgoingLogicalMessageContext context)
{
var encryptedValue = encryptionService.Encrypt(stringToEncrypt, context);
stringToEncrypt = $"{encryptedValue.EncryptedBase64Value}@{encryptedValue.Base64Iv}";
}
public static void EncryptValue(this IEncryptionService encryptionService, EncryptedString encryptedString, IOutgoingLogicalMessageContext context)
{
encryptedString.EncryptedValue = encryptionService.Encrypt(encryptedString.Value, context);
encryptedString.Value = null;
}
public static void EncryptValue(this IEncryptionService encryptionService, WireEncryptedString wireEncryptedString, IOutgoingLogicalMessageContext context)
{
wireEncryptedString.EncryptedValue = encryptionService.Encrypt(wireEncryptedString.Value, context);
wireEncryptedString.Value = null;
}
public EncryptedValue Encrypt(string value, IOutgoingLogicalMessageContext context)
{
throw new System.NotImplementedException();
}
public static Guid GetMessageId(this IOutgoingLogicalMessageContext context)
{
return((context.Message.Instance as IEvent)?.EventId ??
(context.Message.Instance as IPaymentsCommand)?.CommandId ?? Guid.Empty);
}
public static string GetMessageName(this IOutgoingLogicalMessageContext context)
{
return(context.Message.Instance.GetType().Name);
}
/// <summary>
/// Adds a <see cref="DeliveryConstraint"/> to a <see cref="IOutgoingLogicalMessageContext"/>.
/// </summary>
public static void AddDeliveryConstraint(this IOutgoingLogicalMessageContext context, DeliveryConstraint constraint)
{
AddDeliveryConstraintInternal(context, constraint);
}
public EncryptedValue Encrypt(string value, IOutgoingLogicalMessageContext context)
{
throw new NotImplementedException();
}
public static void EncryptValue(this IEncryptionService encryptionService, ref string stringToEncrypt, IOutgoingLogicalMessageContext context)
{
var encryptedValue = encryptionService.Encrypt(stringToEncrypt, context);
stringToEncrypt = $"{encryptedValue.EncryptedBase64Value}@{encryptedValue.Base64Iv}";
}
/// <summary>
/// Requests the serializer to skip serializing the message.
/// </summary>
/// <remarks>
/// This can be used by an extension point needs to take control of the serialization.
/// For example the Callbacks implementation that skips serialization and instead uses
/// headers for passing the enum or int value.
/// </remarks>
public static void SkipSerialization(this IOutgoingLogicalMessageContext context)
{
context.Extensions.Set("MessageSerialization.Skip", true);
}
public OutgoingPhysicalMessageContext(byte[] body, IReadOnlyCollection <RoutingStrategy> routingStrategies, IOutgoingLogicalMessageContext parentContext)
: base(parentContext.MessageId, parentContext.Headers, parentContext)
{
Body = body;
RoutingStrategies = routingStrategies;
}
public EncryptedValue Encrypt(string value, IOutgoingLogicalMessageContext context)
{
return(hardcodedValue);
}
protected internal override void AddKeyIdentifierHeader(IOutgoingLogicalMessageContext context)
{
OutgoingKeyIdentifierSet = true;
}
public OutgoingPhysicalMessageContext(byte[] body, IReadOnlyCollection<RoutingStrategy> routingStrategies, IOutgoingLogicalMessageContext parentContext)
: base(parentContext.MessageId, parentContext.Headers, parentContext)
{
Body = body;
RoutingStrategies = routingStrategies;
}
public EncryptedValue Encrypt(string value, IOutgoingLogicalMessageContext context)
{
return hardcodedValue;
}
protected override void AddKeyIdentifierHeader(IOutgoingLogicalMessageContext context)
{
OutgoingKeyIdentifierSet = true;
}
/// <summary>
/// Creates a <see cref="IOutgoingPhysicalMessageContext" /> based on the current context.
/// </summary>
public static IOutgoingPhysicalMessageContext CreateOutgoingPhysicalMessageContext(this StageConnector <IOutgoingLogicalMessageContext, IOutgoingPhysicalMessageContext> stageConnector, byte[] messageBody, IReadOnlyCollection <RoutingStrategy> routingStrategies, IOutgoingLogicalMessageContext sourceContext)
{
Guard.AgainstNull(nameof(messageBody), messageBody);
Guard.AgainstNull(nameof(routingStrategies), routingStrategies);
Guard.AgainstNull(nameof(sourceContext), sourceContext);
return(new OutgoingPhysicalMessageContext(messageBody, routingStrategies, sourceContext));
}
/// <summary>
/// Requests the serializer to skip serializing the message.
/// </summary>
/// <remarks>
/// This can be used by an extension point needs to take control of the serialization.
/// For example the Callbacks implementation that skips serialization and instead uses
/// headers for passing the enum or int value.
/// </remarks>
public static void SkipSerialization(this IOutgoingLogicalMessageContext context)
{
Guard.AgainstNull(nameof(context), context);
context.Extensions.Set("MessageSerialization.Skip", true);
}
/// <summary>
/// Creates a <see cref="IOutgoingPhysicalMessageContext" /> based on the current context.
/// </summary>
public static IOutgoingPhysicalMessageContext CreateOutgoingPhysicalMessageContext(this StageConnector<IOutgoingLogicalMessageContext, IOutgoingPhysicalMessageContext> stageConnector, byte[] messageBody, IReadOnlyCollection<RoutingStrategy> routingStrategies, IOutgoingLogicalMessageContext sourceContext)
{
Guard.AgainstNull(nameof(messageBody), messageBody);
Guard.AgainstNull(nameof(routingStrategies), routingStrategies);
Guard.AgainstNull(nameof(sourceContext), sourceContext);
return new OutgoingPhysicalMessageContext(messageBody, routingStrategies, sourceContext);
}
