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