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