private int HandleSystemUpdates(CancellationToken token, int updatesExecuted, HashSet <int> alreadyScheduledIds)
{
foreach (var update in _updateRepository.GetMany(PendingReadModelUpdateSourceCategory.ItSystemUsage_ItSystem, BatchSize).ToList())
{
if (token.IsCancellationRequested)
{
break;
}
using var transaction = _transactionManager.Begin(IsolationLevel.ReadCommitted);
var systemIds = _itSystemUsageRepository.GetBySystemId(update.SourceId).Select(x => x.Id).ToList();
var parentSystemIds = _itSystemUsageRepository.GetByParentSystemId(update.SourceId).Select(x => x.Id).ToList();
var usedInRelationsIds = _itSystemUsageRepository.GetBySystemIdInSystemRelations(update.SourceId).Select(x => x.Id).ToList();
var ids = systemIds
.Concat(parentSystemIds)
.Concat(usedInRelationsIds)
.Distinct()
.ToList();
updatesExecuted = PerformUpdate(updatesExecuted, alreadyScheduledIds, ids, update, transaction);
}
return(updatesExecuted);
}
public async Task <ObjectResponse <GetCartViewModel> > Create(AddCartModel model)
{
_addCartCommand.Model = model;
using (_transactionManager.Begin())
{
var result = await _addCartCommand.Execute();
_transactionManager.Commit();
if (_addCartCommand.Validations?.Any() == true)
{
return(new ObjectResponse <GetCartViewModel>
{
Validations = _addCartCommand.Validations,
Success = false
});
}
return(new ObjectResponse <GetCartViewModel>
{
Data = result,
Success = true
});
}
}
public Result <ItSystemUsage, OperationFailure> Delete(int id)
{
using (var transaction = _transactionManager.Begin(IsolationLevel.ReadCommitted))
{
var itSystemUsage = GetById(id);
if (itSystemUsage == null)
{
return(OperationFailure.NotFound);
}
if (!_authorizationContext.AllowDelete(itSystemUsage))
{
return(OperationFailure.Forbidden);
}
// delete it system usage
var deleteBySystemUsageId = _referenceService.DeleteBySystemUsageId(id);
if (deleteBySystemUsageId.Failed)
{
transaction.Rollback();
return(deleteBySystemUsageId.Error);
}
_domainEvents.Raise(new EntityDeletedEvent <ItSystemUsage>(itSystemUsage));
_usageRepository.DeleteByKeyWithReferencePreload(id);
_usageRepository.Save();
transaction.Commit();
return(itSystemUsage);
}
}
public Result <DataProcessingRegistration, OperationError> Create(int organizationId, string name)
{
if (!_authorizationContext.AllowCreate <DataProcessingRegistration>(organizationId))
{
return(new OperationError(OperationFailure.Forbidden));
}
using var transaction = _transactionManager.Begin(IsolationLevel.Serializable);
var error = _namingService.ValidateSuggestedNewRegistrationName(organizationId, name);
if (error.HasValue)
{
return(error.Value);
}
var registration = new DataProcessingRegistration
{
OrganizationId = organizationId,
Name = name
};
var dataProcessingRegistration = _repository.Add(registration);
transaction.Commit();
return(dataProcessingRegistration);
}
public void Handle(EntityDeletedEvent <ExternalReference> domainEvent)
{
using var transaction = _transactionManager.Begin(IsolationLevel.ReadCommitted);
foreach (var report in domainEvent.Entity.BrokenLinkReports.ToList())
{
_externalReferenceBrokenLinks.Delete(report);
}
transaction.Commit();
}
public Result <UserNotification, OperationError> AddUserNotification(int organizationId, int userToNotifyId, string name, string message, int relatedEntityId, RelatedEntityType relatedEntityType, NotificationType notificationType)
{
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
if (name == null)
{
throw new ArgumentNullException(nameof(name));
}
using var transaction = _transactionManager.Begin(IsolationLevel.ReadCommitted);
if (!RelatedEntityExists(relatedEntityId, relatedEntityType))
{
transaction.Rollback();
return(new OperationError(OperationFailure.NotFound));
}
var notification = new UserNotification(name, message, notificationType, organizationId, userToNotifyId, _operationClock.Now);
switch (relatedEntityType)
{
case RelatedEntityType.itContract:
notification.Itcontract_Id = relatedEntityId;
break;
case RelatedEntityType.itProject:
notification.ItProject_Id = relatedEntityId;
break;
case RelatedEntityType.itSystemUsage:
notification.ItSystemUsage_Id = relatedEntityId;
break;
case RelatedEntityType.dataProcessingRegistration:
notification.DataProcessingRegistration_Id = relatedEntityId;
break;
default:
return(new OperationError(OperationFailure.BadInput));
}
var userNotification = _userNotificationRepository.Add(notification);
transaction.Commit();
return(userNotification);
}
private async Task RootMethodProceed(CompensableMethodContext compensableMethodContext)
{
var allDelayCancelExceptionTypes = new HashSet <Type>();
allDelayCancelExceptionTypes.AddRange(this._delayCancelExceptionTypes);
allDelayCancelExceptionTypes.AddRange(compensableMethodContext.Compensable.DelayCancelExceptionTypes);
using (var transaction = _transactionManager.Begin(compensableMethodContext.GetUniqueIdentity()))
{
try
{
await compensableMethodContext.MethodInvocation.ProceedAsync();
}
catch (Exception ex)
{
if (!_transactionManager.IsDelayCancelException(ex, allDelayCancelExceptionTypes))
{
_logger.LogError(string.Format("compensable transaction trying failed. transaction content:{0} ", JsonConvert.SerializeObject(transaction)));
await _transactionManager.RollbackAsync();
}
throw ex;
}
await _transactionManager.CommitAsync();
}
}
private Result <IEnumerable <ExternalReference>, OperationFailure> DeleteExternalReferences(IEntityWithExternalReferences root)
{
if (root == null)
{
return(OperationFailure.NotFound);
}
if (!_authorizationContext.AllowModify(root))
{
return(OperationFailure.Forbidden);
}
using var transaction = _transactionManager.Begin(IsolationLevel.Serializable);
var systemExternalReferences = root.ExternalReferences.ToList();
if (systemExternalReferences.Count == 0)
{
return(systemExternalReferences);
}
foreach (var reference in systemExternalReferences)
{
_domainEvents.Raise(new EntityDeletedEvent <ExternalReference>(reference));
_referenceRepository.Delete(reference);
}
transaction.Commit();
return(systemExternalReferences);
}
public Result <ItProject, OperationFailure> DeleteProject(int id)
{
using (var transaction = _transactionManager.Begin(IsolationLevel.ReadCommitted))
{
var project = _projectRepository.GetByKey(id);
if (project == null)
{
return(OperationFailure.NotFound);
}
if (!_authorizationContext.AllowDelete(project))
{
return(OperationFailure.Forbidden);
}
var deleteByProjectId = _referenceService.DeleteByProjectId(id);
if (deleteByProjectId.Failed)
{
transaction.Rollback();
return(deleteByProjectId.Error);
}
project.Handover?.Participants?.Clear();
_domainEvents.Raise(new EntityDeletedEvent <ItProject>(project));
_projectRepository.DeleteWithReferencePreload(project);
_projectRepository.Save();
transaction.Commit();
return(project);
}
}
/// <summary>
///
/// </summary>
/// <param name="action"></param>
/// <returns>如果延迟执行，返回true</returns>
private void ProcessAction(ScheduledAction action)
{
if (this._transactionStatus == TransactionStatus.Delay)
{
_actions.Add(action);//若处于延迟模式的事务中，那么将该操作暂存
return;
}
if (this._transactionStatus == TransactionStatus.Timely)
{
//若已经开启全局事务，直接执行
_actions.Add(action); //直接执行也要加入到actions集合中
ExecuteAction(action);
return;
}
if (this._transactionStatus == TransactionStatus.None)
{
//没有开启事务，立即执行
using (ITransactionManager manager = GetTransactionManager())
{
manager.Begin();
ExecuteAction(action);
//提交事务
RaisePreCommit(action);
manager.Commit();
RaiseCommitted(action);
}
return;
}
}
public DateTime UpdateKLE(int ownedByOrgnizationUnitId)
{
_logger.Debug("UpdateKLE: Begin");
var kleXmlData = _kleDataBridge.GetAllActiveKleNumbers();
var changes = GetKLEChangeSummary(kleXmlData);
_logger.Debug($"Changes: {changes.Count}");
using (var transaction = _transactionManager.Begin(IsolationLevel.Serializable))
{
// Changes first run
UpdateRemovedTaskRefs(changes);
UpdateRenamedTaskRefs(changes, ownedByOrgnizationUnitId);
UpdateAddedTaskRefs(changes, ownedByOrgnizationUnitId);
PatchTaskRefUuid(changes, ownedByOrgnizationUnitId);
_existingTaskRefRepository.Save();
// Changes second run, takes into account removed/added items
PatchTaskRefParentId(changes, ownedByOrgnizationUnitId);
_existingTaskRefRepository.Save();
transaction.Commit();
}
_logger.Debug("UpdateKLE: End");
return(GetPublishedDate(kleXmlData));
}
public Result <ItContract, OperationFailure> Delete(int id)
{
var contract = _repository.GetById(id);
if (contract == null)
{
return(OperationFailure.NotFound);
}
if (!_authorizationContext.AllowDelete(contract))
{
return(OperationFailure.Forbidden);
}
using (var transaction = _transactionManager.Begin(IsolationLevel.ReadCommitted))
{
try
{
//Delete the economy streams to prevent them from being orphaned
foreach (var economyStream in GetEconomyStreams(contract))
{
DeleteEconomyStream(economyStream);
}
_economyStreamRepository.Save();
//Delete the contract
var deleteByContractId = _referenceService.DeleteByContractId(id);
if (deleteByContractId.Failed)
{
transaction.Rollback();
return(deleteByContractId.Error);
}
_domainEvents.Raise(new ContractDeleted(contract));
_repository.DeleteContract(contract);
transaction.Commit();
}
catch (Exception e)
{
_logger.Error(e, $"Failed to delete it contract with id: {contract.Id}");
transaction.Rollback();
return(OperationFailure.UnknownError);
}
}
return(contract);
}
/// <summary>
/// Begins the transaction.
/// </summary>
/// <param name="transactionId">The transaction id.</param>
/// <exception cref="System.ArgumentNullException">transactionId</exception>
public void BeginTransaction(string transactionId)
{
if (transactionId == null)
{
throw new ArgumentNullException("transactionId");
}
_transactionManager.Begin(transactionId);
}
public void Commit()
{
if (!this.IsInTransaction)
{
throw new NotBeginTransactionException(Strings.NotOpenTransaction);
}
else
{
_transactionCount--;
if (_transactionCount == 0)
{
if (IsCommiting)
{
throw new RepeatedCommitException(Strings.TransactionRepeatedCommit);
}
IsCommiting = true;
try
{
if (_transactionStatus == TransactionStatus.Delay)
{
_transactionStatus = TransactionStatus.Timely; //开启即时事务
using (ITransactionManager manager = GetTransactionManager())
{
manager.Begin();
ExecuteActionQueue();
RaisePreCommitQueue();
manager.Commit();
RaiseCommittedQueue();
}
}
else if (_transactionStatus == TransactionStatus.Timely)
{
ExecuteActionQueue();
RaisePreCommitQueue();
_timelyManager.Commit();
RaiseCommittedQueue();
}
}
catch (Exception ex)
{
throw;
}
finally
{
Clear();
IsCommiting = false;
}
}
}
}
public void Handle(ExposingSystemChanged domainEvent)
{
if (domainEvent == null)
{
throw new ArgumentNullException(nameof(domainEvent));
}
using (var transaction = _transactionManager.Begin(IsolationLevel.ReadCommitted))
{
var affectedInterface = domainEvent.AffectedInterface;
_logger.Debug(
"Exposing system for interface with id {interfaceId} changed from {fromSystemId} to {toSystemId}. Resetting 'interface' field on all associated system relations",
affectedInterface.Id,
domainEvent.PreviousSystem.Match(x => x.Id.ToString(), () => "_none_"),
domainEvent.NewSystem.Match(x => x.Id.ToString(), () => "_none_"));
ResetInterfaceOnRelations(affectedInterface, transaction);
}
}
public KLEUpdateHistoryItem Insert(DateTime version)
{
KLEUpdateHistoryItem result;
using (var transaction = _transactionManager.Begin(IsolationLevel.Serializable))
{
result = _updateHistoryItems.Insert(new KLEUpdateHistoryItem(version));
_updateHistoryItems.Save();
transaction.Commit();
}
return(result);
}
public SystemDeleteResult Delete(int id)
{
var system = _itSystemRepository.GetSystem(id);
if (system == null)
{
return(SystemDeleteResult.NotFound);
}
if (_authorizationContext.AllowDelete(system) == false)
{
return(SystemDeleteResult.Forbidden);
}
if (system.Usages.Any())
{
return(SystemDeleteResult.InUse);
}
if (system.Children.Any())
{
return(SystemDeleteResult.HasChildren);
}
if (system.ItInterfaceExhibits.Any())
{
return(SystemDeleteResult.HasInterfaceExhibits);
}
using (var transaction = _transactionManager.Begin(IsolationLevel.Serializable))
{
try
{
var deleteReferenceResult = _referenceService.DeleteBySystemId(system.Id);
if (deleteReferenceResult.Ok == false)
{
_logger.Error($"Failed to delete external references of it system with id: {system.Id}. Service returned a {deleteReferenceResult.Error}");
transaction.Rollback();
return(SystemDeleteResult.UnknownError);
}
_itSystemRepository.DeleteSystem(system);
transaction.Commit();
return(SystemDeleteResult.Ok);
}
catch (Exception e)
{
_logger.Error(e, $"Failed to delete it system with id: {system.Id}");
transaction.Rollback();
return(SystemDeleteResult.UnknownError);
}
}
}
public void RollBackShouldCloseWorkSpaceTest()
{
ITransactionManager tm = bf.CurrentConversation.TransactionManager;
tm.Begin();
MockEntity mo3 = new MockEntity();
mo3.Save();
tm.Rollback();
Assert.IsNull(bf.CurrentConversation);
bf.InitWorkSpace();
Assert.IsNull(MockEntityDAO.Instance.Get(mo3.Id), "Rolled back transaction did get commit");
}
public Result <ItInterface, OperationFailure> Delete(int id)
{
using (var transaction = _transactionManager.Begin(IsolationLevel.Serializable))
{
var itInterface = _repository.GetByKey(id);
if (itInterface == null)
{
return(OperationFailure.NotFound);
}
if (!_authorizationContext.AllowDelete(itInterface))
{
return(OperationFailure.Forbidden);
}
if (itInterface.ExhibitedBy != null)
{
return(OperationFailure.Conflict);
}
var dataRows = itInterface.DataRows.ToList();
foreach (var dataRow in dataRows)
{
_dataRowRepository.DeleteByKey(dataRow.Id);
}
_dataRowRepository.Save();
// delete it interface
_domainEvents.Raise(new EntityDeletedEvent <ItInterface>(itInterface));
_repository.DeleteWithReferencePreload(itInterface);
_repository.Save();
transaction.Commit();
return(itInterface);
}
}
public void MultipleTransactionTest()
{
ITransactionManager tm = bf.CurrentConversation.TransactionManager;
tm.Begin();
MockEntity mo1 = new MockEntity();
mo1.Save();
tm.Commit();
tm.Begin();
MockEntity mo2 = new MockEntity();
mo2.Save();
tm.Commit();
tm.Begin();
Assert.IsNotNull(MockEntityDAO.Instance.Get(mo1.Id));
Assert.IsNotNull(MockEntityDAO.Instance.Get(mo2.Id));
tm.Commit();
TearDown();
}
public void Handle(EntityDeletedEvent <ItSystemUsage> domainEvent)
{
if (domainEvent == null)
{
throw new ArgumentNullException(nameof(domainEvent));
}
if (domainEvent.ChangeType != LifeCycleEventType.Deleted)
{
return;
}
using var transaction = _transactionManager.Begin(IsolationLevel.ReadCommitted);
var deletedSystemUsage = domainEvent.Entity;
_logger.Debug("System usage with id {id} deleted. All relations TO from other usages will be removed",
deletedSystemUsage.Id);
//Delete all relations which point TO the deleted system usage
var usedByRelationsByFromUsage =
deletedSystemUsage
.UsedByRelations
.GroupBy(relation => relation.FromSystemUsageId)
.ToList();
foreach (var systemRelationsByFromUsage in usedByRelationsByFromUsage)
{
var fromSystemUsage = systemRelationsByFromUsage.First().FromSystemUsage;
foreach (var relationToBeRemoved in systemRelationsByFromUsage)
{
var relationId = relationToBeRemoved.Id;
var result = fromSystemUsage.RemoveUsageRelation(relationId);
if (result.Failed)
{
throw new InvalidOperationException(
$"Failed to remove relation with id {relationId} from system usage with id {fromSystemUsage.Id}. Reported error:{result.Error:G}");
}
_systemRelationRepository.Delete(relationToBeRemoved);
}
}
_systemUsageRepository.Save();
_systemRelationRepository.Save();
transaction.Commit();
}
public Task <Result <string, OperationError> > ExecuteAsync(CancellationToken token = default)
{
var deleted = 0;
foreach (var category in Enum.GetValues(typeof(PendingReadModelUpdateSourceCategory)).Cast <PendingReadModelUpdateSourceCategory>().ToList())
{
if (token.IsCancellationRequested)
{
break;
}
using var transaction = _transactionManager.Begin(IsolationLevel.ReadCommitted);
var idsInQueue = new HashSet <int>();
var updates = _pendingReadModelUpdateRepository
.GetMany(category, int.MaxValue)
.OrderBy(x => x.CreatedAt) //The oldest will be served first
.Select(x => new
{
Id = x.Id,
SourceId = x.SourceId
})
.ToList();
var idsToDelete =
(
//Select ids of all duplicates and nuke them
from update in updates
where !idsInQueue.Add(update.SourceId)
select update.Id
)
.ToList();
if (idsToDelete.Any())
{
//Using optimized collection deletion. DeleteByKey first fetches the object from db and then marks as deleted. That is very slow since it will cause a lot of round-trips to the database in stead of one for select and one for delete
var objectsToDelete = _primitiveRepository.AsQueryable().ByIds(idsToDelete).ToList();
_primitiveRepository.RemoveRange(objectsToDelete);
_primitiveRepository.Save();
transaction.Commit();
deleted += idsToDelete.Count;
}
}
return(Task.FromResult(Result <string, OperationError> .Success($"Deleted {deleted} duplicated")));
}
public Task <Result <string, OperationError> > ExecuteAsync(CancellationToken token = default)
{
var completedUpdates = 0;
try
{
var pendingReadModelUpdates = _pendingReadModelUpdateRepository.GetMany(PendingReadModelUpdateSourceCategory.ItSystemUsage, BatchSize).ToList();
foreach (var pendingReadModelUpdate in pendingReadModelUpdates)
{
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.GetSystemUsage(pendingReadModelUpdate.SourceId).FromNullable();
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);
_lowLevelReadModelRepository.Delete(readModelResult.Value);
}
}
completedUpdates++;
_lowLevelPendingReadModelRepository.Delete(pendingReadModelUpdate);
_databaseControl.SaveChanges();
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 int HandleOversightOptionUpdates(CancellationToken token, int updatesExecuted, HashSet <int> alreadyScheduledIds)
{
foreach (var update in _updateRepository.GetMany(PendingReadModelUpdateSourceCategory.DataProcessingRegistration_OversightOption, BatchSize).ToList())
{
if (token.IsCancellationRequested)
{
break;
}
using var transaction = _transactionManager.Begin(IsolationLevel.ReadCommitted);
var ids = _dataProcessingRegistrationRepository.GetByOversightOptionId(update.SourceId).Select(x => x.Id);
updatesExecuted = PerformUpdate(updatesExecuted, alreadyScheduledIds, ids, update, transaction);
}
return(updatesExecuted);
}
public void Handle(ContractDeleted domainEvent)
{
if (domainEvent == null)
{
throw new ArgumentNullException(nameof(domainEvent));
}
using (var transaction = _transactionManager.Begin(IsolationLevel.ReadCommitted))
{
var deletedContract = domainEvent.DeletedContract;
_logger.Debug(
"Contract with id {contractId} deleted. Resetting 'contract' field on all associated system relations",
deletedContract.Id);
var systemRelations = deletedContract.AssociatedSystemRelations.ToList();
if (systemRelations.Any())
{
foreach (var systemRelation in systemRelations)
{
var fromSystemUsage = systemRelation.FromSystemUsage;
var result = fromSystemUsage.ModifyUsageRelation(
relationId: systemRelation.Id,
toSystemUsage: systemRelation.ToSystemUsage,
changedDescription: systemRelation.Description,
changedReference: systemRelation.Reference,
relationInterface: systemRelation.RelationInterface,
toContract: Maybe <ItContract> .None, //Reset the contract
toFrequency: systemRelation.UsageFrequency);
if (result.Failed)
{
throw new InvalidOperationException($"Failed to modify system relation. Error: {result.Error}");
}
}
_systemUsageRepository.Save();
transaction.Commit();
}
}
}
/// <summary>
/// 开启即时事务,并且锁定事务
/// </summary>
public void OpenTimelyMode()
{
if (_transactionStatus != TransactionStatus.Timely)
{
if (!this.IsInTransaction)
{
throw new NotBeginTransactionException(Strings.NotOpenTransaction);
}
//开启即时事务
this._transactionStatus = TransactionStatus.Timely;
_timelyManager = GetTransactionManager();
_timelyManager.Begin();
if (!IsCommiting)
{
//没有之前的队列要执行
ExecuteActionQueue();//在提交时更改了事务模式,只有可能是在验证行为时发生，该队列会在稍后立即执行，因此此处不执行队列
}
}
}
public void ReplaceCurrentReport(BrokenExternalReferencesReport report)
{
if (report == null)
{
throw new ArgumentNullException(nameof(report));
}
using (var transaction = _transactionManager.Begin(IsolationLevel.Serializable))
{
var existing = _repository.AsQueryable().FirstOrDefault();
if (existing != null)
{
if (existing.Id == report.Id)
{
throw new ArgumentException("Incoming report is the same as the existing report");
}
_repository.DeleteWithReferencePreload(existing);
}
_repository.Insert(report);
_repository.Save();
transaction.Commit();
}
}
public Result <ItSystemUsage, OperationFailure> ExecuteSystemUsageMigration(int usageSystemId, int toSystemId)
{
if (!CanExecuteMigration())
{
return(OperationFailure.Forbidden);
}
using (var transaction = _transactionManager.Begin(IsolationLevel.Serializable))
{
try
{
// **********************************
// *** Check migration conditions ***
// **********************************
// If migration description cannot be retrieved, bail out
var migrationConsequences = GetSystemUsageMigration(usageSystemId, toSystemId);
if (migrationConsequences.Ok == false)
{
return(migrationConsequences.Error);
}
var migration = migrationConsequences.Value;
var systemUsage = migration.SystemUsage;
var oldSystem = migration.FromItSystem;
var newSystem = migration.ToItSystem;
//If modification of the target usage is not allowed, bail out
if (!_authorizationContext.AllowModify(systemUsage))
{
return(OperationFailure.Forbidden);
}
// If target equals current system, bail out
if (systemUsage.ItSystemId == migration.ToItSystem.Id)
{
return(systemUsage);
}
// *************************
// *** Perform migration ***
// *************************
// Delete UsedByRelation interfaces
var relationsMigrated = PerformRelationMigrations(migration);
if (relationsMigrated == false)
{
transaction.Rollback();
return(OperationFailure.UnknownError);
}
//***********************************************
//Perform final switchover of "source IT-System"
//***********************************************
// Delete access types (they are bound to the system)
DeleteAccessTypes(systemUsage);
// Switch the ID
systemUsage.ItSystemId = toSystemId;
_systemUsageRepository.Update(systemUsage);
//Raise events for all affected roots
_domainEvents.Raise(new EntityUpdatedEvent <ItSystemUsage>(systemUsage));
_domainEvents.Raise(new EntityUpdatedEvent <ItSystem>(oldSystem));
_domainEvents.Raise(new EntityUpdatedEvent <ItSystem>(newSystem));
transaction.Commit();
return(systemUsage);
}
catch (Exception e)
{
_logger.Error(e, $"Migrating usageSystem with id: {usageSystemId}, to system with id: {toSystemId} failed");
transaction.Rollback();
return(OperationFailure.UnknownError);
}
}
}
public Result <Organization, OperationFailure> CreateNewOrganization(Organization newOrg)
{
if (newOrg == null)
{
throw new ArgumentNullException(nameof(newOrg));
}
var user = _userRepository.GetByKey(_userContext.UserId);
if (user == null)
{
return(OperationFailure.Forbidden);
}
//Setup defaults
newOrg.Uuid = newOrg.Uuid == Guid.Empty ? Guid.NewGuid() : newOrg.Uuid;
newOrg.Config = Config.Default(user);
newOrg.OrgUnits.Add(new OrganizationUnit
{
Name = newOrg.Name,
});
if (newOrg.IsCvrInvalid())
{
_logger.Error("Invalid cvr {cvr} provided for org with name {name}", newOrg.Cvr, newOrg.Name);
return(OperationFailure.BadInput);
}
if (!_userContext.OrganizationIds.Any(id => _authorizationContext.AllowCreate <Organization>(id)))
{
return(OperationFailure.Forbidden);
}
if (newOrg.TypeId > 0)
{
var organizationType = (OrganizationTypeKeys)newOrg.TypeId;
var allowOrganizationTypeCreation = _userContext.OrganizationIds.Any(id => _authorizationContext.HasPermission(new DefineOrganizationTypePermission(organizationType, id)));
if (!allowOrganizationTypeCreation)
{
return(OperationFailure.Forbidden);
}
}
else
{
//Invalid org key
return(OperationFailure.BadInput);
}
using (var transaction = _transactionManager.Begin(IsolationLevel.Serializable))
{
newOrg = _orgRepository.Insert(newOrg);
_orgRepository.Save();
if (newOrg.TypeId == (int)OrganizationTypeKeys.Interessefællesskab)
{
_organizationRoleService.MakeLocalAdmin(user, newOrg);
_organizationRoleService.MakeUser(user, newOrg);
}
transaction.Commit();
return(newOrg);
}
}
