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