public void DeleteBook(int bookId, UserAndOrganizationDTO userOrg)
{
var bookOffices = _bookOfficesDbSet
.Include(x => x.Book)
.Include(x => x.BookLogs)
.Where(x => x.BookId == bookId && x.OrganizationId == userOrg.OrganizationId)
.ToList();
_bookServiceValidator.CheckIfBookOfficesFoundWhileDeleting(bookOffices.Any());
UpdateMetaFields(userOrg, bookOffices);
_uow.SaveChanges(false);
RemoveBookRelatedEntities(bookOffices);
_uow.SaveChanges(false);
}
public IEnumerable <WallKudosLogDTO> GetLastKudosLogsForWall(UserAndOrganizationDTO userAndOrg)
{
var approvedKudos = _kudosLogsDbSet
.Include(log => log.Employee)
.Where(log =>
log.Status == KudosStatus.Approved &&
log.KudosSystemType != ConstBusinessLayer.KudosTypeEnum.Minus &&
log.OrganizationId == userAndOrg.OrganizationId)
.OrderByDescending(log => log.Created)
.Select(MapKudosLogToWallKudosLogDTO())
.Take(() => ConstBusinessLayer.WallKudosLogCount)
.ToList();
SetKudosSendersName(approvedKudos.Select(log => log.Sender));
return(approvedKudos);
}
public void ReturnBook(int bookOfficeId, UserAndOrganizationDTO userAndOrg)
{
var log = _bookLogsDbSet
.FirstOrDefault(l => l.BookOfficeId == bookOfficeId &&
l.ApplicationUserId == userAndOrg.UserId &&
l.OrganizationId == userAndOrg.OrganizationId &&
l.Returned == null);
_bookServiceValidator.ThrowIfBookCannotBeReturned(log != null);
log.Returned = DateTime.UtcNow;
log.Modified = DateTime.UtcNow;
log.ModifiedBy = userAndOrg.UserId;
_uow.SaveChanges(false);
}
public KudosTypeDTO GetSendKudosType(UserAndOrganizationDTO userOrg)
{
var hasKudosAdminPermission = HasKudosAdministratorPermission(userOrg);
var sendType = _kudosTypesDbSet
.Where(x => x.Type == KudosTypeEnum.Send)
.Select(MapKudosTypesToDTO)
.FirstOrDefault();
if (sendType == null)
{
throw new ValidationException(ErrorCodes.ContentDoesNotExist, "Types not found");
}
return(sendType);
}
public async Task <NotificationDto> CreateForWall(UserAndOrganizationDTO userOrg, CreateWallDto wallDto, int wallId)
{
int mainWallId = await _wallDbSet.Where(w => w.Type == WallType.Main).Select(s => s.Id).SingleAsync();
var membersToNotify = _wallService.GetWallMembersIds(mainWallId, userOrg);
var newNotification = Notification.Create(wallDto.Name, wallDto.Description, wallDto.Logo, new Sources {
WallId = wallId
}, NotificationType.NewWall, userOrg.OrganizationId, membersToNotify);
_notificationDbSet.Add(newNotification);
await _uow.SaveChangesAsync();
return(_mapper.Map <NotificationDto>(newNotification));
}
private void UpdateMetaFields(UserAndOrganizationDTO userOrg, IEnumerable <BookOffice> bookOffices)
{
bookOffices.ForEach(bookOffice =>
{
bookOffice.BookLogs.ForEach(log =>
{
log.Modified = DateTime.UtcNow;
log.ModifiedBy = userOrg.UserId;
});
bookOffice.Book.Modified = DateTime.UtcNow;
bookOffice.Book.ModifiedBy = userOrg.UserId;
bookOffice.Modified = DateTime.UtcNow;
bookOffice.ModifiedBy = userOrg.UserId;
});
}
public bool UserHasPermission(UserAndOrganizationDTO userAndOrg, string permissionName)
{
if (!_permissionsCache.TryGetValue(userAndOrg.UserId, out var permissions))
{
permissions = _permissionsDbSet
.Where(p => p.Roles.Any(r => r.Users.Any(u => u.UserId == userAndOrg.UserId)))
.Where(FilterActiveModules(userAndOrg.OrganizationId))
.Select(x => x.Name)
.ToList();
_permissionsCache.TryAdd(userAndOrg.UserId, permissions);
}
var isPermitted = permissions.Contains(permissionName);
return(isPermitted);
}
public async Task Delete(string userToDelete, UserAndOrganizationDTO userOrg)
{
var user = _usersDbSet
.Single(u =>
u.Id == userToDelete &&
u.OrganizationId == userOrg.OrganizationId);
ClearUserKudos(user);
UnassignUserFromWalls(userToDelete, userOrg.OrganizationId);
_userManager.RemoveLogins(userToDelete);
await Anonymize(user, userOrg);
_usersDbSet.Remove(user);
_uow.SaveChanges(userOrg.UserId);
}
public void Should_Return_Correctly_Mapped_Book_Details_To_User()
{
MockGetBookDetails();
var userOrg = new UserAndOrganizationDTO
{
OrganizationId = 2,
UserId = "testUser2"
};
var res = _bookService.GetBookDetails(2, userOrg);
Assert.AreEqual(2, res.BookLogs.Count());
Assert.AreEqual(2, res.BookOfficeId);
Assert.AreEqual(1, res.Id);
Assert.AreEqual(1, res.BookLogs.First().LogId);
Assert.AreEqual("name1 surname1", res.BookLogs.First().FullName);
}
public void Book_TakeBook_Should_Return_Bad_Request_If_Exception()
{
var id = 1;
var exception = "test";
var userAndOrg = new UserAndOrganizationDTO
{
UserId = "1",
OrganizationId = 1
};
_bookService.When(s => s.TakeBook(id, userAndOrg)).Do(s => { throw new BookException(exception); });
var response = _bookController.TakeBook(id);
Assert.IsInstanceOf <BadRequestErrorMessageResult>(response);
}
public IEnumerable <WallKudosLogDTO> GetLastKudosLogsForWall(UserAndOrganizationDTO userAndOrg)
{
var approvedKudos = _kudosLogsDbSet
.Include(log => log.Employee)
.Where(log =>
log.Status == KudosStatus.Approved &&
log.KudosSystemType != KudosTypeEnum.Minus &&
log.KudosSystemType != KudosTypeEnum.Refund &&
log.OrganizationId == userAndOrg.OrganizationId)
.Join(_usersDbSet, l => l.CreatedBy, s => s.Id,
MapKudosLogToWallKudosLogDTO())
.OrderByDescending(log => log.Created)
.Take(() => BusinessLayerConstants.WallKudosLogCount)
.ToList();
return(approvedKudos);
}
public void RemoveModerator(int wallId, string responsibleUserId, UserAndOrganizationDTO userAndOrg)
{
var wall = _wallsDbSet
.Include(x => x.Moderators)
.Single(x => x.Id == wallId &&
x.OrganizationId == userAndOrg.OrganizationId);
var moderator = wall.Moderators.SingleOrDefault(x => x.UserId == responsibleUserId);
if (moderator == null)
{
return;
}
_moderatorsDbSet.Remove(moderator);
_uow.SaveChanges(userAndOrg.UserId);
}
public void Should_Return_If_Basket_Widget_Is_Active()
{
var userAndOrg = new UserAndOrganizationDTO
{
OrganizationId = 2
};
// leave only one deactivated basket
_kudosBasketDbSet.Remove(_kudosBasketDbSet.Find(11));
var activeKudosBasket = _kudosBasketDbSet.First(x => x.Id == 10);
activeKudosBasket.IsActive = false;
var result = _kudosBasketService.GetKudosBasketWidget(userAndOrg);
Assert.AreEqual(null, result);
}
public void Should_Delete_Only_Event_Wall()
{
MockWallsForDelete();
var userOrg = new UserAndOrganizationDTO
{
OrganizationId = 2,
UserId = "userId"
};
var wallToDelete = _wallsDbSet.First(x => x.Id == 3);
_wallService.DeleteWall(3, userOrg, WallType.Events);
_wallsDbSet.Received(1).Remove(wallToDelete);
_uow.Received(1).SaveChanges(userOrg.UserId);
}
public void Should_Update_Monitor()
{
MockExternalLinks();
var userAndOrg = new UserAndOrganizationDTO()
{
OrganizationId = 2,
UserId = "1"
};
var monitor = new MonitorDTO()
{
Name = "Test4", Id = 1
};
_monitorService.UpdateMonitor(monitor, userAndOrg);
_uow.Received(1).SaveChanges(false);
}
public async Task <IEnumerable <ProjectsListItemDto> > GetProjects(UserAndOrganizationDTO userOrg)
{
var projects = await _projectsDbSet
.Include(p => p.Attributes)
.Include(p => p.Members)
.Where(p => p.OrganizationId == userOrg.OrganizationId)
.Select(p => new ProjectsListItemDto
{
Id = p.Id,
Name = p.Name,
Attributes = p.Attributes.Select(t => t.Title),
Members = p.Members.Select(m => m.FirstName + " " + m.LastName),
IsCurrentUserAMember = p.Members.Any(m => m.Id == userOrg.UserId)
})
.ToListAsync();
return(projects);
}
public void Should_Create_New_Monitor()
{
MockExternalLinks();
var userAndOrg = new UserAndOrganizationDTO()
{
OrganizationId = 2,
UserId = "1"
};
var monitor = new MonitorDTO()
{
Name = "Test4"
};
_monitorService.CreateMonitor(monitor, userAndOrg);
_monitorsDbSet.Received(1).Add(Arg.Any <Monitor>());
}
public void GetKudosTypes_Should_Return_IEnumerable_Of_KudosType_ViewModel()
{
var userAndOrganization = new UserAndOrganizationDTO()
{
OrganizationId = 1,
UserId = "fd798623-166c-412d-a060-369d4c7b90eb"
};
_kudosService.GetKudosTypes(userAndOrganization)
.Returns(new List <KudosTypeDTO>()
{
new KudosTypeDTO()
});
var response = _kudosController.GetKudosTypes();
Assert.IsInstanceOf <IEnumerable <KudosTypeViewModel> >(response);
}
public void Should_Throw_When_Creating_Monitor_With_Existing_Name()
{
MockExternalLinks();
var userAndOrg = new UserAndOrganizationDTO()
{
OrganizationId = 2,
UserId = "1"
};
var monitor = new MonitorDTO()
{
Name = "Test1"
};
var ex = Assert.Throws <ValidationException>(() => _monitorService.CreateMonitor(monitor, userAndOrg));
Assert.That(ex.ErrorCode, Is.EqualTo(ErrorCodes.DuplicatesIntolerable));
}
public void Should_Throw_If_Post_To_Be_Deleted_Does_Not_Exist()
{
// Setup
var posts = new List <Post>();
_postsDbSet.SetDbSetData(posts.AsQueryable());
var userOrg = new UserAndOrganizationDTO
{
UserId = "user1",
OrganizationId = 2
};
// Act
// Assert
var ex = Assert.Throws <ValidationException>(() => _postService.DeleteWallPost(1, userOrg));
Assert.AreEqual(ErrorCodes.ContentDoesNotExist, ex.ErrorCode);
}
public IEnumerable <KudosTypeDTO> GetKudosTypes(UserAndOrganizationDTO userAndOrg)
{
var hasKudosAdminPermission = HasKudosAdministratorPermission(userAndOrg);
var kudosTypesDTO = _kudosTypesDbSet
.Where(GetKudosTypeQuery(hasKudosAdminPermission))
.Select(MapKudosTypesToDTO)
.ToList();
foreach (var kudosType in kudosTypesDTO)
{
if (IsTranslatableKudosType(kudosType.Type))
{
kudosType.Name = TranslateKudos(userAndOrg.UserId, "KudosType" + kudosType.Name);
}
}
return(kudosTypesDTO);
}
public void Should_Throw_When_Updating_Not_Existing_Monitor()
{
MockExternalLinks();
var userAndOrg = new UserAndOrganizationDTO()
{
OrganizationId = 2,
UserId = "1"
};
var monitor = new MonitorDTO()
{
Name = "Test2", Id = 5
};
var ex = Assert.Throws <ValidationException>(() => _monitorService.UpdateMonitor(monitor, userAndOrg));
Assert.That(ex.ErrorCode, Is.EqualTo(ErrorCodes.ContentDoesNotExist));
}
public async Task <EditProjectDisplayDto> GetProjectById(int projectId, UserAndOrganizationDTO userOrg)
{
string projectOwnerId = await _projectsDbSet.Where(p =>
p.Id == projectId &&
p.OrganizationId == userOrg.OrganizationId).Select(s => s.OwnerId)
.SingleAsync();
ValidateOwnershipPermissions(projectOwnerId, userOrg);
var project = await _projectsDbSet
.Include(p => p.Members)
.Include(p => p.Attributes)
.Include(p => p.Owner)
.Where(p =>
p.Id == projectId &&
p.OrganizationId == userOrg.OrganizationId)
.Select(p => new EditProjectDisplayDto
{
Id = p.Id,
Description = p.Desc,
Logo = p.Logo,
Title = p.Name,
Owner = new UserDto
{
UserId = p.Owner.Id,
FullName = p.Owner.FirstName + " " + p.Owner.LastName
},
Members = p.Members.Select(m => new UserDto
{
UserId = m.Id,
FullName = m.FirstName + " " + m.LastName
}),
Attributes = p.Attributes.Select(t => t.Title).ToList()
})
.FirstOrDefaultAsync();
if (project == null)
{
throw new ValidationException(ErrorCodes.ContentDoesNotExist, "Project not found");
}
return(project);
}
private async Task Anonymize(ApplicationUser user, UserAndOrganizationDTO userOrg)
{
await _pictureService.RemoveImage(user.PictureId, userOrg.OrganizationId);
var randomString = Guid.NewGuid().ToString();
user.Email = randomString;
user.FirstName = randomString;
user.LastName = randomString;
user.PhoneNumber = randomString;
user.UserName = randomString;
user.FacebookEmail = randomString;
user.GoogleEmail = randomString;
user.Bio = string.Empty;
user.PictureId = string.Empty;
user.BirthDay = DateTime.UtcNow;
_uow.SaveChanges(userOrg.UserId);
}
public async Task CreateAsync(AuthenticationTokenCreateContext context)
{
using (var requestScope = _ioc.BeginLifetimeScope("AutofacWebRequest"))
{
var tokenService = requestScope.Resolve(typeof(IRefreshTokenService)) as IRefreshTokenService;
var clientId = context.Ticket.Properties.Dictionary["client_id"];
if (string.IsNullOrEmpty(clientId))
{
await Task.CompletedTask;
}
var refreshTokenId = Guid.NewGuid().ToString("n");
var refreshTokenLifeTimeInDays = Convert.ToInt16(ConfigurationManager.AppSettings["RefreshTokenLifeTimeInDays"]);
var token = new RefreshTokenDTO
{
Id = CryptoHelper.GetHash(refreshTokenId),
Subject = context.Ticket.Identity.GetUserId(),
IssuedUtc = DateTime.UtcNow,
ExpiresUtc = DateTime.UtcNow.AddDays(refreshTokenLifeTimeInDays),
OrganizationId = context.Ticket.Identity.GetOrganizationId()
};
context.Ticket.Properties.IssuedUtc = token.IssuedUtc;
context.Ticket.Properties.ExpiresUtc = token.ExpiresUtc;
token.ProtectedTicket = context.SerializeTicket();
var userOrg = new UserAndOrganizationDTO
{
OrganizationId = context.Ticket.Identity.GetOrganizationId(),
UserId = context.Ticket.Identity.GetUserId()
};
tokenService?.RemoveTokenBySubject(userOrg);
tokenService?.AddNewToken(token);
context.SetToken(refreshTokenId);
}
await Task.CompletedTask;
}
private async Task <AuthenticationProperties> CreateInitialRefreshToken(string clientId, ApplicationUser user, ClaimsIdentity oAuthIdentity)
{
var userOrganization = new UserAndOrganizationDTO
{
OrganizationId = user.OrganizationId,
UserId = user.Id
};
_refreshTokenService.RemoveTokenBySubject(userOrganization);
AuthenticationProperties properties = ApplicationOAuthProvider.CreateProperties(user.Id, clientId);
var ticket = new AuthenticationTicket(oAuthIdentity, properties);
var context = new AuthenticationTokenCreateContext(Request.GetOwinContext(), Startup.OAuthServerOptions.RefreshTokenFormat, ticket);
await Startup.OAuthServerOptions.RefreshTokenProvider.CreateAsync(context);
properties.Dictionary.Add("refresh_token", context.Token);
return(properties);
}
public void Should_Get_Role_With_All_Permissions_And_Users()
{
MockRoles();
var userAndOrg = new UserAndOrganizationDTO
{
OrganizationId = 1,
};
var roles = _roleService.GetRoleById(userAndOrg, "roleId1");
Assert.AreEqual("Test1", roles.Name);
Assert.AreEqual(3, roles.Permissions.Count());
Assert.AreEqual(PermissionScopes.Basic, roles.Permissions.ToArray()[0].ActiveScope);
Assert.AreEqual(PermissionScopes.Administration, roles.Permissions.ToArray()[1].ActiveScope);
Assert.AreEqual("", roles.Permissions.ToArray()[2].ActiveScope);
Assert.AreEqual(2, roles.Users.Count());
Assert.AreEqual("first1 last1", roles.Users.ToArray()[0].FullName);
Assert.AreEqual("first2 last2", roles.Users.ToArray()[1].FullName);
}
private async Task <IEnumerable <PostDTO> > QueryForPosts(UserAndOrganizationDTO userOrg, int pageNumber, int pageSize, int?wallId, Expression <Func <Post, bool> > filter, int?wallsType)
{
if (filter == null)
{
filter = post => true;
}
List <int> wallsIds;
if (wallId.HasValue && WallIsValid(userOrg, wallId.Value))
{
wallsIds = new List <int> {
wallId.Value
};
}
else
{
wallsIds = wallsType == (int)WallsType.MyWalls ?
(await GetWallsList(userOrg, WallsListFilter.Followed)).Select(w => w.Id).ToList() :
(await GetWallsList(userOrg, WallsListFilter.All)).Select(w => w.Id).ToList();
}
var entriesCountToSkip = (pageNumber - 1) * pageSize;
var posts = await _postsDbSet
.Include(post => post.Wall)
.Include(post => post.Comments)
.Where(post => wallsIds.Contains(post.WallId))
.Where(filter)
.OrderByDescending(x => x.LastActivity)
.Skip(() => entriesCountToSkip)
.Take(() => pageSize)
.ToListAsync();
var moderators = await _moderatorsDbSet.Where(x => wallsIds.Contains(x.WallId)).ToListAsync();
var watchedPosts = await RetrieveWatchedPosts(userOrg.UserId, posts);
var users = await GetUsers(posts);
return(MapPostsWithChildEntitiesToDto(userOrg.UserId, posts, users, moderators, watchedPosts));
}
public async Task Should_Return_Wall_Details_By_Id_2()
{
MockWallsForDetails();
var userOrg = new UserAndOrganizationDTO
{
OrganizationId = 2,
UserId = "userId"
};
var wall = await _wallService.WallDetails(2, userOrg);
Assert.AreEqual(2, wall.Id);
Assert.AreEqual("Wall2", wall.Name);
Assert.AreEqual(false, wall.IsFollowing);
Assert.AreEqual(1, wall.Moderators.Count());
Assert.AreEqual("user1", wall.Moderators.First().Id);
Assert.AreEqual("Description2", wall.Description);
Assert.AreEqual("Logo2.jpg", wall.Logo);
Assert.AreEqual(WallType.UserCreated, wall.Type);
}
public async Task MarkAllAsRead(UserAndOrganizationDTO userOrg)
{
var notificationUsers = await _notificationUserDbSet
.Include(i => i.Notification)
.Where(s => s.Notification.OrganizationId == userOrg.OrganizationId &&
s.UserId == userOrg.UserId &&
!s.IsAlreadySeen)
.ToListAsync();
if (!notificationUsers.Any())
{
return;
}
foreach (var notificationUser in notificationUsers)
{
notificationUser.IsAlreadySeen = true;
}
await _uow.SaveChangesAsync();
}
