private IMember GetMember(ParsedResume parsedResume)
{
var country = _locationQuery.GetCountry(Country);
return(new Member
{
Address = new Address {
Location = _locationQuery.ResolveLocation(country, parsedResume.Address.Location)
},
AffiliateId = null,
DateOfBirth = parsedResume.DateOfBirth,
EthnicStatus = Defaults.EthnicStatus,
FirstName = parsedResume.FirstName,
Gender = Defaults.Gender,
LastName = parsedResume.LastName,
EmailAddresses = parsedResume.EmailAddresses == null || parsedResume.EmailAddresses.Count == 0
? null
: (from e in parsedResume.EmailAddresses select new EmailAddress {
Address = e.Address, IsVerified = e.IsVerified
}).ToList(),
PhoneNumbers = parsedResume.PhoneNumbers == null || parsedResume.PhoneNumbers.Count == 0
? null
: (from p in parsedResume.PhoneNumbers select new PhoneNumber {
Number = p.Number, Type = p.Type
}).ToList(),
PhotoId = null,
VisibilitySettings = new VisibilitySettings(),
});
}
static TestBase()
{
Credentials data = JsonSerializer.Deserialize <Credentials>(File.ReadAllText("credentials.json"));
GeocodeCredentials = new GeocodeCredentials()
{
Provider = GeocodeProvider.Google,
ProviderKey = data.GeocodeProviderKey
};
Client = new SovrenClient(data.AccountId, data.ServiceKey, new DataCenter("https://rest-local.sovren.com", "v10", true));
ParseResumeResponseValue parseResumeResponseValue = Client.ParseResume(new ParseRequest(TestData.Resume)).Result.Value;
TestParsedResume = parseResumeResponseValue.ResumeData;
parseResumeResponseValue = Client.ParseResume(new ParseRequest(TestData.ResumeWithAddress)).Result.Value;
TestParsedResumeWithAddress = parseResumeResponseValue.ResumeData;
ParseJobResponseValue parseJobResponseValue = Client.ParseJob(new ParseRequest(TestData.JobOrder)).Result.Value;
TestParsedJob = parseJobResponseValue.JobData;
parseJobResponseValue = Client.ParseJob(new ParseRequest(TestData.JobOrderWithAddress)).Result.Value;
TestParsedJobWithAddress = parseJobResponseValue.JobData;
parseJobResponseValue = Client.ParseJob(new ParseRequest(TestData.JobOrderTech)).Result.Value;
TestParsedJobTech = parseJobResponseValue.JobData;
}
void IResumesRepository.CreateParsedResume(ParsedResume parsedResume)
{
using (var dc = CreateContext())
{
dc.ParsedResumeEntities.InsertOnSubmit(parsedResume.Map());
dc.SubmitChanges();
}
}
public void TestEmptyResume()
{
var parsedResume = new ParsedResume {
Id = Guid.NewGuid(), Resume = new Resume()
};
_parsedResumesCommand.CreateParsedResume(parsedResume);
AssertParsedResume(parsedResume, _resumesQuery.GetParsedResume(parsedResume.Id));
}
private static void AssertParsedResume(ParsedResume expectedParsedResume, ParsedResume parsedResume)
{
Assert.AreEqual(expectedParsedResume.FirstName, parsedResume.FirstName);
Assert.AreEqual(expectedParsedResume.LastName, parsedResume.LastName);
Assert.AreEqual(expectedParsedResume.Address, parsedResume.Address);
Assert.AreEqual(expectedParsedResume.DateOfBirth, parsedResume.DateOfBirth);
Assert.IsTrue(expectedParsedResume.PhoneNumbers.NullableCollectionEqual(parsedResume.PhoneNumbers));
Assert.IsTrue(expectedParsedResume.EmailAddresses.NullableCollectionEqual(parsedResume.EmailAddresses));
AssertResume(expectedParsedResume.Resume, parsedResume.Resume);
}
public void TestDeleteNoResume()
{
var parsedResume = new ParsedResume {
Id = Guid.NewGuid()
};
_parsedResumesCommand.CreateParsedResume(parsedResume);
AssertParsedResume(parsedResume, _resumesQuery.GetParsedResume(parsedResume.Id));
_parsedResumesCommand.DeleteParsedResume(parsedResume.Id);
Assert.IsNull(_resumesQuery.GetParsedResume(parsedResume.Id));
}
private static void Prepare(ParsedResume parsedResume)
{
if (parsedResume.Resume != null)
{
var now = DateTime.Now;
parsedResume.Resume.CreatedTime = now;
parsedResume.Resume.LastUpdatedTime = now;
}
if (parsedResume.Resume != null && parsedResume.Resume.IsEmpty)
{
parsedResume.Resume = null;
}
parsedResume.Prepare();
}
public void TestResume()
{
var other = string.Format(OtherFormat, 1);
var parsedResume = new ParsedResume {
Id = Guid.NewGuid(), Resume = new Resume {
Other = other
}
};
_parsedResumesCommand.CreateParsedResume(parsedResume);
AssertParsedResume(parsedResume, _resumesQuery.GetParsedResume(parsedResume.Id));
AssertResume(parsedResume.Resume, _resumesQuery.GetResume(parsedResume.Resume.Id));
}
/// <summary>
/// Create a Matching UI session to find matches for a non-indexed resume
/// </summary>
/// <param name="sovClient">The SovrenClient</param>
/// <param name="resume">The resume (generated by the Sovren Resume Parser) to use as the source for a match query</param>
/// <param name="indexesToQuery">The indexes to find results in. These must all be of the same type (resumes or jobs)</param>
/// <param name="preferredWeights">
/// The preferred category weights for scoring the results. If none are provided,
/// Sovren will determine the best values based on the source resume
/// </param>
/// <param name="filters">Any filters to apply prior to the match (a result must satisfy all the filters)</param>
/// <param name="settings">Settings for this match</param>
/// <param name="numResults">The number of results to show. If not specified, the default will be used.</param>
/// <exception cref="SovrenException">Thrown when an API error occurs</exception>
public static async Task <GenerateUIResponse> Match(
this SovrenClientWithUI sovClient,
ParsedResume resume,
IEnumerable <string> indexesToQuery,
CategoryWeights preferredWeights = null,
FilterCriteria filters = null,
SearchMatchSettings settings = null,
int numResults = 0)
{
MatchResumeRequest request = sovClient.InternalClient.CreateRequest(resume, indexesToQuery, preferredWeights, filters, settings, numResults);
UIMatchResumeRequest uiRequest = new UIMatchResumeRequest(request, sovClient.UISessionOptions);
return(await sovClient.InternalClient.UIMatch(uiRequest));
}
public static ParsedResumeEntity Map(this ParsedResume parsedResume)
{
var entity = new ParsedResumeEntity
{
id = parsedResume.Id,
firstName = parsedResume.FirstName,
lastName = parsedResume.LastName,
street = parsedResume.Address == null ? null : parsedResume.Address.Street,
location = parsedResume.Address == null ? null : parsedResume.Address.Location,
ResumeEntity = parsedResume.Resume == null ? null : parsedResume.Resume.Map()
};
parsedResume.MapTo((IHavePhoneNumbersEntity)entity);
parsedResume.MapTo((IHaveEmailAddressesEntity)entity);
parsedResume.DateOfBirth.MapTo(entity);
return(entity);
}
private Member CreateMember(string firstName, string lastName, ParsedResume parsedResume)
{
return(new Member
{
FirstName = firstName,
LastName = lastName,
IsEnabled = true,
VisibilitySettings = new VisibilitySettings(),
Address = new Address
{
Location = _locationQuery.ResolveLocation(_locationQuery.GetCountry("Australia"), parsedResume.Address.Location),
},
EmailAddresses = (from e in parsedResume.EmailAddresses select new EmailAddress {
Address = e.Address, IsVerified = e.IsVerified
}).ToList(),
PhoneNumbers = (from p in parsedResume.PhoneNumbers select new PhoneNumber {
Number = p.Number, Type = p.Type
}).ToList(),
});
}
public static ParsedResume Map(this ParsedResumeEntity entity)
{
var parsedResume = new ParsedResume
{
Id = entity.id,
FirstName = entity.firstName,
LastName = entity.lastName,
Address = string.IsNullOrEmpty(entity.street) && string.IsNullOrEmpty(entity.location)
? null
: new ParsedAddress {
Street = entity.street, Location = entity.location
},
DateOfBirth = ((IHavePartialDateEntity)entity).Map(),
Resume = entity.ResumeEntity == null ? null : entity.ResumeEntity.Map()
};
entity.MapTo((IHavePhoneNumbers)parsedResume);
entity.MapTo((IHaveEmailAddresses)parsedResume);
return(parsedResume);
}
void IParsedResumesCommand.CreateParsedResume(ParsedResume parsedResume)
{
Prepare(parsedResume);
parsedResume.Validate();
_repository.CreateParsedResume(parsedResume);
}
private static void AssertParsedResume(ParsedResume expectedParsedResume, ParsedResume parsedResume)
{
Assert.AreEqual(expectedParsedResume.FirstName, parsedResume.FirstName);
Assert.AreEqual(expectedParsedResume.LastName, parsedResume.LastName);
Assert.AreEqual(expectedParsedResume.Address, parsedResume.Address);
Assert.AreEqual(expectedParsedResume.DateOfBirth, parsedResume.DateOfBirth);
Assert.AreEqual(expectedParsedResume.Resume.Skills, parsedResume.Resume.Skills);
Assert.AreEqual(expectedParsedResume.Resume.Objective, parsedResume.Resume.Objective);
Assert.AreEqual(expectedParsedResume.Resume.Summary, parsedResume.Resume.Summary);
Assert.AreEqual(expectedParsedResume.Resume.Other, parsedResume.Resume.Other);
Assert.AreEqual(expectedParsedResume.Resume.Citizenship, parsedResume.Resume.Citizenship);
Assert.AreEqual(expectedParsedResume.Resume.Affiliations, parsedResume.Resume.Affiliations);
Assert.AreEqual(expectedParsedResume.Resume.Professional, parsedResume.Resume.Professional);
Assert.AreEqual(expectedParsedResume.Resume.Interests, parsedResume.Resume.Interests);
Assert.AreEqual(expectedParsedResume.Resume.Referees, parsedResume.Resume.Referees);
Assert.IsTrue(expectedParsedResume.EmailAddresses.NullableCollectionEqual(parsedResume.EmailAddresses));
Assert.IsTrue(expectedParsedResume.PhoneNumbers.NullableCollectionEqual(parsedResume.PhoneNumbers));
if (expectedParsedResume.Resume.Courses == null)
{
Assert.IsNull(parsedResume.Resume.Courses);
}
else
{
Assert.AreEqual(expectedParsedResume.Resume.Courses.Count, parsedResume.Resume.Courses.Count);
for (var index = 0; index < expectedParsedResume.Resume.Courses.Count; ++index)
{
Assert.AreEqual(expectedParsedResume.Resume.Courses[index], parsedResume.Resume.Courses[index]);
}
}
if (expectedParsedResume.Resume.Awards == null)
{
Assert.IsNull(parsedResume.Resume.Awards);
}
else
{
Assert.AreEqual(expectedParsedResume.Resume.Awards.Count, parsedResume.Resume.Awards.Count);
for (var index = 0; index < expectedParsedResume.Resume.Awards.Count; ++index)
{
Assert.AreEqual(expectedParsedResume.Resume.Awards[index], parsedResume.Resume.Awards[index]);
}
}
if (expectedParsedResume.Resume.Schools == null)
{
Assert.IsNull(parsedResume.Resume.Schools);
}
else
{
Assert.AreEqual(expectedParsedResume.Resume.Schools.Count, parsedResume.Resume.Schools.Count);
for (var index = 0; index < expectedParsedResume.Resume.Schools.Count; ++index)
{
AssertSchool(expectedParsedResume.Resume.Schools[index], parsedResume.Resume.Schools[index]);
}
}
if (expectedParsedResume.Resume.Jobs == null)
{
Assert.IsNull(parsedResume.Resume.Jobs);
}
else
{
Assert.AreEqual(expectedParsedResume.Resume.Jobs.Count, parsedResume.Resume.Jobs.Count);
for (var index = 0; index < expectedParsedResume.Resume.Jobs.Count; ++index)
{
AssertJob(expectedParsedResume.Resume.Jobs[index], parsedResume.Resume.Jobs[index]);
}
}
}
/// <summary>
/// Save the resume to disk using UTF-8 encoding
/// </summary>
/// <param name="exts"></param>
/// <param name="piiRedacted"><see langword="true"/> to save the redacted version of the resume, otherwise <see langword="false"/></param>
/// <param name="filePath">The file to save to</param>
/// <param name="formatted"><see langword="true"/> for pretty-printing</param>
public static void SaveResumeJsonToFile(this ParseResumeResponseExtensions exts, string filePath, bool formatted, bool piiRedacted)
{
ParsedResume resume = piiRedacted ? exts.Response?.Value?.RedactedResumeData : exts.Response?.Value?.ResumeData;
resume?.ToFile(filePath, formatted);
}
/// <summary>
/// Use this to get the resume as a JSON string (to save to disk or other data storage).
/// <br/>NOTE: be sure to save with UTF-8 encoding!
/// </summary>
/// <param name="exts"></param>
/// <param name="piiRedacted"><see langword="true"/> for the redacted version of the resume, otherwise <see langword="false"/></param>
/// <param name="formatted"><see langword="true"/> for pretty-printing</param>
public static string GetResumeAsJsonString(this ParseResumeResponseExtensions exts, bool formatted, bool piiRedacted)
{
ParsedResume resume = piiRedacted ? exts.Response?.Value?.RedactedResumeData : exts.Response?.Value?.ResumeData;
return(resume?.ToJson(formatted));
}
public async Task TestResumeLifeCycle()
{
const string documentId = "1";
try
{
// verify can't retrieve a document that doesn't exist
SovrenException sovrenException = Assert.ThrowsAsync <SovrenException>(async() => {
await Client.GetResume(resumeIndexId, documentId);
});
Assert.AreEqual(SovrenErrorCodes.DataNotFound, sovrenException.SovrenErrorCode);
// verify can't add document to an index that doesn't exist
sovrenException = Assert.ThrowsAsync <SovrenException>(async() => {
await Client.IndexDocument(TestParsedResume, resumeIndexId, documentId);
});
Assert.AreEqual(SovrenErrorCodes.DataNotFound, sovrenException.SovrenErrorCode);
// create the index
await Client.CreateIndex(IndexType.Resume, resumeIndexId);
await DelayForIndexSync();
// verify document still doesn't exist
sovrenException = Assert.ThrowsAsync <SovrenException>(async() => {
await Client.GetResume(resumeIndexId, documentId);
});
Assert.AreEqual(SovrenErrorCodes.DataNotFound, sovrenException.SovrenErrorCode);
// add resume to index
await Client.IndexDocument(TestParsedResume, resumeIndexId, documentId);
await DelayForIndexSync();
// confirm you can now retrieve the resume
await Client.GetResume(resumeIndexId, documentId);
// confirm the resume shows up in searches
List <string> indexesToQuery = new List <string>()
{
resumeIndexId
};
FilterCriteria filterCriteria = new FilterCriteria()
{
DocumentIds = new List <string>()
{
documentId
}
};
SearchResponseValue searchResponse = Client.Search(indexesToQuery, filterCriteria).Result.Value;
Assert.AreEqual(1, searchResponse.TotalCount);
Assert.AreEqual(1, searchResponse.CurrentCount);
Assert.AreEqual(documentId, searchResponse.Matches[0].Id);
// update the resume
List <string> userDefinedTags = new List <string> {
"userDefinedTag1"
};
await Client.UpdateResumeUserDefinedTags(resumeIndexId, documentId,
userDefinedTags, UserDefinedTagsMethod.Overwrite);
await DelayForIndexSync();
// verify those updates have taken effect
filterCriteria.UserDefinedTags = userDefinedTags;
searchResponse = Client.Search(indexesToQuery, filterCriteria).Result.Value;
Assert.AreEqual(1, searchResponse.TotalCount);
Assert.AreEqual(1, searchResponse.CurrentCount);
Assert.AreEqual(documentId, searchResponse.Matches[0].Id);
// confirm you can retrieve the tags
ParsedResume resume = Client.GetResume(resumeIndexId, documentId).Result.Value;
Assert.AreEqual(1, resume.UserDefinedTags.Count);
Assert.AreEqual(userDefinedTags[0], resume.UserDefinedTags[0]);
// delete the document
await Client.DeleteDocument(resumeIndexId, documentId);
await DelayForIndexSync();
// verify can't retrieve a document that doesn't exist
sovrenException = Assert.ThrowsAsync <SovrenException>(async() => {
await Client.GetResume(resumeIndexId, documentId);
});
Assert.AreEqual(SovrenErrorCodes.DataNotFound, sovrenException.SovrenErrorCode);
sovrenException = Assert.ThrowsAsync <SovrenException>(async() => {
await Client.DeleteDocument(resumeIndexId, documentId);
});
Assert.AreEqual(SovrenErrorCodes.DataNotFound, sovrenException.SovrenErrorCode);
await Client.DeleteIndex(resumeIndexId);
await DelayForIndexSync();
sovrenException = Assert.ThrowsAsync <SovrenException>(async() => {
await Client.DeleteDocument(resumeIndexId, documentId);
});
Assert.AreEqual(SovrenErrorCodes.DataNotFound, sovrenException.SovrenErrorCode);
}
catch (Exception) { throw; }
finally
{
await CleanUpIndex(resumeIndexId);
}
}
/// <summary>
/// Creates a request to call the Resume Formatter endpoint.
/// </summary>
/// <param name="resume">
/// Either<see cref="ParseResumeResponseValue.ResumeData"/> to include the candidate's personal information or
/// <see cref="ParseResumeResponseValue.RedactedResumeData"/> to exclude it.
/// <param name="docType">The output document type</param>
/// </param>
public FormatResumeRequest(ParsedResume resume, ResumeType docType)
{
ResumeData = resume;
Options.OutputType = docType;
}
