public Result <DataProcessingRegistration, OperationError> AssignDataProcessingRegistration(ItContract contract, int dataProcessingRegistrationId)
{
if (contract == null)
{
throw new ArgumentNullException(nameof(contract));
}
return(_dataProcessingRegistrationRepository
.GetById(dataProcessingRegistrationId)
.Match
(
contract.AssignDataProcessingRegistration,
() => new OperationError("Data processing registration ID is not valid", OperationFailure.BadInput)
));
}
public Maybe <IEntityWithAdvices> Resolve(DomainModel.Advice.Advice advice)
{
if (advice?.Type != null && advice.RelationId != null)
{
var adviceRelationId = advice.RelationId.Value;
switch (advice.Type)
{
case RelatedEntityType.itContract:
return(_itContractRepository.GetById(adviceRelationId));
case RelatedEntityType.itSystemUsage:
return(_itSystemUsageRepository.GetSystemUsage(adviceRelationId));
case RelatedEntityType.itProject:
return(_itProjectRepository.GetById(adviceRelationId));
case RelatedEntityType.dataProcessingRegistration:
return(_dataProcessingRegistrationRepository.GetById(adviceRelationId).GetValueOrDefault());
case RelatedEntityType.itInterface: //Intended fallthrough
default:
throw new NotSupportedException("Unsupported object type:" + advice.Type);
}
}
return(Maybe <IEntityWithAdvices> .None);
}
public Result <IEnumerable <ExternalReference>, OperationFailure> DeleteByDataProcessingRegistrationId(int id)
{
return(_dataProcessingRegistrationRepository
.GetById(id)
.Select(DeleteExternalReferences)
.Match(r => r, () => OperationFailure.NotFound));
}
public Result <DataProcessingRegistration, OperationError> Delete(int id)
{
using var transaction = _transactionManager.Begin(IsolationLevel.Serializable);
var result = _repository.GetById(id);
if (result.IsNone)
{
return(new OperationError(OperationFailure.NotFound));
}
var registrationToDelete = result.Value;
if (!_authorizationContext.AllowDelete(registrationToDelete))
{
return(new OperationError(OperationFailure.Forbidden));
}
_repository.DeleteById(id);
transaction.Commit();
return(registrationToDelete);
}
public Task <Result <string, OperationError> > ExecuteAsync(CancellationToken token = default)
{
var completedUpdates = 0;
try
{
foreach (var pendingReadModelUpdate in _pendingReadModelUpdateRepository.GetMany(PendingReadModelUpdateSourceCategory.DataProcessingRegistration, BatchSize).ToList())
{
if (token.IsCancellationRequested)
{
break;
}
using var transaction = _transactionManager.Begin(IsolationLevel.ReadCommitted);
_logger.Debug("Rebuilding read model for {category}:{sourceId}", pendingReadModelUpdate.Category, pendingReadModelUpdate.SourceId);
var source = _sourceRepository.GetById(pendingReadModelUpdate.SourceId);
var readModelResult = _readModelRepository.GetBySourceId(pendingReadModelUpdate.SourceId);
if (source.HasValue)
{
var sourceValue = source.Value;
ApplyUpdate(readModelResult, sourceValue);
}
else
{
_logger.Information("Source object {category}:{sourceId} has been deleted since the update was scheduled. The update is ignored and readmodel is deleted if present.", pendingReadModelUpdate.Category, pendingReadModelUpdate.SourceId);
if (readModelResult.HasValue)
{
_logger.Information("Deleting orphaned read model with id {id}.", readModelResult.Value.Id);
_readModelRepository.Delete(readModelResult.Value);
}
}
completedUpdates++;
_pendingReadModelUpdateRepository.Delete(pendingReadModelUpdate);
transaction.Commit();
_logger.Debug("Finished rebuilding read model for {category}:{sourceId}", pendingReadModelUpdate.Category, pendingReadModelUpdate.SourceId);
}
}
catch (Exception e)
{
_logger.Error(e, $"Error while performing rebuilds of {Id}");
return(Task.FromResult(Result <string, OperationError> .Failure(new OperationError("Error during rebuild", OperationFailure.UnknownError))));
}
return(Task.FromResult(Result <string, OperationError> .Success($"Completed {completedUpdates} updates")));
}
private bool RelatedEntityExists(int relatedEntityId, RelatedEntityType relatedEntityType)
{
switch (relatedEntityType)
{
case RelatedEntityType.itContract:
var contractExists = _contractRepository.GetById(relatedEntityId);
return(contractExists != null);
case RelatedEntityType.itProject:
var projectExists = _projectRepository.GetById(relatedEntityId);
return(projectExists != null);
case RelatedEntityType.itSystemUsage:
var systemUsageExists = _systemUsageRepository.GetSystemUsage(relatedEntityId);
return(systemUsageExists != null);
case RelatedEntityType.dataProcessingRegistration:
var dataProcessingRegistrationExists = _dataProcessingRepository.GetById(relatedEntityId);
return(dataProcessingRegistrationExists.HasValue);
default:
return(false);
}
}
protected override IControllerCrudAuthorization GetCrudAuthorization()
{
// ChildEntityCrudAuthorization uses FromNullable when accessing the object. So even if .Value returns null it will be resolved.
return(new ChildEntityCrudAuthorization <DataProcessingRegistrationRight, DataProcessingRegistration>(r => _dataProcessingRegistrationRepository.GetById(r.ObjectId).Value, base.GetCrudAuthorization()));
}
