public void Handle(ContractDeleted domainEvent)
{
domainEvent
.DeletedContract
.DataProcessingRegistrations
.Select(x => PendingReadModelUpdate.Create(x.Id, PendingReadModelUpdateSourceCategory.DataProcessingRegistration))
.ToList()
.ForEach(_pendingReadModelUpdateRepository.Add);
}
public void Add(PendingReadModelUpdate newItem)
{
if (newItem == null)
{
throw new ArgumentNullException(nameof(newItem));
}
AddMany(new[] { newItem });
}
private void HandleExternalReference(EntityLifeCycleEvent <ExternalReference> domainEvent)
{
//Schedule read model update for affected dpa if dpa was the target of the reference
var dpa = domainEvent.Entity.DataProcessingRegistration;
if (dpa != null)
{
_pendingReadModelUpdateRepository.Add(PendingReadModelUpdate.Create(dpa, PendingReadModelUpdateSourceCategory.DataProcessingRegistration));
}
}
public void Delete(PendingReadModelUpdate pendingUpdate)
{
if (pendingUpdate == null)
{
throw new ArgumentNullException(nameof(pendingUpdate));
}
_repository.Delete(pendingUpdate);
_repository.Save();
}
private void HandleExternalReference(EntityLifeCycleEvent <ExternalReference> domainEvent)
{
//Schedule read model update for affected ItSystemUsage if ItSystemUsage was the target of the reference
var itSystemUsage = domainEvent.Entity.ItSystemUsage;
if (itSystemUsage != null)
{
_pendingReadModelUpdateRepository.Add(PendingReadModelUpdate.Create(itSystemUsage, PendingReadModelUpdateSourceCategory.ItSystemUsage));
}
}
public override bool Execute(KitosContext context)
{
var organization = context.GetOrganization(_organizationName);
var globalAdmin = context.GetGlobalAdmin();
//Create the new it system
var systemWithSameName = GetItSystemnByName(context);
if (systemWithSameName != null)
{
Console.Out.WriteLine($"Existing ITSystem with name {_name} already exists in the database.");
return(false);
}
var itSystem = new ItSystem
{
Name = _name,
ObjectOwnerId = globalAdmin.Id,
OrganizationId = organization.Id,
LastChangedByUserId = globalAdmin.Id,
Uuid = Guid.NewGuid(),
ParentId = _parentId
};
context.ItSystems.Add(itSystem);
context.SaveChanges();
//Enable usage of the system
var itSystemUsage = new ItSystemUsage
{
ItSystemId = itSystem.Id,
OrganizationId = organization.Id,
ObjectOwnerId = globalAdmin.Id,
LastChangedByUserId = globalAdmin.Id
};
itSystemUsage.ResponsibleUsage = new ItSystemUsageOrgUnitUsage
{
ItSystemUsage = itSystemUsage,
ItSystemUsageId = itSystemUsage.Id,
OrganizationUnit = organization.OrgUnits.First(),
OrganizationUnitId = organization.Id
};
context.ItSystemUsages.Add(itSystemUsage);
context.SaveChanges();
var pendingReadModelUpdate = PendingReadModelUpdate.Create(itSystemUsage, PendingReadModelUpdateSourceCategory.ItSystemUsage);
context.PendingReadModelUpdates.Add(pendingReadModelUpdate);
context.SaveChanges();
return(true);
}
public void Handle(EntityCreatedEvent <ItSystemUsage> domainEvent)
{
var model = new ItSystemUsageOverviewReadModel();
BuildFromSource(model, domainEvent.Entity);
_readModelRepository.Add(model); //Add one immediately
//Schedule additional update to refresh once deferred updates are applied
_pendingReadModelUpdateRepository.Add(PendingReadModelUpdate.Create(domainEvent.Entity, PendingReadModelUpdateSourceCategory.ItSystemUsage));
}
public void Handle(EntityDeletedEvent <ItSystemUsage> domainEvent)
{
_readModelRepository.DeleteBySourceId(domainEvent.Entity.Id);
//Related overview models are also affected
foreach (var entityUsageRelation in domainEvent.Entity.UsageRelations)
{
_pendingReadModelUpdateRepository.Add(PendingReadModelUpdate.Create(entityUsageRelation.ToSystemUsageId, PendingReadModelUpdateSourceCategory.ItSystemUsage));
}
foreach (var entityUsedByRelation in domainEvent.Entity.UsedByRelations)
{
_pendingReadModelUpdateRepository.Add(PendingReadModelUpdate.Create(entityUsedByRelation.FromSystemUsageId, PendingReadModelUpdateSourceCategory.ItSystemUsage));
}
}
private int PerformUpdate(
int updatesExecuted,
HashSet <int> alreadyScheduledIds,
IEnumerable <int> idsOfAffectedUsages,
PendingReadModelUpdate sourceUpdate,
IDatabaseTransaction transaction)
{
var updates = idsOfAffectedUsages
.Where(id => alreadyScheduledIds.Contains(id) == false)
.ToList()
.Select(id => PendingReadModelUpdate.Create(id, PendingReadModelUpdateSourceCategory.ItSystemUsage))
.ToList();
updatesExecuted = CompleteUpdate(updatesExecuted, updates, sourceUpdate, transaction);
updates.ForEach(completedUpdate => alreadyScheduledIds.Add(completedUpdate.SourceId));
return(updatesExecuted);
}
private PendingReadModelUpdate MapReadModelUpdate(int id)
{
return(PendingReadModelUpdate.Create(id, _sourceCategory));
}
public void Handle(EntityDeletedEvent <ItInterface> domainEvent)
{
_pendingReadModelUpdateRepository.Add(PendingReadModelUpdate.Create(domainEvent.Entity.Id, PendingReadModelUpdateSourceCategory.ItSystemUsage_ItInterface));
}
public void Handle(EntityDeletedEvent <DataProcessingRegistration> domainEvent)
{
_pendingReadModelUpdateRepository.Add(PendingReadModelUpdate.Create(domainEvent.Entity.Id, PendingReadModelUpdateSourceCategory.ItSystemUsage_DataProcessingRegistration));
}
public void Handle(EntityUpdatedEvent <ItProject> domainEvent)
{
_pendingReadModelUpdateRepository.Add(PendingReadModelUpdate.Create(domainEvent.Entity.Id, PendingReadModelUpdateSourceCategory.ItSystemUsage_Project));
}
public void Handle(ContractDeleted domainEvent)
{
_pendingReadModelUpdateRepository.Add(PendingReadModelUpdate.Create(domainEvent.DeletedContract.Id, PendingReadModelUpdateSourceCategory.ItSystemUsage_Contract));
}
public void Handle(EntityUpdatedEvent <User> domainEvent)
{
_pendingReadModelUpdateRepository.Add(PendingReadModelUpdate.Create(domainEvent.Entity, PendingReadModelUpdateSourceCategory.DataProcessingRegistration_User));
}
public void Handle(EntityUpdatedEvent <BusinessType> domainEvent)
{
_pendingReadModelUpdateRepository.Add(PendingReadModelUpdate.Create(domainEvent.Entity.Id, PendingReadModelUpdateSourceCategory.ItSystemUsage_BusinessType));
}
public void Handle(EntityDeletedEvent <Organization> domainEvent)
{
_pendingReadModelUpdateRepository.Add(PendingReadModelUpdate.Create(domainEvent.Entity, PendingReadModelUpdateSourceCategory.ItSystemUsage_Organization));
}
public void Handle(EntityUpdatedEvent <DataProcessingBasisForTransferOption> domainEvent)
{
_pendingReadModelUpdateRepository.Add(PendingReadModelUpdate.Create(domainEvent.Entity.Id, PendingReadModelUpdateSourceCategory.DataProcessingRegistration_BasisForTransfer));
}
private int CompleteUpdate(int updatesExecuted, List <PendingReadModelUpdate> updates, PendingReadModelUpdate userUpdate,
IDatabaseTransaction transaction)
{
updates.ForEach(update => _updateRepository.Add(update));
_updateRepository.Delete(userUpdate);
transaction.Commit();
updatesExecuted++;
return(updatesExecuted);
}
public void Handle(NamedEntityChangedNameEvent <ItSystem> domainEvent)
{
_pendingReadModelUpdateRepository.Add(PendingReadModelUpdate.Create(domainEvent.Entity.Id, PendingReadModelUpdateSourceCategory.DataProcessingRegistration_ItSystem));
}
public void Handle(EntityUpdatedEvent <DataProcessingOversightOption> domainEvent)
{
_pendingReadModelUpdateRepository.Add(PendingReadModelUpdate.Create(domainEvent.Entity.Id, PendingReadModelUpdateSourceCategory.DataProcessingRegistration_OversightOption));
}
public void Handle(EntityUpdatedEvent <LocalBusinessType> domainEvent)
{
//Point to parent id since that's what the readmodel knows about
_pendingReadModelUpdateRepository.Add(PendingReadModelUpdate.Create(domainEvent.Entity.OptionId, PendingReadModelUpdateSourceCategory.ItSystemUsage_BusinessType));
}
public void Handle(EntityUpdatedEvent <User> domainEvent)
{
_pendingReadModelUpdateRepository.Add(PendingReadModelUpdate.Create(domainEvent.Entity, PendingReadModelUpdateSourceCategory.ItSystemUsage_User));
}
public void Handle(EntityUpdatedEvent <LocalDataProcessingOversightOption> domainEvent)
{
//Point to parent id since that's what the dpr knows about
_pendingReadModelUpdateRepository.Add(PendingReadModelUpdate.Create(domainEvent.Entity.OptionId, PendingReadModelUpdateSourceCategory.DataProcessingRegistration_OversightOption));
}
