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 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;
});
}
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);
});
}
