/// <summary>
/// Initializes a new instance of the <see cref="InventoryItemDetailView"/> class.
/// </summary>
/// <param name="database">The database.</param>
/// <param name="hub">The hub.</param>
public InventoryItemDetailView(
IReadModelRepository <InventoryItemDetailsDto, Guid> database,
InventoryHub hub)
{
_database = database;
_hub = hub;
}
public OrderDeletedEventHandler(
IReadModelRepository readModelRepository,
IInterProcessBus interProcessBus)
{
this.readModelRepository = readModelRepository;
this.interProcessBus = interProcessBus;
}
public StudentsProjectionActor(EventStoreDispatcher dispatcher, IReadModelRepository repository, ICatchupPositionRepository catchupPositionRepository)
: base(dispatcher, repository, catchupPositionRepository)
{
ReceiveAsync <StudentCreated>(async(s) =>
{
await repository.Add(new StudentReadModel
{
Id = s.Id,
LastName = s.LastName,
FirstMidName = s.FirstMidName,
EnrollmentDate = s.EnrollmentDate
});
});
ReceiveAsync <StudentUpdated>(async(s) =>
{
var student = await repository.GetById <StudentReadModel>(s.Id);
student.FirstMidName = s.FirstMidName;
student.LastName = s.LastName;
student.EnrollmentDate = s.EnrollmentDate;
await repository.Update(student);
});
ReceiveAsync <StudentDeleted>(async(s) =>
{
var student = await repository.GetById <StudentReadModel>(s.Id);
await repository.Delete(student);
});
}
public OnPlayerBoughtCreatePlayer(
IEventStore eventStore,
IReadModelRepository readModelRepository)
{
_eventStore = eventStore;
_readModelRepository = readModelRepository;
}
public static void Init(
IEventStoreRegistration eventStore,
IReadModelRepository readModelRepository)
{
if (ReadModelRepository != null)
{
throw new InvalidOperationException("Bootstrapper is already initialized.");
}
ReadModelRepository = readModelRepository;
var eventBus = new EventBus();
eventStore.SetEventBusToPublish(eventBus);
var viewModelGenerator = new ViewModelGenerator(readModelRepository);
eventBus.Register <ItemCreated>(viewModelGenerator);
eventBus.Register <ItemRenamed>(viewModelGenerator);
eventBus.Register <UnitsAdded>(viewModelGenerator);
eventBus.Register <UnitsRemoved>(viewModelGenerator);
eventBus.Register <ItemDisabled>(viewModelGenerator);
eventBus.Register <ItemEnabled>(viewModelGenerator);
var commandBus = new CommandBus();
commandBus.RegisterHandler(new CreateItemHandler(eventStore));
commandBus.RegisterHandler(new RenameItemHandler(eventStore));
commandBus.RegisterHandler(new AddUnitsHandler(eventStore));
commandBus.RegisterHandler(new RemoveUnitsHandler(eventStore));
commandBus.RegisterHandler(new DisableItemHandler(eventStore));
commandBus.RegisterHandler(new EnableItemHandler(eventStore));
CommandBus = commandBus;
}
public OrderService(
OrderCommandHandlers commandHandlers,
IReadModelRepository readModelRepository)
{
this.commandHandlers = commandHandlers;
this.readModelRepository = readModelRepository;
}
public ReadModelUpdateService(
IReadModelMapper <EntityTypeReadModel> entityTypeMapper,
IReadModelMapper <ItemStatBoostPokemonReadModel> itemStatBoostPokemonMapper,
IReadModelMapper <SimpleLearnableMoveReadModel> simpleLearnableMoveMapper,
IReadModelMapper <MoveReadModel> moveMapper,
IReadModelMapper <NatureReadModel> natureMapper,
IReadModelMapper <PokemonVarietyReadModel> pokemonVarietyMapper,
IReadModelMapper <ItemReadModel> itemMapper,
IReadModelRepository <EntityTypeReadModel> entityTypeRepository,
IReadModelRepository <ItemStatBoostPokemonReadModel> itemStatBoostPokemonRepository,
IReadModelRepository <SimpleLearnableMoveReadModel> simpleLearnableMoveRepository,
IReadModelRepository <MoveReadModel> moveRepository,
IReadModelRepository <NatureReadModel> natureRepository,
IReadModelRepository <PokemonVarietyReadModel> pokemonVarietyRepository,
IReadModelRepository <ItemReadModel> itemRepository,
ISpreadsheetImportReporter reporter)
{
_entityTypeMapper = entityTypeMapper;
_itemStatBoostPokemonMapper = itemStatBoostPokemonMapper;
_simpleLearnableMoveMapper = simpleLearnableMoveMapper;
_moveMapper = moveMapper;
_natureMapper = natureMapper;
_pokemonVarietyMapper = pokemonVarietyMapper;
_itemMapper = itemMapper;
_entityTypeRepository = entityTypeRepository;
_itemStatBoostPokemonRepository = itemStatBoostPokemonRepository;
_simpleLearnableMoveRepository = simpleLearnableMoveRepository;
_moveRepository = moveRepository;
_natureRepository = natureRepository;
_pokemonVarietyRepository = pokemonVarietyRepository;
_itemRepository = itemRepository;
_reporter = reporter;
}
public ProcessesController(IReadModelRepository <ProcessModel> readModelRepository, IPublishEndpoint publishEndpoint, IMapper mapper) : base(publishEndpoint)
{
this._mapper = mapper ??
throw new ArgumentNullException(nameof(mapper));
_readModelRepository = readModelRepository ??
throw new ArgumentNullException(nameof(readModelRepository));
}
public SpaceQuery(
ICurrentUser currentUser,
IReadModelRepository readModelRepository)
{
_currentUser = currentUser;
_readModelRepository = readModelRepository;
}
private DomainEventHandler(IReadModelRepository <TEntity, Guid> repository, DomainEvent orderEvent, IBus bus, ILogger <DomainEventHandler <TEntity> > logger)
{
_repository = repository;
_event = orderEvent;
_bus = bus;
_logger = logger ?? NullLogger <DomainEventHandler <TEntity> > .Instance;
}
public ArticlesController(IArticleClient articleClient, IMapper mapper,
IReadModelRepository <Database.Article, Guid> articleReadModelRepository)
{
_articleClient = articleClient;
_mapper = mapper;
_articleReadModelRepository = articleReadModelRepository;
}
public ValueCommentController(IMediator mediator,
IRepository <ValuesRootAggregate> rootAggregateRepository,
IReadModelRepository <ValueRecord> readModelRepository)
{
_mediator = mediator;
_rootAggregateRepository = rootAggregateRepository;
_readModelRepository = readModelRepository;
}
public void Handle(IEvent evt, IReadModelRepository repo)
{
if (evt is UserTileCreated userTileCreated)
{
//this is create read model case
this.UserGuid = userTileCreated.UserGuid;
this.TileGuid = userTileCreated.TileGuid;
this.TileId = userTileCreated.TileId;
repo.UserTileDeviceReadModels.Add(this);
}
if (evt is UserTileRemoved userTileRemoved)
{
var rm = repo.UserTileDeviceReadModels.FirstOrDefault(x => x.UserGuid == userTileRemoved.UserGuid &&
x.TileGuid == userTileRemoved.UserGuid
&& x.TileId == userTileRemoved.TileId);
if (rm == null)
{
return;
}
//tile deactivated - remove it from the list so it's not displayed on the UI anymore
repo.UserTileDeviceReadModels.Remove(rm);
}
if (evt is DeviceConnected deviceConnected)
{
//this is update read model case
var rm = repo.UserTileDeviceReadModels.
FirstOrDefault(x => x.TileId == deviceConnected.TileId);
if (rm != null)
{
rm.State = "Connected";
}
}
if (evt is DeviceStartedRinging deviceStartedRinging)
{
//this is update read model case
var rm = repo.UserTileDeviceReadModels.
FirstOrDefault(x => x.TileDeviceGuid == deviceStartedRinging.TileDeviceGuid);
if (rm == null)
{
return;
}
rm.RingState = "Ringing";
}
if (evt is DeviceDisconnected deviceDisconnected)
{
//this is update read model case
var rm = repo.UserTileDeviceReadModels.
FirstOrDefault(x => x.TileDeviceGuid == deviceDisconnected.TileDeviceGuid);
if (rm == null)
{
return;
}
rm.TileDeviceGuid = null;
}
}
public ReadModelEventHandler(
IReadModelRepository readModelRepository,
IVersionRepository versionRepository,
IEventFeed <ReadModelEventHandler <T> > eventFeed)
{
_readModelRepository = readModelRepository;
_versionRepository = versionRepository;
_eventFeed = eventFeed;
}
public QueryEventHandler(
IReadModelRepository readModelRepository,
IVersionRepository versionRepository,
IEventFeed <QueryEventHandler <TQuerry, TEvent> > eventFeed)
{
_readModelRepository = readModelRepository;
_versionRepository = versionRepository;
_eventFeed = eventFeed;
}
public RestoreNoteCommandHandler(
ICurrentUser currentUser,
IReadModelRepository readModelRepository,
IAggregateRepository aggregateRepository)
{
_currentUser = currentUser;
_readModelRepository = readModelRepository;
_aggregateRepository = aggregateRepository;
}
public InstructorsProjectionActor(EventStoreDispatcher dispatcher,
IReadModelRepository readModelRepository,
ICatchupPositionRepository catchupPositionRepository, IRepository <Course> courseRepository)
: base(dispatcher, readModelRepository, catchupPositionRepository)
{
ReceiveAsync <InstructorCreated>(async(i) =>
{
var instructorReadModel = new InstructorReadModel
{
Id = i.Id,
LastName = i.LastName,
FirstName = i.FirstName,
HireDate = i.HireDate,
};
await readModelRepository.Add(instructorReadModel);
});
ReceiveAsync <InstructorDetailsUpdated>(async(i) =>
{
var instructorReadModel = await readModelRepository.GetById <InstructorReadModel>(i.Id);
instructorReadModel.LastName = i.LastName;
instructorReadModel.FirstName = i.FirstName;
instructorReadModel.HireDate = i.HireDate;
await readModelRepository.Update(instructorReadModel);
});
ReceiveAsync <InstructorOfficeLocationChanged>(async(o) =>
{
var instructor = await readModelRepository.GetById <InstructorReadModel>(o.Id);
instructor.OfficeLocation = o.OfficeLocation;
await readModelRepository.Update(instructor);
});
ReceiveAsync <InstructorCourseAssigned>(async(c) =>
{
var course = await courseRepository.GetById(c.CourseId);
var instructorReadModel = await readModelRepository.GetById <InstructorReadModel>(c.Id);
instructorReadModel.CourseAssignments.Add(new AssignedCourse
{
Id = c.CourseId,
Title = course.Title,
Number = course.Number
});
await readModelRepository.Update(instructorReadModel);
});
ReceiveAsync <InstructorCourseUnassigned>(async(c) =>
{
var instructorReadModel = await readModelRepository.GetById <InstructorReadModel>(c.Id);
instructorReadModel.CourseAssignments.RemoveAll(x => x.Id == c.CourseId);
await readModelRepository.Update(instructorReadModel);
});
ReceiveAsync <InstructorDeleted>(async(i) =>
{
var instructorReadModel = await readModelRepository.GetById <InstructorReadModel>(i.Id);
await readModelRepository.Delete(instructorReadModel);
});
}
public BaseProjectionActor(EventStoreDispatcher dispatcher, IReadModelRepository repository, ICatchupPositionRepository catchupPositionRepository)
{
_catchupPositionRepository = catchupPositionRepository;
_dispatcher = dispatcher;
ReceiveAsync <SaveEventMessage>(async(s) =>
{
var position = new Position(s.CommitPosition, s.PreparePosition);
await _catchupPositionRepository.SavePosition <T>(position);
LastProcessedPosition = position;
});
}
private async Task <EventPosition> GetCurrentPosition(IReadModelRepository <EventPosition> repo)
{
var existing = await repo
.Single(x => x.ApplicationName == _applicationName);
if (existing == null)
{
existing = new EventPosition(0, 0, _applicationName);
await repo.Insert(existing);
}
return(existing);
}
public void Handle(IEvent evt, IReadModelRepository repo)
{
/*if (evt is UserSignedIn userSignedIn)
* {
*
* }
* //handlers for events
* if (evt is UserTileActivated userTileActivated)
* {
* this.UserId = userTileActivated.UserId;
* this
* }*/
}
public SiteService(
ICommandDispatcher dispatcher,
IReadModelRepository<Site> sites,
IReadModelRepository<Page> pages,
IReadModelRepository<SiteIdentity> identities,
IReadModelRepository<SiteOverview> overviews)
{
_dispatcher = dispatcher;
_sites = sites;
_pages = pages;
_identities = identities;
_overviews = overviews;
}
public ValuesEventConsumer(IOptions <SubscriberOptions> options,
IMongoClient mongoClient,
ILogger <ValuesEventConsumer> logger,
IReadModelRepository <ValueRecord> valueRecordsRepository,
IReadModelRepository <ReadPointer> readPointerRepository,
IEventStoreConnection eventStoreConnection) : base(options, eventStoreConnection)
{
_mongoClient = mongoClient;
_logger = logger;
_valueRecordsRepository = valueRecordsRepository;
_readPointerRepository = readPointerRepository;
// there must be at least one record!!!
_readPointer = _readPointerRepository.GetAll()
.First(x => x.SourceName == options.Value.TopicName);
}
public CoursesProjectionActor(EventStoreDispatcher dispatcher,
IReadModelRepository readModelRepository,
ICatchupPositionRepository catchupPositionRepository,
IRepository <Department> departmentRepository)
: base(dispatcher, readModelRepository, catchupPositionRepository)
{
_departmentRepository = departmentRepository;
ReceiveAsync <CourseCreated>(async(c) =>
{
var department = await departmentRepository.GetById(c.DepartmentId);
await readModelRepository.Add(new CourseReadModel
{
Id = c.Id,
Number = c.Number,
Title = c.Title,
Credits = c.Credits,
Department = department.Name,
DepartmentId = c.DepartmentId
});
});
ReceiveAsync <CourseUpdated>(async(c) =>
{
var course = await readModelRepository.GetById <CourseReadModel>(c.Id);
if (course.DepartmentId != c.DepartmentId)
{
var department = await departmentRepository.GetById(c.DepartmentId);
course.Department = department.Name;
}
course.Title = c.Title;
course.Credits = c.Credits;
course.DepartmentId = c.DepartmentId;
await readModelRepository.Update(course);
});
ReceiveAsync <CourseDeleted>(async(s) =>
{
var course = await readModelRepository.GetById <CourseReadModel>(s.Id);
await readModelRepository.Delete <CourseReadModel>(course);
});
ReceiveAsync <DepartmentUpdated>(async(d) =>
{
var coursesCollection = readModelRepository.GetCollection <CourseReadModel>();
await coursesCollection.UpdateManyAsync(x => x.DepartmentId == d.Id, Builders <CourseReadModel> .Update.Set(x => x.Department, d.Name));
});
}
public DepartmentsProjectionActor(EventStoreDispatcher dispatcher,
IReadModelRepository readModelRepository,
ICatchupPositionRepository catchupPositionRepository,
IRepository <Instructor> instructorRepository)
: base(dispatcher, readModelRepository, catchupPositionRepository)
{
_instructorRepository = instructorRepository;
ReceiveAsync <DepartmentCreated>(async(s) =>
{
await readModelRepository.Add(new DepartmentReadModel
{
Id = s.Id,
Name = s.Name,
Budget = s.Budget,
StartDate = s.Startdate
});
});
ReceiveAsync <DepartmentUpdated>(async(s) =>
{
var department = await readModelRepository.GetById <DepartmentReadModel>(s.Id);
department.Name = s.Name;
department.Budget = s.Budget;
department.StartDate = s.Startdate;
await readModelRepository.Update(department);
});
ReceiveAsync <DepartmentDeleted>(async(s) =>
{
var department = await readModelRepository.GetById <DepartmentReadModel>(s.Id);
await readModelRepository.Delete <DepartmentReadModel>(department);
});
ReceiveAsync <DepartmentAdministratorAssigned>(async(@event) =>
{
var instructorName = await GetInstructorName(@event.AdministratorId);
var department = await readModelRepository.GetById <DepartmentReadModel>(@event.DepartmentId);
department.Administrator = instructorName;
await readModelRepository.Update(department);
});
ReceiveAsync <DepartmentAdministratorUnassigned>(async(@event) =>
{
var department = await readModelRepository.GetById <DepartmentReadModel>(@event.DepartmentId);
department.Administrator = null;
await readModelRepository.Update(department);
});
}
public DeleteQueryHandler(IReadModelRepository readModelRepository)
{
_readModelRepository = readModelRepository;
}
public MatchCommandHandler(IEventStore eventStore, IReadModelRepository readModelRepository)
{
_eventStore = eventStore;
_readModelRepository = readModelRepository;
}
public GetCoursesQueryHandler(IReadModelRepository readModelRepository)
{
_readModelRepository = readModelRepository;
}
public MergeRequestDetailProjection(IReadModelRepository readModelRepository)
{
_readModelRepository = readModelRepository;
}
public ProductQueriesHandler(IReadModelRepository <ProductReadModel, Guid> repo)
{
_repo = repo;
}
public DojoById(IReadModelRepository<DojoDetails> repo)
{
_repo = repo;
}
public StudentRegistrationViewWriter(IReadModelRepository <StudentRegistrationView> studentRegistrationRepo, IReadModelRepository <DojoDetails> dojoDetailsRepository, IReadModelRepository <MartialArtistDetails> martialArtistRepository)
{
_studentRegistrationRepo = studentRegistrationRepo;
_dojoDetailsRepository = dojoDetailsRepository;
_martialArtistRepository = martialArtistRepository;
}
public Handler(IAggregateRepository repository, IReadModelRepository <InstrumentDto> readModelRepository) : base(repository)
{
_readModelRepository = readModelRepository ?? throw new ArgumentNullException(nameof(readModelRepository));
}
public GetMartialArtistDetailsByEmail(IReadModelRepository<MartialArtistDetails> repository)
{
_repository = repository;
}
public MartialArtistDetailsById(IReadModelRepository<MartialArtistDetails> repository)
{
_repository = repository;
}
public AllDojos(IReadModelRepository<DojoDetails> dojoRepo )
{
_dojoRepo = dojoRepo;
}
public OrderService(OrderCommandHandlers commandHandlers, IReadModelRepository readModelRepository)
{
this.commandHandlers = commandHandlers;
this.readModelRepository = readModelRepository;
}
public CurrentUserProvider(IReadModelRepository<MartialArtistDetails> userRepo,HttpContextBase context)
{
_userRepo = userRepo;
_context = context;
}
public RegistrationsBySchool(IReadModelRepository<StudentRegistrationView> repository)
{
_repository = repository;
}
public AllMatialArtists(IReadModelRepository<MartialArtistDetails> repository)
{
_repository = repository;
}
