public MessagesViewModel(IWebCommunicatorAsync <Message> webCommunicator, IMessageDataRepository dataRepository) : base(webCommunicator)
{
Refresh = new DelegateCommand(CanRefreshMessages, RefreshMessageCollection);
_dataRepository = dataRepository;
_messageCollection = new ObservableCollection <Message>(_dataRepository.GetAllMessages());
IsRefreshing = false;
}
public GetMessageDataPropertyProvider(IPropertyProvider <TInput, MessageData <TValue> > inputProvider, IMessageDataRepository repository = default)
{
_repository = repository;
_inputProvider = inputProvider;
_reader = MessageDataReaderFactory.CreateReader <TValue>();
}
protected override void ConfigureInMemoryReceiveEndpoint(IInMemoryReceiveEndpointConfigurator configurator)
{
string baseDirectory = AppDomain.CurrentDomain.BaseDirectory;
string messageDataPath = Path.Combine(baseDirectory, "MessageData");
var dataDirectory = new DirectoryInfo(messageDataPath);
var fileRepository = new FileSystemMessageDataRepository(dataDirectory);
ISymmetricKeyProvider keyProvider = new TestSymmetricKeyProvider();
var cryptoStreamProvider = new AesCryptoStreamProvider(keyProvider, "default");
_repository = new EncryptedMessageDataRepository(fileRepository, cryptoStreamProvider);
configurator.UseMessageData <MessageWithBigData>(_repository);
_received = Handler <MessageWithBigData>(configurator, async context =>
{
_receivedBody = await context.Message.Body.Value;
});
configurator.UseMessageData <MessageWithByteArray>(_repository);
_receivedBytes = Handler <MessageWithByteArray>(configurator, async context =>
{
_receivedBytesArray = await context.Message.Bytes.Value;
});
}
/// <summary>
/// Load the message data as part of the transform (replaces the property on the original message, to avoid multiple
/// loads of the same data).
/// </summary>
/// <typeparam name="T"></typeparam>
/// <typeparam name="TProperty"></typeparam>
/// <param name="configurator"></param>
/// <param name="propertyExpression"></param>
/// <param name="repository"></param>
public static void LoadMessageData <T, TProperty>(this ITransformConfigurator <T> configurator, Expression <Func <T, TProperty> > propertyExpression,
IMessageDataRepository repository)
{
var configuration = new LoadMessageDataTransformConfiguration <T, TProperty>(repository, propertyExpression.GetPropertyInfo());
configuration.Apply(configurator);
}
/// <summary>
/// Enable the loading of message data for the any message type that includes a MessageData property.
/// </summary>
/// <param name="configurator"></param>
/// <param name="repository"></param>
public static void UseMessageData(this IBusFactoryConfigurator configurator, IMessageDataRepository repository)
{
configurator.ConsumeTopology.AddConvention(new MessageDataConsumeTopologyConvention(repository));
configurator.SendTopology.AddConvention(new MessageDataSendTopologyConvention(repository));
// Courier does not use ConsumeContext, so it needs to be special
var observer = new CourierMessageDataConfigurationObserver(configurator, repository, false);
}
public MassTransitMessageDataHubLifetimeManager(IPublishEndpoint publishEndpoint,
IClientFactory clientFactory,
IHubProtocolResolver hubProtocolResolver,
IMessageDataRepository repository)
: base(publishEndpoint, clientFactory, hubProtocolResolver)
{
_repository = repository;
}
public MassTransitMessageDataHubLifetimeManager(HubLifetimeManagerOptions <THub> hubLifetimeManagerOptions,
IBus bus,
IHubProtocolResolver hubProtocolResolver,
IMessageDataRepository repository)
: base(hubLifetimeManagerOptions, bus, bus.CreateClientFactory().CreateRequestClient <GroupManagement <THub> >(), hubProtocolResolver)
{
_repository = repository;
}
protected override void ConfigureInputQueueEndpoint(IReceiveEndpointConfigurator configurator)
{
_messageDataRepository = new InMemoryMessageDataRepository();
configurator.UseMessageData <MessageWithByteArray>(_messageDataRepository);
_received = Handled <MessageWithByteArray>(configurator);
}
protected override void ConfigureInMemoryReceiveEndpoint(IInMemoryReceiveEndpointConfigurator configurator)
{
_messageDataRepository = new InMemoryMessageDataRepository();
configurator.UseMessageData(_messageDataRepository);
Handled <IHaveNoMessageData>(configurator);
}
public LoadMessageData(Uri address, IMessageDataRepository repository, IMessageDataConverter <T> converter, CancellationToken cancellationToken)
{
_address = address;
_repository = repository;
_converter = converter;
_cancellationToken = cancellationToken;
_value = new Lazy <Task <T> >(GetValue);
}
public NewMessageViewModel(IWebCommunicatorAsync <Message> webCommunicator, IMessageDataRepository dataRepository) : base(webCommunicator)
{
_dataRepository = dataRepository;
send = new DelegateCommand(CanSendMessage, SendMessage);
clear = new DelegateCommand(CanClearMessage, ClearMessage);
_message = new Message();
CountryCodes = new List <CountryCode>(dataRepository.GetCountryDialingCodes());
IsSending = false;
}
public UpdateDocumentInStorage(
ILogger <UpdateDocumentInStorage> logger,
IBlobStorageClient blobStorageClient,
IMessageDataRepository messageDataRepository
) : base(logger)
{
_blobStorageClient = blobStorageClient;
_messageDataRepository = messageDataRepository;
}
public LoadMessageData(Uri address, IMessageDataRepository repository, IMessageDataConverter <T> converter, TransformContext transformContext)
{
_address = address;
_repository = repository;
_converter = converter;
_transformContext = transformContext;
_value = new Lazy <Task <T> >(GetValue);
}
public AddDocumentToStorage(
ILogger <AddDocumentToStorage> logger,
IBlobStorageClient blobStorageClient,
IMessageDataRepository messageDataRepository
) : base(logger)
{
_blobStorageClient = blobStorageClient;
_messageDataRepository = messageDataRepository;
}
public GetMessageDataTransformConfiguration(IMessageDataRepository repository, PropertyInfo property)
{
if (repository == null)
{
throw new ArgumentNullException(nameof(repository));
}
_property = property;
_repository = repository;
}
public void Setup()
{
var baseDirectory = AppDomain.CurrentDomain.BaseDirectory;
var messageDataPath = Path.Combine(baseDirectory, "MessageData");
var dataDirectory = new DirectoryInfo(messageDataPath);
Console.WriteLine("Using data directory: {0}", dataDirectory);
_repository = new FileSystemMessageDataRepository(dataDirectory);
}
protected override void ConfigureInMemoryReceiveEndpoint(IInMemoryReceiveEndpointConfigurator configurator)
{
_messageDataRepository = new InMemoryMessageDataRepository();
configurator.UseMessageData <MessageWithByteArray>(_messageDataRepository);
_received = Handler <MessageWithByteArray>(configurator, async context =>
{
_receivedBytesArray = await context.Message.Bytes.Value;
});
}
public static Document ToDocument(this DocumentDto documentDto, IMessageDataRepository messageDataRepository)
{
var document = documentDto.ToDocument();
if (documentDto.Content.HasValue)
{
document.Content = GetArrayFromStream(messageDataRepository.Get(documentDto.Content.Address).Result);
}
return(document);
}
public void Setup()
{
string baseDirectory = AppDomain.CurrentDomain.BaseDirectory;
var messageDataPath = Path.Combine(baseDirectory, "MessageData");
var dataDirectory = new DirectoryInfo(messageDataPath);
Console.WriteLine("Using data directory: {0}", dataDirectory);
_repository = new FileSystemMessageDataRepository(dataDirectory);
}
protected override void ConfigureInMemoryBus(IInMemoryBusFactoryConfigurator configurator)
{
var baseDirectory = AppDomain.CurrentDomain.BaseDirectory;
var messageDataPath = Path.Combine(baseDirectory, "MessageData");
var dataDirectory = new DirectoryInfo(messageDataPath);
_repository = new FileSystemMessageDataRepository(dataDirectory);
configurator.UseMessageData(_repository);
}
public MainWindow(IWebCommunicatorAsync <Message> communicator, IMessageDataRepository dataRepository)
{
InitializeComponent();
_MessagesVM = new MessagesViewModel(communicator, dataRepository);
_NewMessageVM = new NewMessageViewModel(communicator, dataRepository);
_MessagesVM.Notification += ShowPopup;
_NewMessageVM.Notification += ShowPopup;
this.MessagesControl.DataContext = _MessagesVM;
this.NewMessageControl.DataContext = _NewMessageVM;
}
public UpdateDocumentHandler(
ICommandDispatcher bus,
IMapper mapper,
IClock clock,
MassTransit.IBus massTransitBus,
IMessageDataRepository messageDataRepository,
ILogger <UpdateDocumentCommand> logger)
: base(bus, mapper, logger)
{
_massTransitBus = massTransitBus;
_messageDataRepository = messageDataRepository;
_clock = clock;
}
public static MessageData <T> Load <T>(IMessageDataRepository repository, Uri address, TransformContext context)
{
if (typeof(T) == typeof(string))
{
return((MessageData <T>) new LoadMessageData <string>(address, repository, MessageDataConverter.String, context));
}
if (typeof(T) == typeof(byte[]))
{
return((MessageData <T>) new LoadMessageData <byte[]>(address, repository, MessageDataConverter.ByteArray, context));
}
throw new MessageDataException("Unknown message data type: " + TypeMetadataCache <T> .ShortName);
}
public static MessageData <T> Load <T>(IMessageDataRepository repository, Uri address, CancellationToken cancellationToken)
{
if (typeof(T) == typeof(string))
{
return((MessageData <T>) new GetMessageData <string>(address, repository, MessageDataConverter.String, cancellationToken));
}
if (typeof(T) == typeof(byte[]))
{
return((MessageData <T>) new GetMessageData <byte[]>(address, repository, MessageDataConverter.ByteArray, cancellationToken));
}
throw new MessageDataException("Unsupported message data type: " + TypeMetadataCache <T> .ShortName);
}
public static async Task <MessageData <byte[]> > PutBytes(this IMessageDataRepository repository, byte[] bytes, TimeSpan timeToLive,
CancellationToken cancellationToken = default(CancellationToken))
{
if (repository == null)
{
throw new ArgumentNullException(nameof(repository));
}
using (var ms = new MemoryStream(bytes, false))
{
Uri address = await repository.Put(ms, timeToLive, cancellationToken).ConfigureAwait(false);
return(new ConstantMessageData <byte[]>(address, bytes));
}
}
protected override void ConfigureInMemoryReceiveEndpoint(IInMemoryReceiveEndpointConfigurator configurator)
{
_messageDataRepository = new InMemoryMessageDataRepository();
configurator.UseMessageData(_messageDataRepository);
_received = Handler <IMessage>(configurator, async context =>
{
_body = context.Message.Document.Body;
_body0 = context.Message.Documents[0].Body;
_bodyList0 = context.Message.DocumentList[0].Body;
_bodyFirst = context.Message.DocumentIndex["First"].Body;
_bodySecond = context.Message.DocumentIndex["Second"].Body;
});
}
public MessageDataConfigurationObserver(IConsumePipeConfigurator configurator, IMessageDataRepository repository)
: base(configurator)
{
if (configurator == null)
{
throw new ArgumentNullException(nameof(configurator));
}
if (repository == null)
{
throw new ArgumentNullException(nameof(repository));
}
_repository = repository;
Connect(this);
}
public GetMessageDataTransformSpecification(IMessageDataRepository repository, IEnumerable <Type> knownTypes = null)
{
if (repository == null)
{
throw new ArgumentNullException(nameof(repository));
}
Replace = true;
var types = new HashSet <Type>(knownTypes ?? Enumerable.Empty <Type>())
{
typeof(TMessage)
};
AddMessageDataProperties(repository, types);
}
public static async Task <MessageData <string> > GetString(this IMessageDataRepository repository, Uri address,
CancellationToken cancellationToken = default(CancellationToken))
{
if (repository == null)
{
throw new ArgumentNullException(nameof(repository));
}
using (var ms = new MemoryStream())
{
Stream stream = await repository.Get(address, cancellationToken).ConfigureAwait(false);
await stream.CopyToAsync(ms).ConfigureAwait(false);
return(new ConstantMessageData <string>(address, Encoding.UTF8.GetString(ms.ToArray())));
}
}
public static async Task <MessageData <byte[]> > GetBytes(this IMessageDataRepository repository, Uri address,
CancellationToken cancellationToken = default(CancellationToken))
{
if (repository == null)
{
throw new ArgumentNullException(nameof(repository));
}
using (var ms = new MemoryStream())
{
Stream stream = await repository.Get(address, cancellationToken);
await stream.CopyToAsync(ms);
return(new ConstantMessageData <byte[]>(address, ms.ToArray()));
}
}
protected override void ConfigureInMemoryBus(IInMemoryBusFactoryConfigurator configurator)
{
var baseDirectory = AppDomain.CurrentDomain.BaseDirectory;
var messageDataPath = Path.Combine(baseDirectory, "MessageData");
var dataDirectory = new DirectoryInfo(messageDataPath);
var fileRepository = new FileSystemMessageDataRepository(dataDirectory);
ISymmetricKeyProvider keyProvider = new TestSymmetricKeyProvider();
var cryptoStreamProvider = new AesCryptoStreamProvider(keyProvider, "default");
_repository = new EncryptedMessageDataRepository(fileRepository, cryptoStreamProvider);
configurator.UseMessageData(_repository);
}
protected override void ConfigureInputQueueEndpoint(IReceiveEndpointConfigurator configurator)
{
string baseDirectory = AppDomain.CurrentDomain.BaseDirectory;
string messageDataPath = Path.Combine(baseDirectory, "MessageData");
var dataDirectory = new DirectoryInfo(messageDataPath);
_repository = new FileSystemMessageDataRepository(dataDirectory);
configurator.UseMessageData<MessageWithBigData>(_repository);
_received = Handled<MessageWithBigData>(configurator);
configurator.UseMessageData<MessageWithByteArray>(_repository);
_receivedBytes = Handled<MessageWithByteArray>(configurator);
}
protected override void ConfigureInputQueueEndpoint(IInMemoryReceiveEndpointConfigurator configurator)
{
string baseDirectory = AppDomain.CurrentDomain.BaseDirectory;
string messageDataPath = Path.Combine(baseDirectory, "MessageData");
var dataDirectory = new DirectoryInfo(messageDataPath);
var fileRepository = new FileSystemMessageDataRepository(dataDirectory);
ISymmetricKeyProvider keyProvider = new TestSymmetricKeyProvider();
var cryptoStreamProvider = new AesCryptoStreamProvider(keyProvider, "default");
_repository = new EncryptedMessageDataRepository(fileRepository, cryptoStreamProvider);
configurator.UseMessageData<MessageWithBigData>(_repository);
_received = Handled<MessageWithBigData>(configurator);
configurator.UseMessageData<MessageWithByteArray>(_repository);
_receivedBytes = Handled<MessageWithByteArray>(configurator);
}
/// <summary>
/// Provides encrypted stream support to ensure that message data is encrypted at rest.
/// </summary>
/// <param name="repository">The original message data repository where message data is stored.</param>
/// <param name="streamProvider">The encrypted stream provider</param>
public EncryptedMessageDataRepository(IMessageDataRepository repository, ICryptoStreamProvider streamProvider)
{
_repository = repository;
_streamProvider = streamProvider;
}
protected override void ConfigureInputQueueEndpoint(IReceiveEndpointConfigurator configurator)
{
_messageDataRepository = new InMemoryMessageDataRepository();
configurator.UseMessageData<MessageWithByteArray>(_messageDataRepository);
_received = Handled<MessageWithByteArray>(configurator);
}
