private static bool CanAccessFolder(IEmployer employer, CandidateFolder folder)
{
if (employer == null)
{
return(false);
}
if (folder == null)
{
return(false);
}
if (folder.IsDeleted)
{
return(false);
}
if (folder.FolderType == FolderType.Shared)
{
// The folder is shared, so the user must have access to this company's shared data to edit it. Even if they
// are the owner of this folder they cannot edit it once they've left the company.
return(folder.OrganisationId == employer.Organisation.Id);
}
// The folder is private, so only the owner can edit or delete it.
return(folder.RecruiterId == employer.Id);
}
public void TestMultipleMembersInFolders()
{
var employer0 = CreateEmployer(0);
var employer1 = CreateEmployer(1, employer0.Organisation);
var member0 = CreateMember(0);
var member1 = CreateMember(1);
var folder = new CandidateFolder {
Name = FolderName
};
_candidateFoldersCommand.CreateSharedFolder(employer0, folder);
_candidateListsCommand.AddCandidateToFolder(employer0, folder, member0.Id);
folder = _candidateFoldersQuery.GetShortlistFolder(employer0);
_candidateListsCommand.AddCandidateToFolder(employer0, folder, member0.Id);
_candidateListsCommand.AddCandidateToFolder(employer0, folder, member1.Id);
TestCount(employer0, member0.Id, 2, v => v.Folders);
TestCount(employer0, member1.Id, 1, v => v.Folders);
TestCount(employer1, member0.Id, 1, v => v.Folders);
TestCount(employer1, member1.Id, 0, v => v.Folders);
var views = _employerMemberViewsQuery.GetEmployerMemberViews(employer0, new[] { member0.Id, member1.Id });
Assert.AreEqual(2, views[member0.Id].Folders);
Assert.AreEqual(1, views[member1.Id].Folders);
views = _employerMemberViewsQuery.GetEmployerMemberViews(employer1, new[] { member0.Id, member1.Id });
Assert.AreEqual(1, views[member0.Id].Folders);
Assert.AreEqual(0, views[member1.Id].Folders);
}
private void TestDeleteFolder(bool isShared)
{
// Create a folder.
var employer = _employerAccountsCommand.CreateTestEmployer(0, _organisationsCommand.CreateTestVerifiedOrganisation(0));
var folder = new CandidateFolder {
Name = string.Format(FolderNameFormat, 0)
};
if (isShared)
{
_candidateFoldersCommand.CreateSharedFolder(employer, folder);
}
else
{
_candidateFoldersCommand.CreatePrivateFolder(employer, folder);
}
LogIn(employer);
// Delete.
var model = DeleteFolder(folder.Id);
// Assert.
AssertJsonSuccess(model);
Assert.IsNull(_candidateFoldersQuery.GetFolder(employer, folder.Id));
}
private void AssertFolders(IEmployer employer, CandidateFolder shortlistFolder, CandidateFolder mobileFolder, ICollection <CandidateFolder> privateFolders, ICollection <CandidateFolder> sharedFolders)
{
// Shortlist folder.
AssertFolder(employer, shortlistFolder, _candidateFoldersQuery.GetFolder(employer, shortlistFolder.Id));
// Mobile folder.
AssertFolder(employer, mobileFolder, _candidateFoldersQuery.GetFolder(employer, mobileFolder.Id));
// Private folders.
foreach (var folder in privateFolders)
{
AssertFolder(employer, folder, _candidateFoldersQuery.GetFolder(employer, folder.Id));
}
var folders = _candidateFoldersQuery.GetPrivateFolders(employer);
Assert.AreEqual(privateFolders.Count, folders.Count);
foreach (var folder in privateFolders)
{
var folderId = folder.Id;
AssertFolder(employer, folder, (from f in folders where f.Id == folderId select f).Single());
}
// Shared folders.
foreach (var folder in sharedFolders)
{
AssertFolder(employer, folder, _candidateFoldersQuery.GetFolder(employer, folder.Id));
}
folders = _candidateFoldersQuery.GetSharedFolders(employer);
Assert.AreEqual(sharedFolders.Count, folders.Count);
foreach (var folder in sharedFolders)
{
var folderId = folder.Id;
AssertFolder(employer, folder, (from f in folders where f.Id == folderId select f).Single());
}
// All folders.
folders = _candidateFoldersQuery.GetFolders(employer);
Assert.AreEqual(1 + 1 + privateFolders.Count + sharedFolders.Count, folders.Count);
AssertFolder(employer, shortlistFolder, (from f in folders where f.FolderType == FolderType.Shortlist select f).Single());
AssertFolder(employer, mobileFolder, (from f in folders where f.FolderType == FolderType.Mobile select f).Single());
foreach (var folder in privateFolders)
{
var folderId = folder.Id;
AssertFolder(employer, folder, (from f in folders where f.Id == folderId select f).Single());
}
foreach (var folder in sharedFolders)
{
var folderId = folder.Id;
AssertFolder(employer, folder, (from f in folders where f.Id == folderId select f).Single());
}
}
private void Validate(IEmployer employer, CandidateFolder folder, string newName)
{
if (string.IsNullOrEmpty(newName))
{
throw new ValidationErrorsException(new RequiredValidationError("name"));
}
// Don't need to check the name of a deleted folder.
if (folder.IsDeleted)
{
return;
}
// Check no private folder with the same name and owner OR no shared folder with same name and organisation.
if (folder.FolderType == FolderType.Shared)
{
if (_contenderListsQuery.GetSharedList <CandidateFolder>(employer.Organisation.Id, newName, new[] { (int)FolderType.Shared }) != null)
{
throw new ValidationErrorsException(new DuplicateValidationError("Name"));
}
}
else
{
if (_contenderListsQuery.GetList <CandidateFolder>(employer.Id, newName, new[] { (int)FolderType.Shortlist, (int)FolderType.Private }) != null)
{
throw new ValidationErrorsException(new DuplicateValidationError("Name"));
}
}
}
private void AssertFolders(IUser employer, CandidateFolder shortlistFolder, ICollection <CandidateFolder> privateFolders, ICollection <CandidateFolder> sharedFolders)
{
LogIn(employer);
Get(GetFoldersUrl());
// Private folders.
var nodes = Browser.CurrentHtml.DocumentNode.SelectNodes("//div[@class='manage-folders']/div[position()=1]/div[@class='section-content']/table//tr");
Assert.AreEqual(2 + privateFolders.Count, nodes.Count);
// First one should be flag list.
AssertFlagList(nodes[0]);
// Next should be shortlist.
AssertShortList(nodes[1], shortlistFolder);
// The rest should be private folders.
AssertPrivateFolders((from i in Enumerable.Range(2, nodes.Count - 2) select nodes[i]), employer as Employer, privateFolders);
// Shared folders.
nodes = Browser.CurrentHtml.DocumentNode.SelectNodes("//div[@class='manage-folders']/div[position()=2]/div[@class='section-content']/table//tr");
Assert.AreEqual(sharedFolders.Count, nodes == null ? 0 : nodes.Count);
AssertSharedFolders(employer.Id, nodes, sharedFolders);
}
protected static void AssertFolders(IEmployer employer, string shortlistFolderName, string mobileFolderName, CandidateFolder[] expectedFolders, IList <CandidateFolder> folders)
{
// Should always have a shortlist and favourites folder.
Assert.AreEqual(expectedFolders.Length + 2, folders.Count);
// Look for the shortlist folder.
var shortlistFolder = new CandidateFolder {
RecruiterId = employer.Id, FolderType = FolderType.Shortlist, Name = shortlistFolderName
};
AssertFolder(employer, shortlistFolder, (from f in folders where f.FolderType == FolderType.Shortlist select f).Single());
// Look for the mobile folder.
var mobileFolder = new CandidateFolder {
RecruiterId = employer.Id, FolderType = FolderType.Mobile, Name = mobileFolderName
};
AssertFolder(employer, mobileFolder, (from f in folders where f.FolderType == FolderType.Mobile select f).Single());
// Look for other folders.
foreach (var expectedFolder in expectedFolders)
{
var expectedFolderId = expectedFolder.Id;
AssertFolder(employer, expectedFolder, (from f in folders where f.Id == expectedFolderId select f).Single());
}
}
protected static void AssertFolder(IEmployer employer, CandidateFolder expectedFolder, CandidateFolder folder)
{
Assert.AreNotEqual(Guid.Empty, folder.Id);
Assert.AreNotEqual(DateTime.MinValue, folder.CreatedTime);
if (!((expectedFolder.FolderType == FolderType.Shortlist || expectedFolder.FolderType == FolderType.Mobile) && expectedFolder.Id == Guid.Empty))
{
Assert.AreEqual(expectedFolder.Id, folder.Id);
}
Assert.AreEqual(expectedFolder.Name, folder.Name);
Assert.AreEqual(expectedFolder.FolderType, folder.FolderType);
switch (expectedFolder.FolderType)
{
case FolderType.Shared:
case FolderType.Private:
Assert.IsNotNull(folder.Name);
break;
}
if (folder.FolderType == FolderType.Shared)
{
Assert.AreEqual(employer.Organisation.Id, folder.OrganisationId);
Assert.AreEqual(expectedFolder.OrganisationId, folder.OrganisationId);
}
else
{
Assert.AreEqual(employer.Id, folder.RecruiterId);
Assert.AreEqual(expectedFolder.RecruiterId, folder.RecruiterId);
Assert.IsNull(folder.OrganisationId);
}
}
private static bool CanDeleteFolder(IEmployer employer, CandidateFolder folder)
{
// Must be owner.
return(CanAccessFolder(employer, folder, true) &&
CanBeDeleted(folder) &&
folder.RecruiterId == employer.Id);
}
private void CreateCandidates(int count, IEmployer employer, CandidateFolder folder)
{
for (var index = 0; index < count; ++index)
{
var member = CreateMember(index);
_candidateListsCommand.AddCandidateToFolder(employer, folder, member.Id);
}
}
protected CandidateFolder CreatePrivateFolder(IEmployer employer, int index)
{
var folder = new CandidateFolder {
Name = string.Format(PrivateFolderNameFormat, index)
};
_candidateFoldersCommand.CreatePrivateFolder(employer, folder);
return(folder);
}
protected CandidateFolder CreateSharedFolder(IEmployer employer, int index)
{
var folder = new CandidateFolder {
Name = string.Format(FolderNameFormat, index), RecruiterId = employer.Id
};
_candidateFoldersCommand.CreateSharedFolder(employer, folder);
return(folder);
}
void ICandidateFoldersCommand.CreatePrivateFolder(IEmployer employer, CandidateFolder folder)
{
folder.RecruiterId = employer.Id;
folder.OrganisationId = null;
folder.FolderType = FolderType.Private;
Validate(employer, folder, folder.Name);
_contenderListsCommand.CreateList(folder);
}
private CandidateFolder CreateSharedFolder(IEmployer employer, int index)
{
var folder = new CandidateFolder {
Name = string.Format(SharedFolderName, index)
};
_candidateFoldersCommand.CreateSharedFolder(employer, folder);
return(folder);
}
private void AssertShortList(HtmlNode node, CandidateFolder shortlistFolder)
{
var a = node.SelectSingleNode(".//a");
Assert.AreEqual(string.IsNullOrEmpty(shortlistFolder.Name) ? "My shortlist" : shortlistFolder.Name, a.InnerText);
Assert.AreEqual(GetFolderUrl(shortlistFolder.Id).Path.ToLower(), a.Attributes["href"].Value.ToLower());
AssertRename(node, true);
AssertRemove(node, false, false);
}
private CandidateFolder CreateSpecialFolder(Guid employerId, FolderType folderType)
{
var folder = new CandidateFolder {
RecruiterId = employerId, FolderType = folderType
};
_contenderListsCommand.CreateList(folder);
return(folder);
}
void ICandidateFoldersCommand.UndeleteFolder(IEmployer employer, CandidateFolder folder)
{
if (!CanDeleteFolder(employer, folder))
{
throw new CandidateFoldersPermissionsException(employer, folder.Id);
}
folder.IsDeleted = false;
_contenderListsCommand.UpdateList(folder);
}
int ICandidateListsCommand.RemoveAllCandidatesFromFolder(IEmployer employer, CandidateFolder folder)
{
if (!CanModifyCandidates(employer, folder))
{
throw new CandidateFoldersPermissionsException(employer, folder.Id);
}
RemoveAllCandidatesFromList(folder.Id);
return(_contenderListsQuery.GetListedCount(folder.Id, new[] { (int)BlockListType.Permanent }));
}
int ICandidateListsCommand.AddCandidatesToFolder(IEmployer employer, CandidateFolder folder, IEnumerable <Guid> candidateIds)
{
if (!CanModifyCandidates(employer, folder))
{
throw new CandidateFoldersPermissionsException(employer, folder.Id);
}
AddCandidatesToFolder(employer.Id, folder.Id, candidateIds);
return(_contenderListsQuery.GetListedCount(folder.Id, new[] { (int)BlockListType.Permanent }));
}
void ICandidateFoldersCommand.CreateSharedFolder(IEmployer employer, CandidateFolder folder)
{
// Create a list for the folder.
folder.RecruiterId = employer.Id;
folder.OrganisationId = employer.Organisation.Id;
folder.FolderType = FolderType.Shared;
Validate(employer, folder, folder.Name);
_contenderListsCommand.CreateList(folder);
}
public void ListsTestsInitialize()
{
Resolve <IDbConnectionFactory>().DeleteAllTestData();
_temporaryBlockList = null;
_permanentBlockList = null;
_flagList = null;
_privateFolder = null;
_sharedFolder = null;
_shortlistFolder = null;
_mobileFolder = null;
}
private static void AssertModel(CandidateFolder folder, IDictionary <Guid, int> expectedCounts, bool expectedCanRename, bool expectedCanDelete, FolderModel model)
{
Assert.AreEqual(folder.Name, model.Name);
Assert.AreEqual(folder.FolderType.ToString(), model.Type);
Assert.AreEqual(expectedCanRename, model.CanRename);
Assert.AreEqual(expectedCanDelete, model.CanDelete);
int expectedCount;
expectedCounts.TryGetValue(model.Id, out expectedCount);
Assert.AreEqual(expectedCount, model.Count);
}
public static string GetNameDisplayText(this CandidateFolder folder)
{
if (folder.FolderType == FolderType.Shortlist && string.IsNullOrEmpty(folder.Name))
{
return("My shortlist");
}
if (folder.FolderType == FolderType.Mobile)
{
return("My mobile favourites");
}
return(folder.Name);
}
void ICandidateFoldersCommand.RenameFolder(IEmployer employer, CandidateFolder folder, string name)
{
if (!CanRenameFolder(employer, folder))
{
throw new CandidateFoldersPermissionsException(employer, folder.Id);
}
// Validate.
Validate(employer, folder, name);
folder.Name = name;
_contenderListsCommand.UpdateList(folder);
}
public ActionResult NewFolder(string name, bool isShared, Guid[] candidateIds)
{
try
{
// Create the folder.
var employer = CurrentEmployer;
var folder = new CandidateFolder
{
Name = name,
OrganisationId = isShared ? employer.Organisation.Id : (Guid?)null,
RecruiterId = employer.Id
};
if (isShared)
{
_candidateFoldersCommand.CreateSharedFolder(employer, folder);
}
else
{
_candidateFoldersCommand.CreatePrivateFolder(employer, folder);
}
// Add candidates.
if (candidateIds != null && candidateIds.Length > 0)
{
_candidateListsCommand.AddCandidatesToFolder(employer, folder, candidateIds);
}
return(Json(new JsonFolderModel
{
Folder = new FolderModel
{
Id = folder.Id,
Name = folder.Name,
Type = (isShared ? FolderType.Shared : FolderType.Private).ToString(),
CanRename = _candidateFoldersCommand.CanRenameFolder(employer, folder),
CanDelete = _candidateFoldersCommand.CanDeleteFolder(employer, folder),
Count = candidateIds == null ? 0 : candidateIds.Length,
}
}));
}
catch (UserException ex)
{
ModelState.AddModelError(ex, new StandardErrorHandler());
}
return(Json(new JsonResponseModel()));
}
private IList <Member> CreateCandidates(int count, IEmployer employer, CandidateFolder folder)
{
var members = new List <Member>();
for (var index = 0; index < count; ++index)
{
var member = CreateMember(index);
_candidateListsCommand.AddCandidateToFolder(employer, folder, member.Id);
_memberSearchService.UpdateMember(member.Id);
members.Add(member);
}
return(members);
}
public void TestGetMobileFolder()
{
var employer = CreateEmployer(1);
var folder = new CandidateFolder {
RecruiterId = employer.Id, FolderType = FolderType.Mobile
};
var mobileFolder = _candidateFoldersQuery.GetMobileFolder(employer);
AssertFolder(employer, folder, mobileFolder);
AssertFolder(employer, folder, _candidateFoldersQuery.GetFolder(employer, mobileFolder.Id));
Assert.AreEqual(0, _candidateFoldersQuery.GetPrivateFolders(employer).Count);
Assert.AreEqual(0, _candidateFoldersQuery.GetSharedFolders(employer).Count);
AssertFolders(employer, new CandidateFolder[0], _candidateFoldersQuery.GetFolders(employer));
}
public void TestGetShortlistFlaggedFolders()
{
var employer = CreateEmployer(1);
var folder1 = new CandidateFolder {
RecruiterId = employer.Id, FolderType = FolderType.Shortlist
};
var shortlistFolder = _candidateFoldersQuery.GetShortlistFolder(employer);
AssertFolder(employer, folder1, shortlistFolder);
AssertFolder(employer, folder1, _candidateFoldersQuery.GetFolder(employer, shortlistFolder.Id));
Assert.AreEqual(0, _candidateFoldersQuery.GetPrivateFolders(employer).Count);
Assert.AreEqual(0, _candidateFoldersQuery.GetSharedFolders(employer).Count);
AssertFolders(employer, new CandidateFolder[0], _candidateFoldersQuery.GetFolders(employer));
}
public void TestIsInSharedFolder()
{
var employer0 = CreateEmployer(0);
var employer1 = CreateEmployer(1, employer0.Organisation);
var member = CreateMember(0);
var folder = new CandidateFolder {
Name = FolderName
};
_candidateFoldersCommand.CreateSharedFolder(employer0, folder);
_candidateListsCommand.AddCandidateToFolder(employer0, folder, member.Id);
TestCount(employer0, member.Id, 1, v => v.Folders);
TestCount(employer1, member.Id, 1, v => v.Folders);
}
protected void AssertFolderEntries(IEmployer employer, CandidateFolder folder, ICollection <Member> inFolderMembers, ICollection <Member> notInFolderMembers)
{
// IsInFolder
foreach (var inFolderMember in inFolderMembers)
{
Assert.IsTrue(_candidateFoldersQuery.IsInFolder(employer, folder.Id, inFolderMember.Id));
}
foreach (var notInFolderMember in notInFolderMembers)
{
Assert.IsFalse(_candidateFoldersQuery.IsInFolder(employer, folder.Id, notInFolderMember.Id));
}
if (folder.FolderType == FolderType.Mobile)
{
foreach (var member in inFolderMembers)
{
Assert.IsTrue(_candidateFoldersQuery.IsInMobileFolder(employer, member.Id));
}
foreach (var member in notInFolderMembers)
{
Assert.IsFalse(_candidateFoldersQuery.IsInMobileFolder(employer, member.Id));
}
}
// GetInFolderCandidateIds
Assert.IsTrue((from m in inFolderMembers select m.Id).CollectionEqual(_candidateFoldersQuery.GetInFolderCandidateIds(employer, folder.Id)));
if (folder.FolderType == FolderType.Mobile)
{
Assert.IsTrue((from m in inFolderMembers select m.Id).CollectionEqual(_candidateFoldersQuery.GetInMobileFolderCandidateIds(employer, from m in inFolderMembers.Concat(notInFolderMembers) select m.Id)));
}
// GetInFolderCounts.
var counts = _candidateFoldersQuery.GetInFolderCounts(employer);
if (counts.ContainsKey(folder.Id))
{
Assert.AreEqual(inFolderMembers.Count, counts[folder.Id]);
}
else
{
Assert.AreEqual(inFolderMembers.Count, 0);
}
}
