private void Initialize(SaveEmployeeInputDto employee, EntityDependency[] dependencies) { RegisterCommandRepositoryFactory <Employee>(() => new EmployeeCommandRepository()); RegisterCommandRepositoryFactory <Person>(() => new PersonCommandRepository()); var employeeDependency = (Employee)dependencies?.SingleOrDefault()?.Entity; RootEntity = new Employee { Id = employee.EmployeeId, HireDate = employee.HireDate, Name = employee.Name, ProviderEmployeeId = (employeeDependency != null) ? employeeDependency.Id : employee.ProviderEmployeeId, CellPhone = new PhoneNumber { AreaCode = employee.CellPhone.AreaCode, Exchange = employee.CellPhone.Exchange, Number = employee.CellPhone.Number } }; Enqueue(new SaveEntityCommandOperation <Employee>(RootEntity, dependencies)); Enqueue(new DeleteLinksCommandOperation <Employee>(RootEntity, "UnlinkDependantsFromEmployee")); if (employee.Dependants?.Any() == true) { foreach (var dto in employee.Dependants) { ILinkedAggregateCommandOperation operation; if (dto is PersonInputDto) { operation = new AddLinkedAggregateCommandOperation <Employee, SavePersonCommandAggregate, PersonInputDto>( RootEntity, (PersonInputDto)dto, new EntityDependency[] { new EntityDependency { Entity = RootEntity, Selector = "Dependants" } } ); Enqueue(operation); } else { throw new NotImplementedException(); } } } }
private void Initialize(PersonInputDto person, EntityDependency[] dependencies) { RegisterCommandRepositoryFactory <Person>(() => new PersonCommandRepository()); var spouseDependency = (Person)dependencies?.SingleOrDefault()?.Entity; RootEntity = new Person { Id = person.PersonId, Name = person.Name, Gender = person.Gender, SpouseId = (spouseDependency != null) ? spouseDependency.Id : person.SpouseId }; Enqueue(new SaveEntityCommandOperation <Person>(RootEntity, dependencies)); Enqueue(new DeleteLinksCommandOperation <Person>(RootEntity, "UnlinkMarriedToFromPerson")); if (person.MarriedTo != null) { ILinkedAggregateCommandOperation operation; var marriedTo = person.MarriedTo; if (marriedTo is PersonInputDto) { operation = new AddLinkedAggregateCommandOperation <Person, SavePersonCommandAggregate, PersonInputDto>( RootEntity, (PersonInputDto)marriedTo, new EntityDependency[] { new EntityDependency { Entity = RootEntity, Selector = "MarriedTo" } } ); Enqueue(operation); } else { throw new NotImplementedException(); } Enqueue(new UpdateEntityCommandOperation <Person>(RootEntity, new EntityDependency[] { new EntityDependency { Entity = operation.CommandAggregate.RootEntity, Selector = "MarriedTo" } })); } }
private void Initialize(SaveSchoolInputDto school, EntityDependency[] dependencies) { RegisterCommandRepositoryFactory <OrganizationRole>(() => new OrganizationRoleCommandRepository()); RegisterCommandRepositoryFactory <School>(() => new SchoolCommandRepository()); RegisterCommandRepositoryFactory <Role>(() => new RoleCommandRepository()); RootEntity = new School { Id = school.SchoolId, IsCharter = school.IsCharter }; Enqueue(new SaveEntityCommandOperation <School>(RootEntity, dependencies)); Enqueue(new DeleteLinksCommandOperation <School>(RootEntity, "UnlinkOrganizationFromRole")); if (school.Organization != null) { ILinkedAggregateCommandOperation operation; if (school.Organization is OrganizationInputDto) { operation = new AddLinkedAggregateCommandOperation <School, SaveOrganizationCommandAggregate, OrganizationInputDto>( RootEntity, (OrganizationInputDto)school.Organization ); Enqueue(operation); } else { throw new NotImplementedException(); } Enqueue(new AddLinkedAggregateCommandOperation <School, CreateOrganizationRoleCommandAggregate, OrganizationRoleInputDto>( RootEntity, school.Organization.OrganizationRole, new EntityDependency[] { new EntityDependency { Entity = RootEntity, Selector = "Role" }, new EntityDependency { Entity = operation.CommandAggregate.RootEntity, Selector = "Organization" } } )); } }
private void Initialize(CourseInputDto course, EntityDependency[] dependencies) { RegisterCommandRepositoryFactory <Course>(() => new CourseCommandRepository()); RootEntity = new Course { Id = course.CourseId, Description = course.Description }; Enqueue(new SaveEntityCommandOperation <Course>(RootEntity, dependencies)); Enqueue(new DeleteLinksCommandOperation <Course>(RootEntity, "UnlinkRequiresFromCourse")); if (course.Requires?.Any() == true) { foreach (var dto in course.Requires) { ILinkedAggregateCommandOperation operation; if (dto is CourseInputDto) { operation = new AddLinkedAggregateCommandOperation <Course, SaveCourseCommandAggregate, CourseInputDto>( RootEntity, (CourseInputDto)dto ); Enqueue(operation); } else { throw new NotImplementedException(); } Enqueue(new AddLinkedAggregateCommandOperation <Course, CreatePreRequisiteCommandAggregate, PreRequisiteInputDto>( RootEntity, dto.PreRequisite, new EntityDependency[] { new EntityDependency { Entity = RootEntity, Selector = "IsRequiredBy" }, new EntityDependency { Entity = operation.CommandAggregate.RootEntity, Selector = "Requires" } } )); } } }
private void Initialize(ReplaceClassStudentsInputDto enrollment, EntityDependency[] dependencies) { RegisterCommandRepositoryFactory <Class>(() => new ClassCommandRepository()); RootEntity = new Class { Id = enrollment.ClassId }; Enqueue(new DeleteLinksCommandOperation <Class>(RootEntity, "UnlinkStudentsFromClass")); if (enrollment.Students?.Any() == true) { foreach (var dto in enrollment.Students) { ILinkedAggregateCommandOperation operation; if (dto is StudentInputDto) { operation = new AddLinkedAggregateCommandOperation <Class, CreateStudentCommandAggregate, StudentInputDto>( RootEntity, (StudentInputDto)dto ); Enqueue(operation); } else { throw new NotImplementedException(); } Enqueue(new AddLinkedAggregateCommandOperation <Class, CreateClassEnrollmentCommandAggregate, ClassEnrollmentInputDto>( RootEntity, dto.Enrollment, new EntityDependency[] { new EntityDependency { Entity = RootEntity, Selector = "Classes" }, new EntityDependency { Entity = operation.CommandAggregate.RootEntity, Selector = "Students" } } )); } } }
private void Initialize(SaveManagerInputDto manager, EntityDependency[] dependencies) { RegisterCommandRepositoryFactory <Manager>(() => new ManagerCommandRepository()); RegisterCommandRepositoryFactory <Employee>(() => new EmployeeCommandRepository()); var managerDependency = (Manager)dependencies?.SingleOrDefault()?.Entity; RootEntity = new Manager { Id = manager.ManagerId, Department = manager.Department, Name = manager.Name, SupervisorId = (managerDependency != null) ? managerDependency.Id : manager.SupervisorId }; Enqueue(new SaveEntityCommandOperation <Manager>(RootEntity, dependencies)); Enqueue(new DeleteLinksCommandOperation <Manager>(RootEntity, "UnlinkEmployeesFromManager")); if (manager.Employees?.Any() == true) { foreach (var dto in manager.Employees) { ILinkedAggregateCommandOperation operation; if (dto is EmployeeInputDto) { operation = new AddLinkedAggregateCommandOperation <Manager, SaveEmployeeCommandAggregate, EmployeeInputDto>( RootEntity, (EmployeeInputDto)dto, new EntityDependency[] { new EntityDependency { Entity = RootEntity, Selector = "Employees" } } ); Enqueue(operation); } else { throw new NotImplementedException(); } } } }
private void Initialize(OrganizationInputDto organization, EntityDependency[] dependencies) { RegisterCommandRepositoryFactory <Organization>(() => new OrganizationCommandRepository()); var addressDependency = (Address)dependencies?.SingleOrDefault()?.Entity; RootEntity = new Organization { Id = organization.OrganizationId, Name = organization.Name, AddressId = (addressDependency != null) ? addressDependency.Id : organization.AddressId, Phone = new Phone { Number = organization.Phone.Number } }; var existanceDependencies = new List <EntityDependency>(); Enqueue(new DeleteLinksCommandOperation <Organization>(RootEntity, "UnlinkAddressFromOrganization")); if (organization.Address != null) { var address = organization.Address; if (address is AddressInputDto) { var operation = new AddLinkedAggregateCommandOperation <Organization, SaveAddressCommandAggregate, AddressInputDto>( RootEntity, (AddressInputDto)address, dependencies ); Enqueue(operation); existanceDependencies.Add(new EntityDependency { Entity = operation.CommandAggregate.RootEntity, Selector = "Address" }); } else { throw new NotImplementedException(); } } Enqueue(new SaveEntityCommandOperation <Organization>(RootEntity, existanceDependencies.ToArray())); }
private void Initialize(SaveBookInputDto book, EntityDependency[] dependencies) { RegisterCommandRepositoryFactory <Book>(() => new BookCommandRepository()); RootEntity = new Book { Id = book.BookId, Title = book.Title, Category = book.Category, DatePublished = book.DatePublished, PublisherId = book.PublisherId, IsHardCopy = book.IsHardCopy }; Enqueue(new UpdateEntityCommandOperation <Book>(RootEntity, dependencies)); Enqueue(new DeleteLinksCommandOperation <Book>(RootEntity, "UnlinkPagesFromBook")); if (book.Pages?.Any() == true) { foreach (var dto in book.Pages) { ILinkedAggregateCommandOperation operation; if (dto is SavePageInputDto) { operation = new AddLinkedAggregateCommandOperation <Book, CreatePageCommandAggregate, SavePageInputDto>( RootEntity, (SavePageInputDto)dto, new EntityDependency[] { new EntityDependency { Entity = RootEntity, Selector = "Pages" } } ); Enqueue(operation); } else { throw new NotImplementedException(); } } } }
private void Initialize(PersonInputDto person, EntityDependency[] dependencies) { RegisterCommandRepositoryFactory <Person>(() => new PersonCommandRepository()); var leaderDependency = (Person)dependencies?.SingleOrDefault()?.Entity; RootEntity = new Person { Id = person.PersonId, Name = person.Name, Gender = person.Gender, LeaderId = (leaderDependency != null) ? leaderDependency.Id : person.LeaderId }; Enqueue(new SaveEntityCommandOperation <Person>(RootEntity, dependencies)); Enqueue(new DeleteLinksCommandOperation <Person>(RootEntity, "UnlinkDisciplesFromPerson")); if (person.Disciples?.Any() == true) { foreach (var dto in person.Disciples) { ILinkedAggregateCommandOperation operation; if (dto is PersonInputDto) { operation = new AddLinkedAggregateCommandOperation <Person, SavePersonCommandAggregate, PersonInputDto>( RootEntity, (PersonInputDto)dto, new EntityDependency[] { new EntityDependency { Entity = RootEntity, Selector = "Disciples" } } ); Enqueue(operation); } else { throw new NotImplementedException(); } } } }
private void Initialize(UpdateCountryInputDto country, EntityDependency[] dependencies) { RegisterCommandRepositoryFactory <Country>(() => new CountryCommandRepository()); RootEntity = new Country { Id = country.CountryCode, Name = country.Name, IsActive = country.IsActive }; Enqueue(new UpdateEntityCommandOperation <Country>(RootEntity, dependencies)); Enqueue(new DeleteLinksCommandOperation <Country>(RootEntity, "UnlinkCapitalCityFromCountry")); if (country.CapitalCity != null) { ILinkedAggregateCommandOperation operation; var capitalCity = country.CapitalCity; if (capitalCity is CreateCapitalCityInputDto) { operation = new AddLinkedAggregateCommandOperation <Country, CreateCapitalCityCommandAggregate, CreateCapitalCityInputDto>( RootEntity, (CreateCapitalCityInputDto)capitalCity, new EntityDependency[] { new EntityDependency { Entity = RootEntity, Selector = "CapitalCity" } } ); Enqueue(operation); } else { throw new NotImplementedException(); } } }
private void Initialize(BookAddPagesInputDto book, EntityDependency[] dependencies) { RegisterCommandRepositoryFactory <Book>(() => new BookCommandRepository()); RootEntity = new Book { Id = book.BookId }; if (book.Pages?.Any() == true) { foreach (var dto in book.Pages) { ILinkedAggregateCommandOperation operation; if (dto is SavePageInputDto) { operation = new AddLinkedAggregateCommandOperation <Book, CreatePageCommandAggregate, SavePageInputDto>( RootEntity, (SavePageInputDto)dto, new EntityDependency[] { new EntityDependency { Entity = RootEntity, Selector = "Pages" } } ); Enqueue(operation); } else { throw new NotImplementedException(); } } } }
private void Initialize(SavePersonInputDto organization, EntityDependency[] dependencies) { RegisterCommandRepositoryFactory <Person>(() => new PersonCommandRepository()); RootEntity = new Person { Id = organization.PersonId, Name = organization.Name }; Enqueue(new SaveEntityCommandOperation <Person>(RootEntity, dependencies)); Enqueue(new DeleteLinksCommandOperation <Person>(RootEntity, "UnlinkPhonesFromPerson")); if (organization.Phones?.Any() == true) { foreach (var dto in organization.Phones) { ILinkedAggregateCommandOperation operation; if (dto is SavePhoneInputDto) { operation = new AddLinkedAggregateCommandOperation <Person, SavePhoneCommandAggregate, SavePhoneInputDto>( RootEntity, (SavePhoneInputDto)dto, new EntityDependency[] { new EntityDependency { Entity = RootEntity, Selector = "Phones" } } ); Enqueue(operation); } else { throw new NotImplementedException(); } } } Enqueue(new DeleteLinksCommandOperation <Person>(RootEntity, "UnlinkAddressFromPerson")); if (organization.Address != null) { ILinkedAggregateCommandOperation operation; var address = organization.Address; if (address is SaveAddressInputDto) { operation = new AddLinkedAggregateCommandOperation <Person, SaveAddressCommandAggregate, SaveAddressInputDto>( RootEntity, (SaveAddressInputDto)address, new EntityDependency[] { new EntityDependency { Entity = RootEntity, Selector = "Address" } } ); Enqueue(operation); } else { throw new NotImplementedException(); } } }
private void Initialize(SaveEmployeeInputDto employee, EntityDependency[] dependencies) { RegisterCommandRepositoryFactory <Employee>(() => new EmployeeCommandRepository()); RegisterCommandRepositoryFactory <Person>(() => new PersonCommandRepository()); var marriedToDependency = (Person)dependencies?.SingleOrDefault()?.Entity; RootEntity = new Employee { Id = employee.EmployeeId, HireDate = employee.HireDate, Name = employee.Name, MarriedToPersonId = (marriedToDependency != null) ? marriedToDependency.Id : employee.MarriedToPersonId, CellPhone = (employee.CellPhone != null) ? new PhoneNumber { AreaCode = employee.CellPhone.AreaCode, Exchange = employee.CellPhone.Exchange, Number = employee.CellPhone.Number } : null }; Enqueue(new SaveEntityCommandOperation <Employee>(RootEntity, dependencies)); Enqueue(new DeleteLinksCommandOperation <Employee>(RootEntity, "UnlinkSpouseFromPerson")); if (employee.Spouse != null) { ILinkedAggregateCommandOperation operation; var spouse = employee.Spouse; if (spouse is PersonInputDto) { operation = new AddLinkedAggregateCommandOperation <Employee, SavePersonCommandAggregate, PersonInputDto>( RootEntity, (PersonInputDto)spouse, new EntityDependency[] { new EntityDependency { Entity = RootEntity, Selector = "Spouse" } } ); Enqueue(operation); } else { throw new NotImplementedException(); } Enqueue(new UpdateEntityCommandOperation <Employee>(RootEntity, new EntityDependency[] { new EntityDependency { Entity = operation.CommandAggregate.RootEntity, Selector = "Spouse" } })); } }
private void Initialize(SavePersonInputDto person, EntityDependency[] dependencies) { RegisterCommandRepositoryFactory <Person>(() => new PersonCommandRepository()); var marriedToPersonDependency = (Person)dependencies?.SingleOrDefault(d => d.Selector == "MarriedToPerson")?.Entity; var dependsOnPersonDependency = (Person)dependencies?.SingleOrDefault(d => d.Selector == "DependsOnPerson")?.Entity; RootEntity = new Person { Id = person.PersonId, Name = person.Name, MarriedPersonId = (marriedToPersonDependency != null) ? marriedToPersonDependency.Id : person.MarriedPersonId, ProviderPersonId = (dependsOnPersonDependency != null) ? dependsOnPersonDependency.Id : person.ProviderPersonId }; Enqueue(new SaveEntityCommandOperation <Person>(RootEntity, dependencies)); Enqueue(new DeleteLinksCommandOperation <Person>(RootEntity, "UnlinkSpouseFromPerson")); if (person.Spouse != null) { ILinkedAggregateCommandOperation operation; var spouse = person.Spouse; if (spouse is SavePersonInputDto) { operation = new AddLinkedAggregateCommandOperation <Person, SavePersonCommandAggregate, SavePersonInputDto>( RootEntity, (SavePersonInputDto)spouse, new EntityDependency[] { new EntityDependency { Entity = RootEntity, Selector = "Spouse" } } ); Enqueue(operation); } else { throw new NotImplementedException(); } Enqueue(new UpdateEntityCommandOperation <Person>(RootEntity, new EntityDependency[] { new EntityDependency { Entity = operation.CommandAggregate.RootEntity, Selector = "Spouse" } })); } Enqueue(new DeleteLinksCommandOperation <Person>(RootEntity, "UnlinkDependantsFromPerson")); if (person.Dependants?.Any() == true) { foreach (var dto in person.Dependants) { ILinkedAggregateCommandOperation operation; if (dto is SavePersonInputDto) { operation = new AddLinkedAggregateCommandOperation <Person, SavePersonCommandAggregate, SavePersonInputDto>( RootEntity, (SavePersonInputDto)dto, new EntityDependency[] { new EntityDependency { Entity = RootEntity, Selector = "Dependants" } } ); Enqueue(operation); } else { throw new NotImplementedException(); } } } }
private void Initialize(SaveMechanicInputDto mechanic, EntityDependency[] dependencies) { RegisterCommandRepositoryFactory <Mechanic>(() => new MechanicCommandRepository()); RootEntity = new Mechanic { Id = mechanic.MechanicId, Name = mechanic.Name }; Enqueue(new SaveEntityCommandOperation <Mechanic>(RootEntity, dependencies)); Enqueue(new DeleteLinksCommandOperation <Mechanic>(RootEntity, "UnlinkVehiclesFromMechanic")); if (mechanic.Vehicles?.Any() == true) { foreach (var dto in mechanic.Vehicles) { ILinkedAggregateCommandOperation operation; if (dto is CarInputDto) { operation = new AddLinkedAggregateCommandOperation <Mechanic, SaveCarCommandAggregate, CarInputDto>( RootEntity, (CarInputDto)dto, new EntityDependency[] { new EntityDependency { Entity = RootEntity, Selector = "Vehicles" } } ); Enqueue(operation); } else if (dto is TruckInputDto) { operation = new AddLinkedAggregateCommandOperation <Mechanic, SaveTruckCommandAggregate, TruckInputDto>( RootEntity, (TruckInputDto)dto, new EntityDependency[] { new EntityDependency { Entity = RootEntity, Selector = "Vehicles" } } ); Enqueue(operation); } else if (dto is VehicleInputDto) { operation = new AddLinkedAggregateCommandOperation <Mechanic, SaveVehicleCommandAggregate, VehicleInputDto>( RootEntity, (VehicleInputDto)dto, new EntityDependency[] { new EntityDependency { Entity = RootEntity, Selector = "Vehicles" } } ); Enqueue(operation); } else { throw new NotImplementedException(); } } } }