public void LoadMetadataFromJson()
{
var svcProvider = new ServiceContainer();
// Use StandardMetadataProvider
var metadataProvider = new StandardMetadataProvider();
svcProvider.AddService(typeof(IMetadataProvider), metadataProvider);
svcProvider.AddService(typeof(ISerializerConfigService), new StandardSerializerConfigService(null));
var metadataRepoFilePath = Path.Combine(Directory.GetCurrentDirectory(), @"MockData/SuperheroMetadata.json");
var metadataRepo = new FlatFileRepo <DynamicObjectType>(
metadataRepoFilePath,
svcProvider.GetService(typeof(ISerializerConfigService)) as ISerializerConfigService,
svcProvider
);
var dynamicMetadataProvider = new DynamicMetadataProvider();
dynamicMetadataProvider.Load(metadataRepo);
var metahumanObjType = dynamicMetadataProvider.GetDataType <ObjectType>("Headway.Dynamo.UnitTests.Mockdata.Metahuman");
Assert.IsNotNull(metahumanObjType);
var propSuperpower1 = metahumanObjType.GetPropertyByName("Superpower1");
Assert.IsNotNull(propSuperpower1);
}
public void VerifyReflectionPropertiesOnDynamicObjectType()
{
// Use StandardMetadataProvider
var metadataProvider = new StandardMetadataProvider();
// Register Person as a dynamic object type and verify return value
var dynamicPersonObjectType = metadataProvider.DynamicProvider.RegisterObjectType(typeof(Person).FullName, typeof(Person));
Assert.IsNotNull(dynamicPersonObjectType);
// Verify that DerivesFrom is System.Object
Assert.AreEqual(dynamicPersonObjectType.DerivesFrom.FullName, "System.Object");
// Verify that compile-time properties can be successfully found
var firstNameProp = dynamicPersonObjectType.GetPropertyByName("FirstName");
Assert.IsNotNull(firstNameProp);
var lastNameProp = dynamicPersonObjectType.GetPropertyByName("LastName");
Assert.IsNotNull(lastNameProp);
var extraStuffProp = dynamicPersonObjectType.GetPropertyByName("ExtraStuff");
Assert.IsNotNull(extraStuffProp);
Assert.IsNotNull(extraStuffProp.DataType);
}
public void TestInitialize()
{
this.svcProvider = new ServiceContainer();
var metadataProvider = new StandardMetadataProvider();
this.svcProvider.AddService(typeof(IMetadataProvider), metadataProvider);
}
public void when_getting_metadata_then_returns_namespace()
{
var provider = new StandardMetadataProvider();
var expected = typeof(given_a_metadata_provider).Namespace;
var metadata = provider.GetMetadata(this);
Assert.Contains(expected, metadata.Values);
Assert.Contains(StandardMetadata.Namespace, metadata.Keys);
}
public void when_getting_metadata_then_returns_namespace()
{
var provider = new StandardMetadataProvider();
var expected = typeof(given_a_metadata_provider).Namespace;
var metadata = provider.GetMetadata(this);
Assert.Contains(expected, metadata.Values);
Assert.Contains(StandardMetadata.Namespace, metadata.Keys);
}
public void when_getting_metadata_then_returns_assembly_name()
{
var provider = new StandardMetadataProvider();
var expected = typeof(given_a_metadata_provider).Assembly.GetName().Name;
var metadata = provider.GetMetadata(this);
Assert.IsTrue(metadata.Values.Contains(expected));
Assert.IsTrue(metadata.Keys.Contains(StandardMetadata.AssemblyName));
}
public void CreateContainer(IServiceCollection services, ILoggerFactory loggerFactory)
{
var serializer = new JsonTextSerializer();
services.AddSingleton <ITextSerializer>(serializer);
var metadataProvider = new StandardMetadataProvider();
services.AddSingleton <IMetadataProvider>(metadataProvider);
//services.AddScoped(provider =>
//{
// Func<string, ICommandHandler> accessor = key =>
// {
// switch (key)
// {
// case "RegistrationProcessManagerRouter":
// return provider.GetService<RegistrationProcessManagerRouter>();
// case "OrderCommandHandler":
// return provider.GetService<OrderCommandHandler>();
// case "AnchorsAvailabilityHandler":
// return provider.GetService<AnchorsAvailabilityHandler>();
// case "AnchorAssignmentsHandler":
// return provider.GetService<AnchorAssignmentsHandler>();
// default:
// throw new KeyNotFoundException(string.Format("Key is {0}.", key));
// }
// };
// return accessor;
//});
services.AddScoped <ICommandHandler, RegistrationProcessManagerRouter>();
services.AddScoped <ICommandHandler, OrderCommandHandler>();
services.AddScoped <ICommandHandler, AnchorsAvailabilityHandler>();
//services.AddScoped<ICommandHandler, ThirdPartyProcessorPaymentCommandHandler>("ThirdPartyProcessorPaymentCommandHandler");
services.AddScoped <ICommandHandler, AnchorAssignmentsHandler>();
services.AddSingleton <RegistrationProcessManagerRouter>();
services.AddSingleton <PricedOrderViewModelGenerator>();
services.AddSingleton <WorkshopViewModelGenerator>();
services.AddSingleton <DraftOrderViewModelGenerator>();
services.AddSingleton <AnchorAssignmentsViewModelGenerator>();
services.AddSingleton <AnchorAssignmentsHandler>();
services.AddSingleton <OrderEventHandler>();
services.AddSingleton <IPricingService, PricingService>();
// Conference management integration
//container.RegisterType<global::Conference.ConferenceContext>(new TransientLifetimeManager(), new InjectionConstructor("ConferenceManagement"));
OnCreateContainer(services, serializer, metadataProvider, loggerFactory);
}
public void OnCreateContainer1(IServiceCollection services)
{
var serializer = new JsonTextSerializer();
services.AddSingleton <ITextSerializer>(serializer);
var metadataProvider = new StandardMetadataProvider();
services.AddSingleton <IMetadataProvider>(metadataProvider);
services.AddSingleton <IBlobStorage, SqlBlobStorage>();
var eventBus = new EventBus(new MessageSender(_localConnectionString, "SqlBus.Events"), serializer);
var commandBus = new CommandBus(new MessageSender(_localConnectionString, "SqlBus.Commands"), serializer);
var commandProcessor = new CommandProcessor(new MessageReceiver(_localConnectionString, "SqlBus.Commands"), serializer);
var eventProcessor = new EventProcessor(new MessageReceiver(_localConnectionString, "SqlBus.Events"), serializer);
services.AddSingleton <IEventBus>(eventBus);
services.AddSingleton <ICommandBus>(commandBus);
services.AddSingleton <ICommandHandlerRegistry>(commandProcessor);
services.AddSingleton <IEventHandlerRegistry>(eventProcessor);
services.AddSingleton(provider =>
{
Func <string, IProcessor> accessor = key =>
{
switch (key)
{
case "CommandProcessor":
return(commandProcessor);
case "EventProcessor":
return(eventProcessor);
default:
throw new KeyNotFoundException(string.Format("current {0} key wasn't found in service collection", key));
}
};
return(accessor);
});
// Event log database and handler.
services.AddTransient(provider => new SqlMessageLog(provider.GetService <IDbContextScopeFactory>(),
provider.GetService <IAmbientDbContextLocator>(), serializer, metadataProvider));
services.AddScoped <IEventHandler, SqlMessageLogHandler>();
services.AddScoped <ICommandHandler, SqlMessageLogHandler>();
services.AddSingleton <IPricingService, PricingService>();
}
public static IEventSourcedRepository <SeatsAvailability> GetSeatsAvailabilityRepository()
{
var serializer = new JsonTextSerializer();
#if LOCAL
Func <EventStoreDbContext> ctxFactory = () => new EventStoreDbContext("EventStore");
return(new SqlEventSourcedRepository <SeatsAvailability>(ConferenceHelper.BuildEventBus(), serializer, ctxFactory));
#else
var settings = InfrastructureSettings.Read("Settings.xml");
var eventSourcingAccount = CloudStorageAccount.Parse(settings.EventSourcing.ConnectionString);
var eventStore = new EventStore(eventSourcingAccount, settings.EventSourcing.SeatsAvailabilityTableName);
var publisher = new EventStoreBusPublisher(ConferenceHelper.GetTopicSender("eventsAvailability"), eventStore, new EventStoreBusPublisherInstrumentation("worker", false));
var metadata = new StandardMetadataProvider();
return(new AzureEventSourcedRepository <SeatsAvailability>(eventStore, publisher, serializer, metadata, new MemoryCache("RepositoryCache")));
#endif
}
public void AddPropertyToDynamicObjectType()
{
// Use StandardMetadataProvider
var metadataProvider = new StandardMetadataProvider();
// Register Person as a dynamic object type and verify return value
var dynamicPersonObjectType = metadataProvider.DynamicProvider.RegisterObjectType(typeof(Person).FullName, typeof(Person));
Assert.IsNotNull(dynamicPersonObjectType);
// Add a new string property
dynamicPersonObjectType.AddProperty("Foo", IntegralType.String);
var fooProp = dynamicPersonObjectType.GetPropertyByName("Foo");
Assert.AreEqual(fooProp.FullName, "Headway.Dynamo.UnitTests.Mockdata.Person.Foo");
Assert.AreEqual(fooProp.DataType.FullName, "System.String");
}
public void TestInitialize()
{
this.svcProvider = new ServiceContainer();
var metadataProvider = new StandardMetadataProvider();
this.svcProvider.AddService(typeof(IMetadataProvider), metadataProvider);
var standardSerializerConfig = new StandardSerializerConfigService();
this.svcProvider.AddService(typeof(ISerializerConfigService), standardSerializerConfig);
var personArray = new Person[]
{
new Person()
{
Id = 1,
FirstName = "Fred",
LastName = "Flintstone",
DateOfBirth = new DateTime(200)
},
new Person()
{
Id = 1,
FirstName = "Wilma",
LastName = "Flintstone",
DateOfBirth = new DateTime(201)
},
new Person()
{
Id = 1,
FirstName = "Barney",
LastName = "Rubble",
DateOfBirth = new DateTime(300)
},
new Person()
{
Id = 1,
FirstName = "Betty",
LastName = "Rubble",
DateOfBirth = new DateTime(301)
}
};
this.personColl = personArray;
}
public static void Run(string connStr)
{
IMessageSender sender = new SqlMessageSender(connStr, "dbo.messages");
ITextSerializer serializer = new JsonTextSerializer();
IEventStore eventStore = new SqlEventStore(connStr, "dbo.events");
IEventBus eventBus = new EventBus(sender, serializer);
IMetadataProvider metaProvider = new StandardMetadataProvider();
IEventSourcedRepository <AppointmentAggregate> repo = new
EventSourcedRepository <AppointmentAggregate>(eventStore, eventBus, serializer, metaProvider);
ICommandDispatcher cmdDispatcher = new CommandDispatcher();
cmdDispatcher.Register(new AppointmentCommandHandler(repo));
IMessageReceiver cmdReceiver = new SqlMessageReceiver(connStr, "dbo.messages");
CommandProcessor commandProcessor = new CommandProcessor(cmdReceiver, serializer, cmdDispatcher);
commandProcessor.Start();
}
public void TestInitialize()
{
this.svcProvider = new ServiceContainer();
var metadataProvider = new StandardMetadataProvider();
this.svcProvider.AddService(typeof(IMetadataProvider), metadataProvider);
this.svcProvider.AddService(typeof(ISerializerConfigService), new StandardSerializerConfigService(null));
var restApiRepo = new FlatFileRepo <RestApi>(
@"MockData/RestApis.json",
svcProvider.GetService(typeof(ISerializerConfigService)) as ISerializerConfigService,
svcProvider
);
var restApiService = new RestApiServiceImpl();
restApiService.Load(restApiRepo.GetQueryable());
this.svcProvider.AddService(typeof(IRestApiService), restApiService);
}
public static void Run(string connStr)
{
IMessageSender sender = new SqlMessageSender(connStr, "dbo.messages");
ITextSerializer serializer = new JsonTextSerializer();
IEventStore eventStore = new SqlEventStore(connStr, "dbo.events");
IEventBus eventBus = new EventBus(sender, serializer);
IMetadataProvider metaProvider = new StandardMetadataProvider();
IReadModelStorage <AppointmentReadModel> readModelStorage = new InMemeoryStorage <AppointmentReadModel>();
IEventSourcedRepository <AppointmentAggregate> repo = new
EventSourcedRepository <AppointmentAggregate>(eventStore, eventBus, serializer, metaProvider);
IEventDispatcher evtDispatcher = new EventDispatcher();
evtDispatcher.Register(new AppointmentEventHandler(readModelStorage));
var evtReceiver = new SqlEventReceiver(new SqlEventStore(connStr, "dbo.events"));
var eventProcessor = new EventProcessor(evtReceiver, serializer, evtDispatcher);
eventProcessor.Start();
}
public void TestInitialize()
{
this.MetadataProvider = new StandardMetadataProvider();
}
static partial void OnCreateContainer(UnityContainer container)
{
var serializer = new JsonTextSerializer();
container.RegisterInstance <ITextSerializer>(serializer);
var metadata = new StandardMetadataProvider();
container.RegisterInstance <IMetadataProvider>(metadata);
var instrumentationEnabled = CloudConfigurationManager.GetSetting("InstrumentationEnabled") == "true";
// command bus
var settings = InfrastructureSettings.Read(HttpContext.Current.Server.MapPath(@"~\bin\Settings.xml"));
if (!Conference.Common.MaintenanceMode.IsInMaintainanceMode)
{
new ServiceBusConfig(settings.ServiceBus).Initialize();
}
var commandBus = new CommandBus(new TopicSender(settings.ServiceBus, "conference/commands"), metadata, serializer);
var synchronousCommandBus = new SynchronousCommandBusDecorator(commandBus);
container.RegisterInstance <ICommandBus>(synchronousCommandBus);
container.RegisterInstance <ICommandHandlerRegistry>(synchronousCommandBus);
// blob
var blobStorageAccount = CloudStorageAccount.Parse(settings.BlobStorage.ConnectionString);
container.RegisterInstance <IBlobStorage>(new CloudBlobStorage(blobStorageAccount, settings.BlobStorage.RootContainerName));
// support for inline command processing
container.RegisterType <ICommandHandler, OrderCommandHandler>("OrderCommandHandler");
container.RegisterType <ICommandHandler, ThirdPartyProcessorPaymentCommandHandler>("ThirdPartyProcessorPaymentCommandHandler");
container.RegisterType <ICommandHandler, SeatAssignmentsHandler>("SeatAssignmentsHandler");
container.RegisterType <DbContext, PaymentsDbContext>("payments", new TransientLifetimeManager(), new InjectionConstructor("Payments"));
container.RegisterType <IDataContext <ThirdPartyProcessorPayment>, SqlDataContext <ThirdPartyProcessorPayment> >(
new TransientLifetimeManager(),
new InjectionConstructor(new ResolvedParameter <Func <DbContext> >("payments"), typeof(IEventBus)));
container.RegisterType <IPricingService, PricingService>(new ContainerControlledLifetimeManager());
var topicSender = new TopicSender(settings.ServiceBus, "conference/events");
container.RegisterInstance <IMessageSender>(topicSender);
var eventBus = new EventBus(topicSender, metadata, serializer);
container.RegisterInstance <IEventBus>(eventBus);
var eventSourcingAccount = CloudStorageAccount.Parse(settings.EventSourcing.ConnectionString);
var eventStore = new EventStore(eventSourcingAccount, settings.EventSourcing.OrdersTableName);
container.RegisterInstance <IEventStore>(eventStore);
container.RegisterInstance <IPendingEventsQueue>(eventStore);
container.RegisterType <IEventStoreBusPublisher, EventStoreBusPublisher>(
new ContainerControlledLifetimeManager(),
new InjectionConstructor(
new TopicSender(settings.ServiceBus, "conference/eventsOrders"),
typeof(IPendingEventsQueue),
new EventStoreBusPublisherInstrumentation("web.public - orders", instrumentationEnabled)));
container.RegisterType(
typeof(IEventSourcedRepository <>),
typeof(AzureEventSourcedRepository <>),
new ContainerControlledLifetimeManager(),
new InjectionConstructor(typeof(IEventStore), typeof(IEventStoreBusPublisher), typeof(ITextSerializer), typeof(IMetadataProvider), new InjectionParameter <ObjectCache>(null)));
// to satisfy the IProcessor requirements.
container.RegisterType <IProcessor, PublisherProcessorAdapter>("EventStoreBusPublisher", new ContainerControlledLifetimeManager());
}
