public ActionResult NewNote(Guid[] candidateIds, string text, bool isShared)
{
try
{
var employer = CurrentEmployer;
// Create them.
foreach (var candidateId in candidateIds)
{
var note = new CandidateNote
{
Text = text,
CandidateId = candidateId,
};
if (isShared)
{
_candidateNotesCommand.CreateSharedNote(employer, note);
}
else
{
_candidateNotesCommand.CreatePrivateNote(employer, note);
}
}
}
catch (UserException ex)
{
ModelState.AddModelError(ex, new StandardErrorHandler());
}
return(Json(new JsonResponseModel()));
}
private static void AssertNote(CandidateNote expectedNote, CandidateNote note)
{
Assert.AreEqual(expectedNote.Id, note.Id);
Assert.AreEqual(expectedNote.RecruiterId, note.RecruiterId);
Assert.AreEqual(expectedNote.OrganisationId, note.OrganisationId);
Assert.AreEqual(expectedNote.CandidateId, note.CandidateId);
Assert.AreEqual(expectedNote.Text, note.Text);
}
private CandidateNote CreateNote(IEmployer employer, Guid memberId, int index)
{
var note = new CandidateNote {
CandidateId = memberId, Text = string.Format(TextFormat, index), CreatedTime = DateTime.Now.AddMinutes(-1 * index)
};
_candidateNotesCommand.CreateSharedNote(employer, note);
return(note);
}
void ICandidateNotesCommand.UpdateNote(IEmployer employer, CandidateNote note)
{
if (!CanUpdateNote(employer, note))
{
throw new NoteOwnerPermissionsException(employer, note.Id);
}
_contenderNotesCommand.UpdateNote(note);
}
private static bool CanUpdateNote(IHasId <Guid> employer, CandidateNote note)
{
// Must own the note to update it.
if (employer == null || note == null)
{
return(false);
}
return(note.RecruiterId == employer.Id);
}
protected static void AssertModel(IEmployer createdBy, NoteModel model, CandidateNote expectedNote)
{
if (expectedNote.Id != Guid.Empty)
{
Assert.AreEqual(expectedNote.Id, model.Id);
}
Assert.AreEqual(expectedNote.IsShared, model.IsShared);
Assert.AreEqual(true, model.UpdatedTime != DateTime.MinValue);
Assert.AreEqual(expectedNote.Text, model.Text);
Assert.AreEqual(createdBy == null ? null : createdBy.FullName, model.CreatedBy);
}
void ICandidateNotesCommand.UnshareNote(IEmployer employer, CandidateNote note)
{
// Must be able to update the note.
if (!CanUpdateNote(employer, note))
{
throw new NoteOwnerPermissionsException(employer, note.Id);
}
Prepare(employer, note, false);
_contenderNotesCommand.UpdateNote(note);
}
private void AssertNote(bool expectAccess, CandidateNote expectedNote, IEmployerContact noteReader)
{
var note = _candidateNotesCommand.GetCandidateNote(noteReader, expectedNote.Id);
if (expectAccess)
{
AssertNote(expectedNote, note);
}
else
{
Assert.IsNull(note);
}
}
private Member CreateMember(IEmployer employer, int index, bool inFolder, bool isFlagged, bool hasNotes, bool hasBeenViewed, bool canContact)
{
var member = _memberAccountsCommand.CreateTestMember(index);
var candidate = _candidatesQuery.GetCandidate(member.Id);
_candidateResumesCommand.AddTestResume(candidate);
// In folder.
if (inFolder)
{
var folder = _candidateFoldersQuery.GetShortlistFolder(employer);
_candidateListsCommand.AddCandidateToFolder(employer, folder, member.Id);
}
// Is flagged.
if (isFlagged)
{
var flagList = _candidateFlagListsQuery.GetFlagList(employer);
_candidateListsCommand.AddCandidateToFlagList(employer, flagList, member.Id);
}
// Has notes.
if (hasNotes)
{
var note = new CandidateNote {
CandidateId = member.Id, Text = "A note"
};
_candidateNotesCommand.CreatePrivateNote(employer, note);
}
// Has been viewed.
if (hasBeenViewed)
{
_employerMemberViewsCommand.ViewMember(_app, employer, member);
}
// Has been contacted.
if (canContact)
{
_employerMemberViewsCommand.AccessMember(_app, employer, _employerMemberViewsQuery.GetProfessionalView(employer, member), MemberAccessReason.PhoneNumberViewed);
}
_updateMemberSearchCommand.AddMember(member.Id);
return(member);
}
public void TestHasSharedNotes()
{
var employer0 = CreateEmployer(0);
var employer1 = CreateEmployer(1, employer0.Organisation);
var member = CreateMember(0);
var note = new CandidateNote {
CandidateId = member.Id, Text = NoteText
};
_candidateNotesCommand.CreateSharedNote(employer0, note);
TestCount(employer0, member.Id, 1, v => v.Notes);
TestCount(employer1, member.Id, 1, v => v.Notes);
}
private CandidateNote CreateNote(int index, IEmployer noteCreator, Guid memberId, bool isShared)
{
var note = new CandidateNote {
CandidateId = memberId, Text = string.Format(TextFormat, index)
};
if (isShared)
{
_candidateNotesCommand.CreateSharedNote(noteCreator, note);
}
else
{
_candidateNotesCommand.CreatePrivateNote(noteCreator, note);
}
return(note);
}
public void TestNewNotesShared()
{
// Create member.
var member0 = _memberAccountsCommand.CreateTestMember(0);
var member1 = _memberAccountsCommand.CreateTestMember(1);
// Create employer and log in.
var employer = _employerAccountsCommand.CreateTestEmployer(0, _organisationsCommand.CreateTestVerifiedOrganisation(0));
LogIn(employer);
AssertModels(employer, Notes(member0.Id));
AssertModels(employer, Notes(member1.Id));
var note1 = new CandidateNote {
Text = string.Format(NoteTextFormat, 1), RecruiterId = employer.Id, OrganisationId = employer.Organisation.Id
};
var model = CreateNote(new[] { member0.Id, member1.Id }, note1.Text, true);
// Assert.
AssertJsonSuccess(model);
AssertNotes(employer, member0.Id, note1);
AssertNotes(employer, member1.Id, note1);
AssertModels(null, Notes(member0.Id), note1);
AssertModels(null, Notes(member1.Id), note1);
// Add another.
var note2 = new CandidateNote {
Text = string.Format(NoteTextFormat, 2), RecruiterId = employer.Id, OrganisationId = employer.Organisation.Id
};
model = CreateNote(new[] { member0.Id, member1.Id }, note2.Text, true);
// Assert.
AssertJsonSuccess(model);
AssertNotes(employer, member0.Id, note1, note2);
AssertNotes(employer, member1.Id, note1, note2);
AssertModels(null, Notes(member0.Id), note2, note1);
AssertModels(null, Notes(member1.Id), note2, note1);
}
private void TestNote <T>(bool verified, int?credits, bool isShared)
where T : Credit
{
var member = _createMemberContactsCommand.CreateContact(1);
var noteCreator = _createEmployerContactsCommand.CreateContact(1, verified);
var noteReader = _createEmployerContactsCommand.CreateContact(2, noteCreator.Organisation);
// Allocate some credits.
if (credits != null)
{
_allocationsCommand.CreateAllocation(noteCreator.Id, new Allocation {
CreditId = _creditsCommand.GetCredit <T>().Id, Quantity = credits
});
}
_allocationsCommand.CreateAllocation(noteReader.Id, new Allocation {
CreditId = _creditsCommand.GetCredit <T>().Id
});
// Add one note.
const string text = "Here's a new note";
var note = new CandidateNote {
CandidateId = member.Id, Text = text
};
if (isShared)
{
_candidateNotesCommand.CreateSharedCandidateNote(noteCreator, note);
}
else
{
_candidateNotesCommand.CreateCandidateNote(noteCreator, note);
}
if (!isShared || credits != null)
{
AssertNote(true, note, noteCreator);
AssertNote(isShared, note, noteReader);
}
else
{
Assert.IsTrue(credits == null);
}
}
public void TestFilterHasNotes()
{
var member1 = CreateMember(1);
var member2 = CreateMember(2);
var employer = _employersCommand.CreateTestEmployer(1, _organisationsCommand.CreateTestOrganisation(1));
// Member1 has notes.
var note = new CandidateNote {
CandidateId = member1.Id, Text = "A note"
};
_candidateNotesCommand.CreatePrivateNote(employer, note);
// Filter.
TestFilter(employer, CreateHasNotesCriteria, new[] { member1.Id, member2.Id }, new[] { member1.Id }, new[] { member2.Id });
}
private static bool CanAccessNote(IEmployer employer, CandidateNote note)
{
if (employer == null || note == null)
{
return(false);
}
if (!note.IsShared)
{
// Must be the owner.
return(note.RecruiterId == employer.Id);
}
// Must belong to the same organisation.
return(note.OrganisationId == employer.Organisation.Id);
}
public void TestGetSharedNotes()
{
const int employerCount = 3;
var employers = new Employer[employerCount];
var organisation = _organisationsCommand.CreateTestVerifiedOrganisation(0);
for (var index = 0; index < employerCount; ++index)
{
employers[index] = _employerAccountsCommand.CreateTestEmployer(index, organisation);
}
// Create notes.
var member = _memberAccountsCommand.CreateTestMember(0);
const int noteCount = 8;
var notes = new CandidateNote[noteCount];
var createdBys = new Employer[noteCount];
for (var index = 0; index < noteCount; ++index)
{
var employer = employers[Random.Next(3)];
notes[index] = CreateNote(employer, member.Id, index);
createdBys[index] = employer;
}
foreach (var employer in employers)
{
LogIn(employer);
for (var index = 0; index < noteCount; ++index)
{
var model = Note(notes[index].Id);
AssertModel(employer == createdBys[index] ? null : createdBys[index], model, notes[index]);
}
var notesModel = Notes(member.Id);
Assert.AreEqual(notes.Length, notesModel.Notes.Count);
for (var index = 0; index < notes.Length; ++index)
{
AssertModel(employer == createdBys[index] ? null : createdBys[index], notesModel.Notes[index], notes[index]);
}
}
}
public void TestEditBoth()
{
// Create member.
var member = _memberAccountsCommand.CreateTestMember(0);
// Create notes.
var employer = _employerAccountsCommand.CreateTestEmployer(0, _organisationsCommand.CreateTestVerifiedOrganisation(0));
var note1 = new CandidateNote {
Text = string.Format(NoteTextFormat, 1), CandidateId = member.Id, CreatedTime = DateTime.Now.AddDays(-1)
};
_candidateNotesCommand.CreatePrivateNote(employer, note1);
var note2 = new CandidateNote {
Text = string.Format(NoteTextFormat, 2), CandidateId = member.Id, CreatedTime = DateTime.Now.AddDays(-2)
};
_candidateNotesCommand.CreatePrivateNote(employer, note2);
// Log in and edit tex.
LogIn(employer);
AssertModels(null, Notes(member.Id), note1, note2);
AssertModel(null, Note(note1.Id), note1);
AssertModel(null, Note(note2.Id), note2);
var newText = string.Format(NoteTextFormat, 3);
var model = EditNote(note1, newText, true);
note1.Text = newText;
note1.OrganisationId = employer.Organisation.Id;
// Assert.
AssertJsonSuccess(model);
AssertNotes(employer, member.Id, note1, note2);
AssertModels(null, Notes(member.Id), note1, note2);
AssertModel(null, Note(note1.Id), note1);
AssertModel(null, Note(note2.Id), note2);
}
public void TestFilterBlockHasNotes()
{
var member = CreateMember(1);
var employer = _employersCommand.CreateTestEmployer(1, _organisationsCommand.CreateTestOrganisation(1));
// Member has notes.
var note = new CandidateNote {
CandidateId = member.Id, Text = "A note"
};
_candidateNotesCommand.CreatePrivateNote(employer, note);
// Filter.
TestFilter(new[] { member.Id }, employer, CreateHasNotesCriteria(true));
// Block.
_candidateListsCommand.AddCandidateToBlockList(employer, _candidateBlockListsQuery.GetTemporaryBlockList(employer), member.Id);
TestFilter(new Guid[0], employer, CreateHasNotesCriteria(true));
}
public void TestMultipleMembersHaveNotes()
{
var employer0 = CreateEmployer(0);
var employer1 = CreateEmployer(1, employer0.Organisation);
var member0 = CreateMember(0);
var member1 = CreateMember(1);
var note = new CandidateNote {
CandidateId = member0.Id, Text = NoteText
};
_candidateNotesCommand.CreateSharedNote(employer0, note);
note = new CandidateNote {
CandidateId = member0.Id, Text = NoteText
};
_candidateNotesCommand.CreatePrivateNote(employer0, note);
note = new CandidateNote {
CandidateId = member1.Id, Text = NoteText
};
_candidateNotesCommand.CreatePrivateNote(employer0, note);
TestCount(employer0, member0.Id, 2, v => v.Notes);
TestCount(employer0, member1.Id, 1, v => v.Notes);
TestCount(employer1, member0.Id, 1, v => v.Notes);
TestCount(employer1, member1.Id, 0, v => v.Notes);
var views = _employerMemberViewsQuery.GetEmployerMemberViews(employer0, new[] { member0.Id, member1.Id });
Assert.AreEqual(2, views[member0.Id].Notes);
Assert.AreEqual(1, views[member1.Id].Notes);
views = _employerMemberViewsQuery.GetEmployerMemberViews(employer1, new[] { member0.Id, member1.Id });
Assert.AreEqual(1, views[member0.Id].Notes);
Assert.AreEqual(0, views[member1.Id].Notes);
}
void ICandidateNotesCommand.CreateSharedNote(IEmployer employer, CandidateNote note)
{
Prepare(employer, note, true);
_contenderNotesCommand.CreateNote(note);
}
public void TestOrganisationSharedNotes()
{
var member = _createMemberContactsCommand.CreateContact(1);
var noteCreator = _createEmployerContactsCommand.CreateContact(1, false);
_allocationsCommand.CreateAllocation(noteCreator.Id, new Allocation {
CreditId = _creditsCommand.GetCredit <ContactCredit>().Id, Quantity = 100
});
var organisation = noteCreator.Organisation;
var noteReader = _createEmployerContactsCommand.CreateContact(2, organisation);
_allocationsCommand.CreateAllocation(noteReader.Id, new Allocation {
CreditId = _creditsCommand.GetCredit <ApplicantCredit>().Id, Quantity = 100
});
// Create a private note and a shared note.
const string noteText1 = "Here's a new note";
var note1 = new CandidateNote {
CandidateId = member.Id, Text = noteText1
};
_candidateNotesCommand.CreateCandidateNote(noteCreator, note1);
NoteCreationDelay();
const string noteText2 = "A second note";
var note2 = new CandidateNote {
CandidateId = member.Id, Text = noteText2
};
_candidateNotesCommand.CreateSharedCandidateNote(noteCreator, note2);
// Check access.
AssertNote(true, note1, noteCreator);
AssertNote(false, note1, noteReader);
AssertNote(true, note2, noteCreator);
AssertNote(true, note2, noteReader);
// The note creator leaves the company, so they cannot access their own shared notes.
var otherOrganisation = new Organisation {
Name = "OtherOrganisation"
};
_organisationsCommand.CreateOrganisation(otherOrganisation);
_createEmployerContactsCommand.UpdateOrganisation(noteCreator, otherOrganisation);
// Check access.
AssertNote(true, note1, noteCreator);
AssertNote(false, note1, noteReader);
AssertNote(false, note2, noteCreator);
AssertNote(true, note2, noteReader);
// Create a private note while not part of the company.
const string noteText3 = "A third note";
var note3 = new CandidateNote {
CandidateId = member.Id, Text = noteText3
};
_candidateNotesCommand.CreateCandidateNote(noteCreator, note3);
AssertNote(true, note1, noteCreator);
AssertNote(false, note1, noteReader);
AssertNote(false, note2, noteCreator);
AssertNote(true, note2, noteReader);
AssertNote(true, note3, noteCreator);
AssertNote(false, note3, noteReader);
// Join again so can see original notes.
_createEmployerContactsCommand.UpdateOrganisation(noteCreator, organisation);
AssertNote(true, note1, noteCreator);
AssertNote(false, note1, noteReader);
AssertNote(true, note2, noteCreator);
AssertNote(true, note2, noteReader);
AssertNote(true, note3, noteCreator);
AssertNote(false, note3, noteReader);
// Change the latest note to shared, so now the second employer can see it.
_candidateNotesCommand.ShareCandidateNote(noteCreator, note3);
AssertNote(true, note1, noteCreator);
AssertNote(false, note1, noteReader);
AssertNote(true, note2, noteCreator);
AssertNote(true, note2, noteReader);
AssertNote(true, note3, noteCreator);
AssertNote(true, note3, noteReader);
// Make that note private once again.
_candidateNotesCommand.UnshareCandidateNote(noteCreator, note3);
AssertNote(true, note1, noteCreator);
AssertNote(false, note1, noteReader);
AssertNote(true, note2, noteCreator);
AssertNote(true, note2, noteReader);
AssertNote(true, note3, noteCreator);
AssertNote(false, note3, noteReader);
}
public void TestNoteOwner()
{
var member = _createMemberContactsCommand.CreateContact(1);
var noteCreator = _createEmployerContactsCommand.CreateContact(1, false);
_allocationsCommand.CreateAllocation(noteCreator.Id, new Allocation {
CreditId = _creditsCommand.GetCredit <ContactCredit>().Id, Quantity = 100
});
var noteReader = _createEmployerContactsCommand.CreateContact(2, noteCreator.Organisation);
_allocationsCommand.CreateAllocation(noteReader.Id, new Allocation {
CreditId = _creditsCommand.GetCredit <ApplicantCredit>().Id, Quantity = 100
});
// Add a private note.
const string noteText1 = "Here's a new note";
var note1 = new CandidateNote {
CandidateId = member.Id, Text = noteText1
};
_candidateNotesCommand.CreateCandidateNote(noteCreator, note1);
// Add a shared note.
NoteCreationDelay();
const string noteText2 = "A second note";
var note2 = new CandidateNote {
CandidateId = member.Id, Text = noteText2
};
_candidateNotesCommand.CreateSharedCandidateNote(noteCreator, note2);
AssertNote(true, note1, noteCreator);
AssertNote(false, note1, noteReader);
AssertNote(true, note2, noteCreator);
AssertNote(true, note2, noteReader);
// Try to update the first note text as the reader.
const string updatedText = "Updated first note";
var note = _candidateNotesCommand.GetCandidateNote(noteCreator, note1.Id);
note.Text = updatedText;
try
{
_candidateNotesCommand.UpdateCandidateNote(noteReader, note);
Assert.Fail();
}
catch (NoteOwnerPermissionsException)
{
}
AssertNote(true, note1, noteCreator);
AssertNote(false, note1, noteReader);
AssertNote(true, note2, noteCreator);
AssertNote(true, note2, noteReader);
// Try to update the second note text as the reader.
note = _candidateNotesCommand.GetCandidateNote(noteCreator, note2.Id);
note.Text = updatedText;
try
{
_candidateNotesCommand.UpdateCandidateNote(noteReader, note);
Assert.Fail();
}
catch (NoteOwnerPermissionsException)
{
}
AssertNote(true, note1, noteCreator);
AssertNote(false, note1, noteReader);
AssertNote(true, note2, noteCreator);
AssertNote(true, note2, noteReader);
// Try to delete the first note.
try
{
_candidateNotesCommand.DeleteCandidateNode(noteReader, note1.Id);
Assert.Fail();
}
catch (NoteOwnerPermissionsException)
{
}
AssertNote(true, note1, noteCreator);
AssertNote(false, note1, noteReader);
AssertNote(true, note2, noteCreator);
AssertNote(true, note2, noteReader);
// Try to delete the second note.
try
{
_candidateNotesCommand.DeleteCandidateNode(noteReader, note2.Id);
Assert.Fail();
}
catch (NoteOwnerPermissionsException)
{
}
AssertNote(true, note1, noteCreator);
AssertNote(false, note1, noteReader);
AssertNote(true, note2, noteCreator);
AssertNote(true, note2, noteReader);
}
private void TestNotes(bool isShared1, bool isShared2)
{
var member = _createMemberContactsCommand.CreateContact(1);
var noteCreator = _createEmployerContactsCommand.CreateContact(1, false);
_allocationsCommand.CreateAllocation(noteCreator.Id, new Allocation {
CreditId = _creditsCommand.GetCredit <ContactCredit>().Id, Quantity = 100
});
var noteReader = _createEmployerContactsCommand.CreateContact(2, noteCreator.Organisation);
_allocationsCommand.CreateAllocation(noteReader.Id, new Allocation {
CreditId = _creditsCommand.GetCredit <ApplicantCredit>().Id, Quantity = 100
});
// Add one note.
const string noteText1 = "Here's a new note";
var note1 = new CandidateNote {
CandidateId = member.Id, Text = noteText1
};
if (isShared1)
{
_candidateNotesCommand.CreateSharedCandidateNote(noteCreator, note1);
}
else
{
_candidateNotesCommand.CreateCandidateNote(noteCreator, note1);
}
AssertNote(true, note1, noteCreator);
AssertNote(isShared1, note1, noteReader);
// Add another note.
NoteCreationDelay();
const string noteText2 = "A second note";
var note2 = new CandidateNote {
CandidateId = member.Id, Text = noteText2
};
if (isShared2)
{
_candidateNotesCommand.CreateSharedCandidateNote(noteCreator, note2);
}
else
{
_candidateNotesCommand.CreateCandidateNote(noteCreator, note2);
}
AssertNote(true, note2, noteCreator);
AssertNote(isShared2, note2, noteReader);
// Check the order.
AssertNotes(noteCreator, member, note2, note1);
if (isShared1)
{
if (isShared2)
{
AssertNotes(noteReader, member, note2, note1);
}
else
{
AssertNotes(noteReader, member, note1);
}
}
else
{
if (isShared2)
{
AssertNotes(noteReader, member, note2);
}
else
{
AssertNotes(noteReader, member);
}
}
// Update the first note text.
NoteCreationDelay();
const string updatedText = "Updated first note";
note1.Text = updatedText;
_candidateNotesCommand.UpdateCandidateNote(noteCreator, note1);
AssertNote(true, note1, noteCreator);
AssertNote(isShared1, note1, noteReader);
AssertNote(true, note2, noteCreator);
AssertNote(isShared2, note2, noteReader);
// Order should be reversed now.
AssertNotes(noteCreator, member, note1, note2);
if (isShared1)
{
if (isShared2)
{
AssertNotes(noteReader, member, note1, note2);
}
else
{
AssertNotes(noteReader, member, note1);
}
}
else
{
if (isShared2)
{
AssertNotes(noteReader, member, note2);
}
else
{
AssertNotes(noteReader, member);
}
}
// Delete the first note.
_candidateNotesCommand.DeleteCandidateNode(noteCreator, note1.Id);
Assert.IsNull(_candidateNotesCommand.GetCandidateNote(noteCreator, note1.Id));
Assert.IsNull(_candidateNotesCommand.GetCandidateNote(noteReader, note1.Id));
AssertNote(true, note2, noteCreator);
AssertNote(isShared2, note2, noteReader);
AssertNotes(noteCreator, member, note2);
if (isShared2)
{
AssertNotes(noteReader, member, note2);
}
else
{
AssertNotes(noteReader, member);
}
}
void ICandidateNotesCommand.CreatePrivateNote(IEmployer employer, CandidateNote note)
{
Prepare(employer, note, false);
_contenderNotesCommand.CreateNote(note);
}
protected static void AssertModel(IEmployer createdBy, JsonNoteModel model, CandidateNote expectedNote)
{
AssertJsonSuccess(model);
AssertModel(createdBy, model.Note, expectedNote);
}
private static void Prepare(IEmployer employer, CandidateNote note, bool isShared)
{
note.RecruiterId = employer.Id;
note.OrganisationId = isShared ? employer.Organisation.Id : (Guid?)null;
}
bool ICandidateNotesCommand.CanDeleteNote(IEmployer employer, CandidateNote note)
{
// Same thing at the moment.
return(CanUpdateNote(employer, note));
}
bool ICandidateNotesCommand.CanUpdateNote(IEmployer employer, CandidateNote note)
{
return(CanUpdateNote(employer, note));
}
