public async Task <KudosBasketCreateDto> CreateNewBasketAsync(KudosBasketCreateDto newBasket) { var existsBasket = await _kudosBasketsDbSet.AnyAsync(); _kudosBasketValidator.CheckIfBasketAlreadyExists(existsBasket); var kudosBasket = new KudosBasket { IsActive = true, Created = DateTime.UtcNow, CreatedBy = newBasket.UserId, Modified = DateTime.UtcNow, Title = newBasket.Title, Description = newBasket.Description, OrganizationId = newBasket.OrganizationId, KudosLogs = new List <KudosLog>() }; _kudosBasketsDbSet.Add(kudosBasket); await _uow.SaveChangesAsync(false); newBasket.Id = kudosBasket.Id; newBasket.IsActive = kudosBasket.IsActive; return(newBasket); }
public async Task DeleteAsync(Guid id, UserAndOrganizationDto userOrg) { var @event = await _eventsDbSet .Include(e => e.EventOptions) .Include(e => e.EventParticipants) .SingleOrDefaultAsync(e => e.Id == id && e.OrganizationId == userOrg.OrganizationId); _eventValidationService.CheckIfEventExists(@event); var isAdmin = await _permissionService.UserHasPermissionAsync(userOrg, AdministrationPermissions.Event); // ReSharper disable once PossibleNullReferenceException _eventValidationService.CheckIfUserHasPermission(userOrg.UserId, @event.ResponsibleUserId, isAdmin); _eventValidationService.CheckIfEventEndDateIsExpired(@event.EndDate); var timestamp = DateTime.UtcNow; @event.Modified = timestamp; @event.ModifiedBy = userOrg.UserId; await _eventParticipationService.DeleteByEventAsync(id, userOrg.UserId); await _eventUtilitiesService.DeleteByEventAsync(id, userOrg.UserId); _eventsDbSet.Remove(@event); await _uow.SaveChangesAsync(false); await _wallService.DeleteWallAsync(@event.WallId, userOrg, WallType.Events); }
public async Task <LotteryDto> CreateLotteryAsync(LotteryDto newLotteryDto) { if (newLotteryDto.EndDate < DateTime.UtcNow) { throw new LotteryException("Lottery can't start in the past."); } if (newLotteryDto.EntryFee < 1) { throw new LotteryException("Invalid entry fee."); } if (newLotteryDto.Status != (int)LotteryStatus.Started && newLotteryDto.Status != (int)LotteryStatus.Drafted) { throw new LotteryException("Invalid status of created lottery."); } var newLottery = MapNewLottery(newLotteryDto); _lotteriesDbSet.Add(newLottery); await _uow.SaveChangesAsync(newLotteryDto.UserId); newLotteryDto.Id = newLottery.Id; return(newLotteryDto); }
public async Task PostBookAsync(BookMobilePostDto bookDto) { await _newBookLock.WaitAsync(); try { var book = await _bookDbSet .Include(b => b.BookOffices) .FirstOrDefaultAsync(b => b.Code == bookDto.Code && b.OrganizationId == bookDto.OrganizationId); if (book == null) { AddNewBook(bookDto); } else { await ValidatePostBookAsync(bookDto, book); AddBookToOtherOffice(bookDto, book); } await _uow.SaveChangesAsync(false); } finally { _newBookLock.Release(); } }
public async Task <NotificationDto> CreateForPost(UserAndOrganizationDTO userOrg, NewlyCreatedPostDTO post, int wallId, IEnumerable <string> membersToNotify) { var postType = NotificationType.WallPost; var sources = new Sources { PostId = post.Id }; switch (post.WallType) { case WallType.Events: postType = NotificationType.EventPost; sources.EventId = _eventDbSet.FirstOrDefault(x => x.WallId == wallId).Id.ToString(); break; case WallType.Project: postType = NotificationType.ProjectPost; sources.ProjectId = _projectDbSet.FirstOrDefault(x => x.WallId == wallId).Id.ToString(); break; } var wallName = await _wallDbSet .Where(x => x.Id == wallId && x.OrganizationId == userOrg.OrganizationId) .Select(s => s.Name) .SingleAsync(); var newNotification = Notification.Create(post.User.FullName, wallName, post.User.PictureId, sources, postType, userOrg.OrganizationId, membersToNotify); _notificationDbSet.Add(newNotification); await _uow.SaveChangesAsync(); return(_mapper.Map <NotificationDto>(newNotification)); }
public async Task CreateItemAsync(KudosShopItemDto dto) { var alreadyExists = await _kudosShopItemsDbSet .AnyAsync(t => t.Name == dto.Name && t.OrganizationId == dto.OrganizationId); if (alreadyExists) { throw new ValidationException(PremiumErrorCodes.KudosShopItemAlreadyExist, "Kudos shop item already exists"); } var modified = DateTime.UtcNow; var newItem = new KudosShopItem { Name = dto.Name, Price = dto.Price, Description = dto.Description, CreatedBy = dto.UserId, Created = modified, Modified = modified, ModifiedBy = dto.UserId, OrganizationId = dto.OrganizationId, PictureId = dto.PictureId }; _kudosShopItemsDbSet.Add(newItem); await _uow.SaveChangesAsync(dto.UserId); }
public async Task ChangeUserLocalizationSettings(ChangeUserLocalizationSettingsDto settingsDto) { var user = await _usersDbSet .FirstAsync(u => u.Id == settingsDto.UserId && u.OrganizationId == settingsDto.OrganizationId); var culture = CultureInfo .GetCultures(CultureTypes.SpecificCultures) .FirstOrDefault(c => c.Name == settingsDto.LanguageCode); if (culture == null) { throw new ValidationException(ErrorCodes.CultureUnsupported, "Unsupported culture"); } var isLanguageSupported = ConstBusinessLayer.SupportedLanguages.Any(x => x.LCID == culture.LCID); if (!isLanguageSupported) { throw new ValidationException(ErrorCodes.CultureUnsupported, "Unsupported culture"); } var isTimezoneValid = TimeZoneInfo.GetSystemTimeZones().Any(tz => tz.Id == settingsDto.TimeZoneId); if (!isTimezoneValid) { throw new ValidationException(ErrorCodes.TimezoneUnsupported, "Unsupported timezone"); } user.TimeZone = settingsDto.TimeZoneId; user.CultureCode = culture.Name; await _uow.SaveChangesAsync(settingsDto.UserId); }
public async Task AddProviderImageAsync(string userId, ClaimsIdentity externalIdentity) { var user = await _usersDbSet.FirstAsync(u => u.Id == userId); if (user.PictureId == null && externalIdentity.FindFirst("picture") != null) { byte[] data = data = await new WebClient().DownloadDataTaskAsync(externalIdentity.FindFirst("picture").Value); user.PictureId = await _pictureService.UploadFromStreamAsync(new MemoryStream(data), "image/jpeg", Guid.NewGuid() + ".jpg", user.OrganizationId); await _uow.SaveChangesAsync(userId); } }
public async Task NewProject(NewProjectDto dto) { var owningUserExists = await _usersDbSet .AnyAsync(u => u.Id == dto.OwningUserId && u.OrganizationId == dto.OrganizationId); if (!owningUserExists) { throw new ValidationException(ErrorCodes.ContentDoesNotExist, "Incorrect user"); } var members = await _usersDbSet .Where(u => dto.MembersIds.Contains(u.Id)) .ToListAsync(); var completeListOfAttributes = await ManageProjectAttributes(dto.Attributes); var project = new Project { Name = dto.Title, Desc = dto.Description, OwnerId = dto.OwningUserId, OrganizationId = dto.OrganizationId, Logo = dto.Logo, Attributes = completeListOfAttributes.ToList(), Members = members }; var wall = new CreateWallDto { Name = dto.Title, UserId = dto.OwningUserId, OrganizationId = dto.OrganizationId, Type = WallType.Project, Description = dto.Description, Logo = dto.Logo, Access = WallAccess.Public, MembersIds = members.Select(m => m.Id).Concat(new List <string> { dto.OwningUserId }), ModeratorsIds = new List <string> { dto.OwningUserId } }; _projectsDbSet.Add(project); await _wallService.CreateNewWall(wall); await _uow.SaveChangesAsync(dto.UserId); }
private async Task UpdateUserProfilesAsync(Lottery lottery, IEnumerable <AddKudosLogDto> kudosLogs, UserAndOrganizationDto userOrg) { if (lottery.Status != (int)LotteryStatus.RefundLogsCreated) { return; } var userIds = kudosLogs.Select(x => x.ReceivingUserIds.First()); await _kudosService.UpdateProfilesFromUserIdsAsync(userIds, userOrg); lottery.Status = (int)LotteryStatus.Refunded; await _uow.SaveChangesAsync(userOrg.UserId); }
public async Task AnonymizeUsersAsync(string organizationName) { var organization = await _organizationsDbSet.FirstAsync(org => org.ShortName == organizationName); var sqlQuery = @"SELECT TOP(@userLimit) * FROM [dbo].[AspNetUsers] WHERE IsDeleted = 1 AND OrganizationId = @organizationId AND IsAnonymized = 0 AND DATEDIFF(DAY, Modified, GETDATE()) >= @anonymizeAfterDays"; var sqlParameters = new object[] { new SqlParameter("@organizationId", organization.Id), new SqlParameter("@anonymizeAfterDays", _anonymizeUsersAfterDays), new SqlParameter("@userLimit", _anonymizeUsersPerRequest) }; var usersToAnonymize = await _usersDbSet.SqlQuery(sqlQuery, sqlParameters).ToListAsync(); foreach (var user in usersToAnonymize) { await AnonymizeAsync(user, organization.Id); await _uow.SaveChangesAsync(); } }
public async Task <NotificationDto> CreateForEventAsync(UserAndOrganizationDto userOrg, CreateEventDto eventDto) { var mainWallId = await _wallDbSet.Where(w => w.Type == WallType.Main).Select(s => s.Id).SingleAsync(); var membersToNotify = await _wallService.GetWallMembersIdsAsync(mainWallId, userOrg); var sourceIds = new Sources { EventId = eventDto.Id }; var newNotification = Notification.Create(eventDto.Name, eventDto.Description, eventDto.ImageName, sourceIds, NotificationType.NewEvent, userOrg.OrganizationId, membersToNotify); _notificationDbSet.Add(newNotification); await _uow.SaveChangesAsync(); return(_mapper.Map <NotificationDto>(newNotification)); }
private async Task SaveChangesAsync() { var response = await _uow.SaveChangesAsync(); if (response == 0) { throw new ApplicationException("Changes could not be saved in BadgesService"); } }
public async Task DeleteByEventAsync(Guid eventId, string userId) { var options = await _eventOptionsDbSet .Where(o => o.EventId == eventId) .ToListAsync(); var timestamp = DateTime.UtcNow; foreach (var option in options) { option.Modified = timestamp; option.ModifiedBy = userId; } await _uow.SaveChangesAsync(false); options.ForEach(o => _eventOptionsDbSet.Remove(o)); await _uow.SaveChangesAsync(false); }
public async Task AddNewTokenAsync(RefreshTokenDto tokenDto) { var timestamp = DateTime.UtcNow; var newToken = new RefreshToken { Id = tokenDto.Id, ExpiresUtc = tokenDto.ExpiresUtc, IssuedUtc = tokenDto.IssuedUtc, Subject = tokenDto.Subject, ProtectedTicket = tokenDto.ProtectedTicket, Created = timestamp, Modified = timestamp, OrganizationId = tokenDto.OrganizationId, CreatedBy = tokenDto.Subject, ModifiedBy = tokenDto.Subject }; _refreshTokensDbSet.Add(newToken); await _uow.SaveChangesAsync(false); }
private async Task CreateNewLinksAsync(AddEditDeleteExternalLinkDto updateLinks, DateTime timestamp) { foreach (var link in updateLinks.LinksToCreate) { var newLink = new ExternalLink { Name = link.Name, Url = link.Url, OrganizationId = updateLinks.OrganizationId, Created = timestamp, CreatedBy = updateLinks.UserId, Modified = timestamp, Type = link.Type }; _externalLinkDbSet.Add(newLink); } await _uow.SaveChangesAsync(false); }
public async Task ResetAttendeesAsync(Guid eventId, UserAndOrganizationDto userOrg) { var @event = await _eventsDbSet .Include(e => e.EventParticipants) .Include(e => e.EventOptions) .Include(e => e.EventType) .Include(e => e.EventParticipants.Select(participant => participant.ApplicationUser)) .Include(e => e.EventParticipants.Select(participant => participant.ApplicationUser.Manager)) .SingleOrDefaultAsync(e => e.Id == eventId && e.OrganizationId == userOrg.OrganizationId); _eventValidationService.CheckIfEventExists(@event); var hasPermission = await _permissionService.UserHasPermissionAsync(userOrg, AdministrationPermissions.Event); // ReSharper disable once PossibleNullReferenceException _eventValidationService.CheckIfUserHasPermission(userOrg.UserId, @event.ResponsibleUserId, hasPermission); _eventValidationService.CheckIfEventEndDateIsExpired(@event.EndDate); var users = @event.EventParticipants.Select(p => p.ApplicationUserId).ToList(); var timestamp = DateTime.UtcNow; foreach (var participant in @event.EventParticipants) { participant.UpdateMetadata(userOrg.UserId, timestamp); } await _uow.SaveChangesAsync(false); if ([email protected]) { await RemoveParticipantsAsync(@event, userOrg); _asyncRunner.Run <IEventNotificationService>(async notifier => await notifier.NotifyRemovedEventParticipantsAsync(@event.Name, @event.Id, userOrg.OrganizationId, users), _uow.ConnectionName); return; } var userEventAttendStatusDto = MapEventToUserEventAttendStatusChangeEmailDto(@event).ToList(); await RemoveParticipantsAsync(@event, userOrg); _asyncRunner.Run <IEventNotificationService>(async notifier => await notifier.NotifyRemovedEventParticipantsAsync(@event.Name, @event.Id, userOrg.OrganizationId, users), _uow.ConnectionName); NotifyManagers(userEventAttendStatusDto); }
public async Task EditVacationPage(UserAndOrganizationDto userAndOrg, VacationPageDto vacationPageDto) { var vacationPage = await _vacationPagesDbSet.FirstOrDefaultAsync(page => page.OrganizationId == userAndOrg.OrganizationId); if (vacationPage == null) { _vacationPagesDbSet.Add(new VacationPage { Content = vacationPageDto.Content, OrganizationId = userAndOrg.OrganizationId, }); await _uow.SaveChangesAsync(); return; } vacationPage.Content = vacationPageDto.Content; await _uow.SaveChangesAsync(); }
public async Task Should_Assign_1_Badge_For_Recent_Kudos_Transaction() { // Arrange var twoDaysAgo = DateTime.UtcNow.AddDays(-2); var oneHourAgo = DateTime.UtcNow.AddHours(-1); var user = new ApplicationUser { Id = "user1", OrganizationId = 1, EmploymentDate = twoDaysAgo, BadgeLogs = new List <BadgeLog>() }; _badgeCategoriesDbSet.SetDbSetDataForAsync(GetBadgeCategories(twoDaysAgo)); _kudosLogsDbSet.SetDbSetDataForAsync(GetKudosLogs(user, oneHourAgo)); _badgeLogsDbSet.SetDbSetDataForAsync(new List <BadgeLog>()); _unitOfWork.SaveChangesAsync().Returns(Task.FromResult(1)); // Act await _badgesService.AssignBadgesAsync(); // Assert AssertBadgeReceived(user.Id, 1, 1); }
public async Task CreateJobType(JobTypeDTO jobTypeDTO) { var alreadyExists = await _jobTypesDbSet .AnyAsync(t => t.Title == jobTypeDTO.Title && t.OrganizationId == jobTypeDTO.OrganizationId); if (alreadyExists) { throw new ValidationException(ErrorCodes.DuplicatesIntolerable, "Job position with that title already exists"); } var newType = new JobPosition { Title = jobTypeDTO.Title, CreatedBy = jobTypeDTO.UserId, OrganizationId = jobTypeDTO.OrganizationId }; _jobTypesDbSet.Add(newType); await _uow.SaveChangesAsync(jobTypeDTO.UserId); }
public async Task CreateKudosType(NewKudosTypeDto dto) { var alreadyExists = await _kudosTypesDbSet .AnyAsync(t => t.Name == dto.Name); if (alreadyExists) { throw new ValidationException(444, "Kudos type already exists"); } var newType = new KudosType { Name = dto.Name, Value = dto.Multiplier, Type = ConstBusinessLayer.KudosTypeEnum.Ordinary, Description = dto.Description }; _kudosTypesDbSet.Add(newType); await _uow.SaveChangesAsync(dto.UserId); }
public async Task CreateMonitorAsync(MonitorDto newMonitor, UserAndOrganizationDto userAndOrganizationDto) { if (await _monitorsDbSet.AnyAsync(x => x.Name == newMonitor.Name && x.OrganizationId == userAndOrganizationDto.OrganizationId)) { throw new ValidationException(ErrorCodes.DuplicatesIntolerable, "Monitor names should be unique"); } var timestamp = DateTime.UtcNow; var monitor = new Monitor { Created = timestamp, Modified = timestamp, CreatedBy = userAndOrganizationDto.UserId, ModifiedBy = userAndOrganizationDto.UserId, Name = newMonitor.Name, OrganizationId = userAndOrganizationDto.OrganizationId }; _monitorsDbSet.Add(monitor); await _uow.SaveChangesAsync(false); }
public async Task ToggleLikeAsync(AddLikeDto addLikeDto, UserAndOrganizationDto userOrg) { var comment = await _commentsDbSet .Include(x => x.Post.Wall) .FirstOrDefaultAsync(x => x.Id == addLikeDto.Id && x.Post.Wall.OrganizationId == userOrg.OrganizationId); if (comment == null) { throw new ValidationException(ErrorCodes.ContentDoesNotExist, "Comment does not exist"); } var like = comment.Likes.FirstOrDefault(x => x.UserId == userOrg.UserId); if (like == null) { comment.Likes.Add(new Like(userOrg.UserId, addLikeDto.Type)); } else { comment.Likes.Remove(like); } await _uow.SaveChangesAsync(userOrg.UserId); }
public async Task <int> CreateNewWall(CreateWallDto newWallDto) { var alreadyExists = await _wallsDbSet .AnyAsync(w => w.OrganizationId == newWallDto.OrganizationId && w.Name == newWallDto.Name && (w.Type == WallType.UserCreated || w.Type == WallType.Main)); if (alreadyExists) { throw new ValidationException(ErrorCodes.WallNameAlreadyExists, "Wall name already exists"); } if (newWallDto.MembersIds == null || newWallDto.MembersIds.Any()) { newWallDto.MembersIds = newWallDto.ModeratorsIds; } else { newWallDto.MembersIds = newWallDto.MembersIds.Union(newWallDto.ModeratorsIds); } var wall = new DataLayer.EntityModels.Models.Multiwall.Wall { Access = newWallDto.Access, Type = newWallDto.Type == WallType.Main ? WallType.UserCreated : newWallDto.Type, OrganizationId = newWallDto.OrganizationId, Name = newWallDto.Name, Logo = newWallDto.Logo, Description = newWallDto.Description, Moderators = newWallDto.ModeratorsIds.Select(x => new WallModerator { UserId = x, }).ToList(), Members = newWallDto.MembersIds.Select(x => new WallMember { UserId = x, AppNotificationsEnabled = true, EmailNotificationsEnabled = true }).ToList() }; _wallsDbSet.Add(wall); await _uow.SaveChangesAsync(newWallDto.UserId); return(wall.Id); }
public async Task CreateNewServiceRequestAsync(ServiceRequestDto newServiceRequestDto, UserAndOrganizationDto userAndOrganizationDto) { await ValidateServiceRequestForCreateAsync(newServiceRequestDto); var serviceRequestStatusId = await _serviceRequestStatusDbSet .Where(x => x.Title.Equals("Open")) .Select(x => x.Id) .FirstAsync(); var serviceRequestCategory = await _serviceRequestCategoryDbSet .FirstOrDefaultAsync(x => x.Id == newServiceRequestDto.ServiceRequestCategoryId); if (serviceRequestCategory == null) { throw new ValidationException(ErrorCodes.ContentDoesNotExist, "Service request category does not exist"); } var timestamp = DateTime.UtcNow; var serviceRequest = new ServiceRequest { Description = newServiceRequestDto.Description, Title = newServiceRequestDto.Title, CreatedBy = userAndOrganizationDto.UserId, ModifiedBy = userAndOrganizationDto.UserId, EmployeeId = userAndOrganizationDto.UserId, KudosAmmount = newServiceRequestDto.KudosAmmount, OrganizationId = userAndOrganizationDto.OrganizationId, CategoryName = serviceRequestCategory.Name, StatusId = serviceRequestStatusId, PriorityId = newServiceRequestDto.PriorityId, Created = timestamp, Modified = timestamp, PictureId = newServiceRequestDto.PictureId }; if (newServiceRequestDto.KudosShopItemId != null) { serviceRequest.KudosShopItemId = newServiceRequestDto.KudosShopItemId; } _serviceRequestsDbSet.Add(serviceRequest); await _uow.SaveChangesAsync(false); var srqDto = new CreatedServiceRequestDto { ServiceRequestId = serviceRequest.Id }; _asyncRunner.Run <IServiceRequestNotificationService>(async notifier => await notifier.NotifyAboutNewServiceRequestAsync(srqDto), _uow.ConnectionName); }
public async Task <NewlyCreatedPostDto> CreateNewPostAsync(NewPostDto newPostDto) { await _postDeleteLock.WaitAsync(); try { var wall = await _wallsDbSet.FirstOrDefaultAsync(x => x.Id == newPostDto.WallId && x.OrganizationId == newPostDto.OrganizationId); if (wall == null) { throw new ValidationException(ErrorCodes.ContentDoesNotExist, "Wall not found"); } var post = new Post { AuthorId = newPostDto.UserId, Created = DateTime.UtcNow, LastEdit = DateTime.UtcNow, CreatedBy = newPostDto.UserId, MessageBody = newPostDto.MessageBody, PictureId = newPostDto.PictureId, SharedEventId = newPostDto.SharedEventId, LastActivity = DateTime.UtcNow, WallId = newPostDto.WallId, Likes = new LikesCollection() }; _postsDbSet.Add(post); await _uow.SaveChangesAsync(newPostDto.UserId); _postWatchers.Add(new PostWatcher { PostId = post.Id, UserId = newPostDto.UserId }); await _uow.SaveChangesAsync(newPostDto.UserId); var postCreator = await _usersDbSet.SingleAsync(user => user.Id == newPostDto.UserId); var postCreatorDto = MapUserToDto(postCreator); var newlyCreatedPostDto = MapNewlyCreatedPostToDto(post, postCreatorDto, wall.Type, newPostDto.MentionedUserIds); return(newlyCreatedPostDto); } finally { _postDeleteLock.Release(); } }
public async Task DeleteCommitteeSuggestionAsync(int committeeId, int suggestionId, UserAndOrganizationDto userAndOrg) { var committee = await _committeeDbSet .Include(u => u.Suggestions) .FirstOrDefaultAsync(u => u.Id == committeeId); if (committee == null) { throw new ValidationException(ErrorCodes.ContentDoesNotExist, "Committee does not exist"); } var suggestion = committee.Suggestions.FirstOrDefault(x => x.Id == suggestionId); committee.Suggestions.Remove(suggestion); await _uow.SaveChangesAsync(userAndOrg.UserId); }
public async Task UpdateRecurringEventsAsync() { var eventsToUpdate = await _eventsDbSet .Include(e => e.EventOptions) .Include(u => u.ResponsibleUser) .Where(e => e.EventRecurring != EventRecurrenceOptions.None && e.EndDate < _systemClock.UtcNow && e.ResponsibleUser != null) .ToListAsync(); foreach (var @event in eventsToUpdate) { var newWallId = await CreateEventWallAsync(@event); var newEvent = CreateNewEvent(@event, newWallId); _eventsDbSet.Add(newEvent); @event.EventRecurring = EventRecurrenceOptions.None; CreateNewOptions(@event.EventOptions, newEvent); } await _uow.SaveChangesAsync(false); }
public async Task DeleteBookAsync(int bookId, UserAndOrganizationDto userOrg) { var bookOffices = await _bookOfficesDbSet .Include(x => x.Book) .Include(x => x.BookLogs) .Where(x => x.BookId == bookId && x.OrganizationId == userOrg.OrganizationId) .ToListAsync(); _bookServiceValidator.CheckIfBookOfficesFoundWhileDeleting(bookOffices.Any()); UpdateMetaFields(userOrg, bookOffices); await _uow.SaveChangesAsync(false); RemoveBookRelatedEntities(bookOffices); await _uow.SaveChangesAsync(false); }
public async Task SetManagingDirectorAsync(string userId, UserAndOrganizationDto userAndOrganizationDto) { if (!await _roleService.HasRoleAsync(userId, Contracts.Constants.Roles.Manager)) { throw new ValidationException(ErrorCodes.UserIsNotAManager, "User need to have manager role to become a managing director"); } var managingDirectors = await _usersDbSet .Include(x => x.Roles) .Where(x => x.OrganizationId == userAndOrganizationDto.OrganizationId) .Where(x => x.IsManagingDirector || x.Id == userId) .ToListAsync(); foreach (var currentDirector in managingDirectors.Where(x => x.IsManagingDirector)) { currentDirector.IsManagingDirector = false; } var newManagingDirector = managingDirectors.First(x => x.Id == userId); newManagingDirector.IsManagingDirector = true; await _uow.SaveChangesAsync(userAndOrganizationDto.UserId); }