public void Initialize()
{
var inMemoryUserRepository = new InMemoryUserRepository();
var inMemoryGroupRepository = new InMemoryGroupRepository();
var inMemoryKeyRepository = new InMemoryKeysRepository();
var inMemorySanctionRepository = new InMemorySanctionRepository();
var inMemoryEventRepository = new InMemoryEventRepository();
var groupSettings = new GroupSettings(2, 10, 0, 1000);
var emailSender = new Mock <IEmailSender>();
var publisher = new Mock <IEventPublisher>();
userSettings = new UserSettings("");
var adminKey = new Key("email", KeyAppointment.BecomeAdmin);
inMemoryKeyRepository.AddKey(adminKey);
_sanctionFacade = new SanctionFacade(inMemorySanctionRepository, inMemoryUserRepository, publisher.Object);
_groupFacade = new GroupFacade(inMemoryGroupRepository, inMemoryUserRepository, inMemorySanctionRepository,
new GroupSettings(3, 100, 0, 1000), publisher.Object);
_userFacade = new UserFacade(inMemoryUserRepository, inMemoryGroupRepository, inMemoryEventRepository,
publisher.Object);
_accountFacade = new AccountFacade(inMemoryKeyRepository, inMemoryUserRepository,
emailSender.Object, userSettings);
var creatorId = _accountFacade.RegUser("Alena", new Credentials("email", "password"), true, adminKey.Value);
_groupCreator = _userFacade.GetUser(creatorId);
}
public void No_events_in_empty_repo()
{
using (var sut = new InMemoryEventRepository(""))
{
Assert.Equal(0, sut.Count);
}
}
public void Initialize()
{
var emailSender = new Mock <IEmailSender>();
var keysRepository = new InMemoryKeysRepository();
var eventRepository = new InMemoryEventRepository();
var groupRepository = new InMemoryGroupRepository();
_userRepository = new InMemoryUserRepository();
var fileRepository = new InMemoryFileRepository();
_sanctionRepository = new InMemorySanctionRepository();
var userSettings = new UserSettings("");
var adminKey = new Key("adminEmail", KeyAppointment.BecomeModerator);
keysRepository.AddKey(adminKey);
var accountFacade = new AccountFacade(keysRepository, _userRepository, emailSender.Object, userSettings);
_publisher = new Mock <IEventPublisher>();
_userEditFacade = new UserEditFacade(_userRepository, fileRepository, _sanctionRepository);
_userFacade = new UserFacade(_userRepository, groupRepository, eventRepository, _publisher.Object);
_adminId = accountFacade.RegUser("admin", Credentials.FromRawData("adminEmail", "password"), false,
adminKey.Value);
_testUserId = accountFacade.RegUser("Ivan", Credentials.FromRawData("*****@*****.**", "1"), false);
}
public void ShouldComposeSnapshotOfExactNumberOfEvents()
{
// ARRANGE
var eventRepository = new InMemoryEventRepository();
var snapshotRepository = new InMemorySnapshotEventRepository();
var factory = new DefaultAggregateFactory();
var aggregateStore = new AggregateRepository(eventRepository, factory, snapshotRepository);
// Create a test aggregate.
var aggregateId = CombGuid.Generate();
var aggregate = aggregateStore.GetById <IncrementingAggregate>(aggregateId);
var snapshotSize = aggregate.SnapshotSize;
var numberOfTestEvents = 2 * snapshotSize + 1;
// Send test events to the aggregate.
Enumerable.Range(1, numberOfTestEvents)
.ToList()
.ForEach(x => aggregate.Tell(new IncrementingAggregate.Increment()));
// ACT
var orderedEvents = aggregateStore.Save(aggregate);
var snapshotVersion = snapshotRepository.GetVersionByAggregateId(aggregateId);
var snapshotOffer = (SnapshotOffer)snapshotRepository
.GetSnapshotEventByAggregateIdAndVersion(aggregateId, snapshotVersion ?? 0);
var newAggregate = aggregateStore.GetById <IncrementingAggregate>(aggregateId);
var newState = newAggregate.Ask <int>(new IncrementingAggregate.GetValue());
// ASSERT
Assert.AreEqual(numberOfTestEvents, orderedEvents.Length);
Assert.AreEqual(numberOfTestEvents - 1, snapshotOffer.Version);
Assert.AreEqual(numberOfTestEvents - 1, snapshotOffer.State);
Assert.AreEqual(numberOfTestEvents, newState);
}
public void Index_must_be_geq_0()
{
using (var sut = new InMemoryEventRepository(""))
{
Assert.Throws <InvalidOperationException>(() => sut.Store(-1, new TestEvent()));
Assert.Equal(0, sut.Count);
}
}
public void Store_once()
{
using (var sut = new InMemoryEventRepository(""))
{
sut.Store(0, new TestEvent());
Assert.Throws <InvalidOperationException>(() => sut.Store(0, new TestEvent()));
Assert.Equal(1, sut.Count);
}
}
public void Counting_events()
{
using (var sut = new InMemoryEventRepository(""))
{
sut.Store(0, new TestEvent());
Assert.Equal(1, sut.Count);
sut.Store(1, new TestEvent());
Assert.Equal(2, sut.Count);
}
}
public void Store_and_load()
{
using (var sut = new InMemoryEventRepository(""))
{
var e = new TestEvent {
Foo = "Hello"
};
sut.Store(0, e);
var result = (TestEvent)sut.Load(0);
Assert.Equal(e, result);
Assert.Equal(e.Id, result.Id);
Assert.Equal(e.Foo, result.Foo);
}
}
static async Task Main(string[] args)
{
var eventRepository = new InMemoryEventRepository();
var snapshotRepository = new InMemorySnapshotRepository();
var solution = new Solution(eventRepository, snapshotRepository);
solution.AddContext <EntityContext>();
solution.AddContext <AttributeContext>();
await solution.ExecuteCommand(new CreateEntity(Guid.NewGuid(), "Name1"));
await solution.ExecuteCommand(new CreateEntity(Guid.NewGuid(), "Name2"));
await solution.ExecuteCommand(new CreateEntity(Guid.NewGuid(), "Name2"));
}
public static async Task StartAsync()
{
using (await _queue.GetBlockingScope())
{
if (_initialized)
{
throw new InvalidOperationException("Bootstrapper has already been invoked");
}
var constantSettings = ApplicationBootstrapper.ConstantSettingsProvider.Find();
var directoryPath = AppDomain.CurrentDomain.BaseDirectory;
await WriteDatabaseInitializer.Initialize(new WriteDatabaseConfiguration(directoryPath, constantSettings.DatabaseFilePath, constantSettings.DatabaseEncryptionKey));
await ReadDatabaseInitializer.Initialize();
var applicationSettings = await new ApplicationSettingsRepository(WriteDatabaseInitializer.DatabaseContext).LoadAsync();
var applicationListenerUri = string.Format(constantSettings.ApplicationListenerUri, constantSettings.SystemIpAddress, applicationSettings.ApplicationCommunicationPort);
var builder = new ContainerBuilder();
var assemblies = new[] { Assembly.GetEntryAssembly() }
.Union(new[]
{
"iGP11.Library.dll",
"iGP11.Library.Component.dll",
"iGP11.Library.Component.DataAnnotations.dll",
"iGP11.Library.DDD.dll",
"iGP11.Library.EventPublisher.dll",
"iGP11.Library.File.dll",
"iGP11.Library.Hub.dll",
"iGP11.Library.Hub.Client.dll",
"iGP11.Library.Hub.Shared.dll",
"iGP11.Library.Hub.Transport.dll",
"iGP11.Library.Network.dll",
"iGP11.Library.Scheduler.dll",
"iGP11.Tool.Application.dll",
"iGP11.Tool.Application.Api.dll",
"iGP11.Tool.Domain.dll",
"iGP11.Tool.Infrastructure.Communication.dll",
"iGP11.Tool.Infrastructure.External.dll",
"iGP11.Tool.Infrastructure.Database.dll",
"iGP11.Tool.Localization.dll",
"iGP11.Tool.ReadModel.dll",
"iGP11.Tool.ReadModel.Api.dll",
"iGP11.Tool.Shared.dll"
}
.Select(Assembly.LoadFrom))
.ToArray();
foreach (var assembly in assemblies)
{
builder.RegisterAssemblyTypes(assembly)
.AsSelf()
.AsImplementedInterfaces();
}
builder.Register(
context =>
{
var listener = new NetworkListener($"{applicationListenerUri}/", context.Resolve <ILogger>());
foreach (dynamic handler in assemblies.GetImplementations(typeof(INetworkCommandHandler)).Select(context.Resolve))
{
listener.Register(handler);
}
return(listener);
})
.SingleInstance()
.AsSelf()
.AsImplementedInterfaces();
var proxyCommunicationPort = applicationSettings.ProxyCommunicationPort;
var systemIpAddress = constantSettings.SystemIpAddress;
var eventPublisher = new EventPublisher();
_scheduler = new BlockingScheduler(eventPublisher.Collect, Interval);
_scheduler.Start();
builder.Register(context => Logger.Current).SingleInstance().AsSelf().AsImplementedInterfaces();
builder.Register(context => WriteDatabaseInitializer.DatabaseContext).SingleInstance().AsSelf().AsImplementedInterfaces();
builder.Register(context => ReadDatabaseInitializer.Database).SingleInstance().AsSelf().AsImplementedInterfaces();
builder.Register(context => new CommunicatorFactory(systemIpAddress, proxyCommunicationPort, Logger.Current)).AsSelf().AsImplementedInterfaces();
builder.Register(context => eventPublisher).SingleInstance().AsSelf().AsImplementedInterfaces();
builder.Register(context => constantSettings.Plugins).AsSelf().AsImplementedInterfaces();
builder.Register(context => new NetworkPublisher(applicationListenerUri)).AsSelf().AsImplementedInterfaces();
builder.Register(context => new GameSettingsProcessWatcher(
constantSettings.Plugins,
systemIpAddress,
proxyCommunicationPort,
context.Resolve <ComponentAssembler>(),
context.Resolve <IDirectoryRepository>(),
context.Resolve <IGameRepository>(),
context.Resolve <IInjectionService>(),
Logger.Current,
context.Resolve <IProcessWatcher>()))
.SingleInstance()
.AsSelf()
.AsImplementedInterfaces();
var hubEventRepository = new InMemoryEventRepository <HubEvent>();
var endpointEventRepository = new InMemoryEventRepository <EndpointEvent>();
var transport = new InMemoryTransport();
var eventSerializerFactory = new DataContractEventSerializerFactory();
var hubClientFactory = new HubClientFactory(transport, eventSerializerFactory);
_hub = new Hub(hubEventRepository, endpointEventRepository, transport, Logger.Current);
var commandEndpointId = EndpointId.Generate();
var queryEndpointId = EndpointId.Generate();
builder.Register(context => new DomainActionBuilder(new ActionBuilder(hubClientFactory, eventSerializerFactory), commandEndpointId)).AsSelf().AsImplementedInterfaces();
DependencyResolver.Current = new AutofacResolver(builder.Build());
var domainCommandHubHost = new DomainCommandHubHost(commandEndpointId, queryEndpointId, hubClientFactory);
foreach (dynamic handler in assemblies.GetImplementations(typeof(IDomainCommandHandler <>)).Select(DependencyResolver.Current.Resolve))
{
ListenFor(domainCommandHubHost, handler);
}
var domainEventHubHost = new DomainEventHubHost(queryEndpointId, hubClientFactory);
foreach (dynamic handler in assemblies.GetImplementations(typeof(IDomainEventHandler <>)).Select(DependencyResolver.Current.Resolve))
{
ListenFor(domainEventHubHost, handler);
}
domainCommandHubHost.Start();
domainEventHubHost.Start();
_initialized = true;
}
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
StartLoggly();
services.AddWebSocketManager();
IFileRepository fileRepository;
IGroupRepository groupRepository;
IKeysRepository keysRepository;
ITagRepository tagRepository;
IUserRepository userRepository;
ISanctionRepository sanctionRepository;
IEventRepository eventRepository;
if (bool.Parse(Configuration.GetValue <string>("UseDB")))
{
var dbContext = Configuration.GetValue <string>("MysqlConnectionString");
using (var context = new EduhubContext(dbContext))
{
if (bool.Parse(Configuration.GetValue <string>("DeleteDB")))
{
context.Database.EnsureDeleted();
}
if (context.Database.EnsureCreated())
{
var dbName = dbContext.Split("database=")[1].Split(";")[0];
context.Database.ExecuteSqlCommand(
"ALTER DATABASE " + dbName + " CHARACTER SET utf8mb4 COLLATE utf8mb4_bin;");
var modelNames = context.Model.GetEntityTypes();
foreach (var modelname in modelNames)
{
var mapping = context.Model.FindEntityType(modelname.Name).Relational();
var tableName = mapping.TableName;
context.Database.ExecuteSqlCommand(
"alter table " + tableName.ToLower()
+ " convert to character set utf8mb4 collate utf8mb4_bin;");
}
}
context.Database.Migrate();
}
fileRepository = new InMysqlFileRepository(dbContext);
groupRepository = new InMysqlGroupRepository(dbContext);
keysRepository = new InMysqlKeyRepository(dbContext);
tagRepository = new InMysqlTagRepository(dbContext);
userRepository = new InMysqlUserRepository(dbContext);
sanctionRepository = new InMysqlSanctionRepository(dbContext);
eventRepository = new InMemoryEventRepository();
}
else
{
fileRepository = new InMemoryFileRepository();
groupRepository = new InMemoryGroupRepository();
keysRepository = new InMemoryKeysRepository();
tagRepository = new InMemoryTagRepository();
sanctionRepository = new InMemorySanctionRepository();
userRepository = new InMemoryUserRepository();
eventRepository = new InMemoryEventRepository();
}
var emailSettings = new EmailSettings(Configuration.GetValue <string>("EmailLogin"),
Configuration.GetValue <string>("Email"),
Configuration.GetValue <string>("EmailPassword"),
Configuration.GetValue <string>("SmtpAddress"),
Configuration.GetValue <string>("ConfirmAddress"),
int.Parse(Configuration.GetValue <string>("SmtpPort")));
var defaultAvatarFilename = Configuration.GetValue <string>("DefaultAvatarFilename");
var defaultAvatarContentType = Configuration.GetValue <string>("DefaultAvatarContentType");
var userSettings = new UserSettings(defaultAvatarFilename);
if (!fileRepository.DoesFileExists(defaultAvatarFilename))
{
fileRepository.AddFile(new UserFile(defaultAvatarFilename, defaultAvatarContentType));
}
var tagFacade = new TagFacade(tagRepository);
var emailSender = new EmailSender(emailSettings);
var notificationsDistributor = new NotificationsDistributor(groupRepository, userRepository, emailSender);
var groupSettings = new GroupSettings(Configuration.GetValue <int>("MinGroupSize"),
Configuration.GetValue <int>("MaxGroupSize"),
Configuration.GetValue <double>("MinGroupValue"),
Configuration.GetValue <double>("MaxGroupValue"));
var eventBusSettings = new EventBusSettings(Configuration.GetValue <string>("RabbitMqServerHostName"),
Configuration.GetValue <string>("RabbitMqServerVirtualHost"),
Configuration.GetValue <string>("RabbitMqAdminUserName"),
Configuration.GetValue <string>("RabbitMqAdminPassword"));
var eventBus = new EventBus(eventBusSettings);
eventBus.StartListening();
var adminsEventConsumer = new AdminsEventConsumer(notificationsDistributor, eventRepository);
var courseEventConsumer = new CourseEventConsumer(notificationsDistributor, eventRepository);
var curriculumEventConsumer = new CurriculumEventConsumer(notificationsDistributor, eventRepository);
var groupEventsConsumer = new GroupEventsConsumer(notificationsDistributor, eventRepository);
var invitationConsumer = new InvitationConsumer(notificationsDistributor, eventRepository);
var memberActionsConsumer = new MemberActionsConsumer(notificationsDistributor, eventRepository);
eventBus.RegisterConsumer(new TagPopularityConsumer(tagFacade));
eventBus.RegisterConsumer <ReportMessageEvent>(adminsEventConsumer);
eventBus.RegisterConsumer <SanctionsAppliedEvent>(adminsEventConsumer);
eventBus.RegisterConsumer <SanctionCancelledEvent>(adminsEventConsumer);
eventBus.RegisterConsumer <TeacherFoundEvent>(courseEventConsumer);
eventBus.RegisterConsumer <CourseFinishedEvent>(courseEventConsumer);
eventBus.RegisterConsumer <ReviewReceivedEvent>(courseEventConsumer);
eventBus.RegisterConsumer <CurriculumAcceptedEvent>(curriculumEventConsumer);
eventBus.RegisterConsumer <CurriculumDeclinedEvent>(curriculumEventConsumer);
eventBus.RegisterConsumer <CurriculumSuggestedEvent>(curriculumEventConsumer);
eventBus.RegisterConsumer <NewCreatorEvent>(groupEventsConsumer);
eventBus.RegisterConsumer <GroupIsFormedEvent>(groupEventsConsumer);
eventBus.RegisterConsumer <InvitationAcceptedEvent>(invitationConsumer);
eventBus.RegisterConsumer <InvitationDeclinedEvent>(invitationConsumer);
eventBus.RegisterConsumer <InvitationReceivedEvent>(invitationConsumer);
eventBus.RegisterConsumer <NewMemberEvent>(memberActionsConsumer);
eventBus.RegisterConsumer <MemberLeftEvent>(memberActionsConsumer);
var publisher = eventBus.GetEventPublisher();
var userFacade = new UserFacade(userRepository, groupRepository, eventRepository, publisher);
var groupEditFacade = new GroupEditFacade(groupRepository, groupSettings, publisher);
var userEditFacade = new UserEditFacade(userRepository, fileRepository, sanctionRepository);
var groupFacade = new GroupFacade(groupRepository, userRepository, sanctionRepository, groupSettings,
publisher);
var fileFacade = new FileFacade(fileRepository);
var chatFacade = new ChatFacade(groupRepository, userRepository);
var sanctionsFacade = new SanctionFacade(sanctionRepository, userRepository, publisher);
var userAccountFacade = new AccountFacade(keysRepository, userRepository, emailSender, userSettings);
var reportFacade = new ReportFacade(userRepository, eventRepository, publisher);
services.AddSingleton <IUserFacade>(userFacade);
services.AddSingleton <IGroupFacade>(groupFacade);
services.AddSingleton <IFileFacade>(fileFacade);
services.AddSingleton <IChatFacade>(chatFacade);
services.AddSingleton <IGroupEditFacade>(groupEditFacade);
services.AddSingleton <IUserEditFacade>(userEditFacade);
services.AddSingleton <ITagFacade>(tagFacade);
services.AddSingleton <ISanctionFacade>(sanctionsFacade);
services.AddSingleton <IAccountFacade>(userAccountFacade);
services.AddSingleton <IReportFacade>(reportFacade);
services.AddSingleton(Env);
userAccountFacade.CheckAdminExistence(Configuration.GetValue <string>("AdminEmail"));
services.AddSwaggerGen(current =>
{
current.SwaggerDoc("v1", new Info
{
Title = "EduHub API",
Version = "v1"
});
current.AddSecurityDefinition("Bearer", new ApiKeyScheme
{
Description =
"JWT Authorization header using the Bearer scheme. Example: \"Authorization: Bearer {token}\"",
Name = "Authorization",
In = "header",
Type = "apiKey"
});
current.OperationFilter <ExamplesOperationFilter>();
current.DescribeAllEnumsAsStrings();
var a = string.Format(@"{0}\EduHub.xml", AppDomain.CurrentDomain.BaseDirectory);
current.IncludeXmlComments(string.Format(@"{0}/EduHub.xml", AppDomain.CurrentDomain.BaseDirectory));
});
ConfigureSecurity(services);
if (Configuration.GetValue <bool>("Authorization"))
{
services.AddMvc(o =>
{
o.Filters.Add(new ExceptionFilter());
o.Filters.Add(new ActionFilter());
});
}
else
{
services.AddMvc(o =>
{
o.Filters.Add(new AllowAnonymousFilter());
o.Filters.Add(new ExceptionFilter());
o.Filters.Add(new ActionFilter());
});
}
services.AddCors(options =>
{
options.AddPolicy("AllowAnyOrigin",
builder => builder.AllowAnyOrigin().AllowAnyMethod().AllowAnyHeader());
});
}
