/// <summary>Gets the primary entity metadata.</summary>
/// <param name="context">The context.</param>
/// <param name="result">The result.</param>
/// <param name="request">The request.</param>
/// <returns>The primary entity metadata.</returns>
public override IEntityMetadata GetPrimaryEntityMetadata(ExecutionContext context,
IExternalSearchQueryResult result,
IExternalSearchRequest request)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (result == null)
{
throw new ArgumentNullException(nameof(result));
}
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
using (context.Log.BeginScope("{0} {1}: request {2}, result {3}", GetType().Name, "GetPrimaryEntityMetadata", request, result))
{
var metadata = CreateMetadata(result.As <VatLayerResponse>());
context.Log.LogInformation("Primary entity meta data created, Name: '{Name}' OriginEntityCode: '{OriginEntityCode}'", metadata.Name, metadata.OriginEntityCode.Origin.Code);
return(metadata);
}
}
/// <summary>Builds the clues.</summary>
/// <param name="context">The context.</param>
/// <param name="query">The query.</param>
/// <param name="result">The result.</param>
/// <param name="request">The request.</param>
/// <returns>The clues.</returns>
public override IEnumerable <Clue> BuildClues(ExecutionContext context,
IExternalSearchQuery query,
IExternalSearchQueryResult result,
IExternalSearchRequest request)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (query == null)
{
throw new ArgumentNullException(nameof(query));
}
if (result == null)
{
throw new ArgumentNullException(nameof(result));
}
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
using (context.Log.BeginScope("{0} {1}: query {2}, request {3}, result {4}", GetType().Name, "BuildClues", query, request, result))
{
var resultItem = result.As <VatLayerResponse>();
var dirtyClue = request.CustomQueryInput.ToString();
var code = GetOriginEntityCode(resultItem);
var clue = new Clue(code, context.Organization);
if (!string.IsNullOrEmpty(dirtyClue))
{
clue.Data.EntityData.Codes.Add(new EntityCode(EntityType.Organization, CodeOrigin.CluedIn.CreateSpecific("vatlayer"), dirtyClue));
}
PopulateMetadata(clue.Data.EntityData, resultItem);
context.Log.LogInformation("Clue produced, Id: '{Id}' OriginEntityCode: '{OriginEntityCode}' RawText: '{RawText}'", clue.Id, clue.OriginEntityCode, clue.RawText);
return(new[] { clue });
}
}
/**********************************************************************************************************
* METHODS
**********************************************************************************************************/
/// <summary>Builds the queries.</summary>
/// <param name="context">The context.</param>
/// <param name="request">The request.</param>
/// <returns>The search queries.</returns>
public override IEnumerable <IExternalSearchQuery> BuildQueries(ExecutionContext context, IExternalSearchRequest request)
{
if (!Accepts(request.EntityMetaData.EntityType))
{
yield break;
}
//var existingResults = request.GetQueryResults<LibpostalResponse>(this).ToList();
//bool filter(string value)
//{
// return existingResults.Any(r => string.Equals(r.Data.response., value, StringComparison.InvariantCultureIgnoreCase));
//}
var entityType = request.EntityMetaData.EntityType;
var personAddress = request.QueryParameters.GetValue(Core.Data.Vocabularies.Vocabularies.CluedInPerson.HomeAddress, new HashSet <string>());
var organizationAddress = request.QueryParameters.GetValue(Core.Data.Vocabularies.Vocabularies.CluedInOrganization.Address, new HashSet <string>());
var userAddress = request.QueryParameters.GetValue(Core.Data.Vocabularies.Vocabularies.CluedInUser.HomeAddress, new HashSet <string>());
var locationAddress = request.QueryParameters.GetValue(Core.Data.Vocabularies.Vocabularies.CluedInLocation.Address, new HashSet <string>());
if (personAddress != null && personAddress.Count > 0)
{
foreach (var item in personAddress)
{
var queryBody = new Dictionary <string, string>
{
{ "body", item }
};
yield return(new ExternalSearchQuery(this, entityType, queryBody));
}
}
if (organizationAddress != null && organizationAddress.Count > 0)
{
foreach (var item in organizationAddress)
{
var queryBody = new Dictionary <string, string>
{
{ "body", item }
};
yield return(new ExternalSearchQuery(this, entityType, queryBody));
}
}
if (userAddress != null && userAddress.Count > 0)
{
foreach (var item in userAddress)
{
var queryBody = new Dictionary <string, string>
{
{ "body", item }
};
yield return(new ExternalSearchQuery(this, entityType, queryBody));
}
}
if (locationAddress != null && locationAddress.Count > 0)
{
foreach (var item in locationAddress)
{
var queryBody = new Dictionary <string, string>
{
{ "body", item }
};
yield return(new ExternalSearchQuery(this, entityType, queryBody));
}
}
}
public IPreviewImage GetPrimaryEntityPreviewImage(ExecutionContext context, IExternalSearchQueryResult result, IExternalSearchRequest request, IDictionary <string, object> config, IProvider provider)
{
return(GetPrimaryEntityPreviewImage(context, result, request));
}
public IEnumerable <IExternalSearchQuery> BuildQueries(ExecutionContext context, IExternalSearchRequest request, IDictionary <string, object> config, IProvider provider)
{
return(BuildQueries(context, request));
}
/// <summary>Gets the primary entity metadata.</summary>
/// <param name="context">The context.</param>
/// <param name="result">The result.</param>
/// <param name="request">The request.</param>
/// <returns>The primary entity metadata.</returns>
public override IEntityMetadata GetPrimaryEntityMetadata(ExecutionContext context, IExternalSearchQueryResult result, IExternalSearchRequest request)
{
var resultItem = result.As <CompanyNew>();
return(CreateMetadata(resultItem));
}
/// <inheritdoc/>
public override IEnumerable <IExternalSearchQuery> BuildQueries(ExecutionContext context, IExternalSearchRequest request)
{
if (!Accepts(request.EntityMetaData.EntityType))
{
yield break;
}
// Query Input
var entityType = request.EntityMetaData.EntityType;
var address = request.QueryParameters.GetValue(CluedIn.Core.Data.Vocabularies.Vocabularies.CluedInOrganization.Address, new HashSet <string>());
if (address != null)
{
var values = address.GetOrganizationNameVariants().Select(NameNormalization.Normalize).ToHashSet();
foreach (var value in values)
{
yield return(new ExternalSearchQuery(this, entityType, ExternalSearchQueryParameter.Name, value));
}
}
}
/// <summary>Creates the metadata.</summary>
/// <param name="resultItem">The result item.</param>
/// <returns>The metadata.</returns>
private IEntityMetadata CreateMetadata(IExternalSearchQueryResult <Result> resultItem, IExternalSearchRequest request)
{
if (resultItem == null)
{
throw new ArgumentNullException(nameof(resultItem));
}
var metadata = new EntityMetadataPart();
PopulateMetadata(metadata, resultItem, request);
return(metadata);
}
/// <inheritdoc/>
public override IEnumerable <Clue> BuildClues(ExecutionContext context, IExternalSearchQuery query, IExternalSearchQueryResult result, IExternalSearchRequest request)
{
var resultItem = result.As <Result>();
string id;
if (request.QueryParameters.ContainsKey(Core.Data.Vocabularies.Vocabularies.CluedInOrganization.CodesCVR))
{
id = request.QueryParameters.GetValue(Core.Data.Vocabularies.Vocabularies.CluedInOrganization.CodesCVR).FirstOrDefault();
}
else
{
id = resultItem.Data.ActualAddress.AccessAddressId;
}
var code = new EntityCode(EntityType.Organization, CodeOrigin.CluedIn, id);
var clue = new Clue(code, context.Organization);
clue.Data.OriginProviderDefinitionId = Id;
PopulateMetadata(clue.Data.EntityData, resultItem, request);
yield return(clue);
}
/// <summary>Builds the clues.</summary>
/// <param name="context">The context.</param>
/// <param name="query">The query.</param>
/// <param name="result">The result.</param>
/// <param name="request">The request.</param>
/// <returns>The clues.</returns>
public override IEnumerable <Clue> BuildClues(ExecutionContext context, IExternalSearchQuery query, IExternalSearchQueryResult result, IExternalSearchRequest request)
{
var resultItem = result.As <Person>();
var code = this.GetOriginEntityCode(resultItem);
var clue = new Clue(code, context.Organization);
clue.Data.OriginProviderDefinitionId = this.Id;
this.PopulateMetadata(clue.Data.EntityData, resultItem);
this.DownloadPreviewImage(context, resultItem.Data.avatar, clue);
return(new[] { clue });
}
private IEnumerable <IExternalSearchQuery> InternalBuildQueries(ExecutionContext context, IExternalSearchRequest request, string apiToken)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
using (context.Log.BeginScope($"{GetType().Name} BuildQueries: request {request}"))
{
if (string.IsNullOrEmpty(apiToken))
{
context.Log.LogError("ApiToken for VatLayer must be provided.");
yield break;
}
if (!Accepts(request.EntityMetaData.EntityType))
{
context.Log.LogTrace("Unacceptable entity type from '{EntityName}', entity code '{EntityCode}'", request.EntityMetaData.DisplayName, request.EntityMetaData.EntityType.Code);
yield break;
}
context.Log.LogTrace("Starting to build queries for {EntityName}", request.EntityMetaData.DisplayName);
var existingResults = request.GetQueryResults <VatLayerResponse>(this).ToList();
bool vatFilter(string value) => existingResults.Any(r => string.Equals(r.Data.VatNumber, value, StringComparison.InvariantCultureIgnoreCase));
var entityType = request.EntityMetaData.EntityType;
var vatNumber = request.QueryParameters.GetValue(Core.Data.Vocabularies.Vocabularies.CluedInOrganization.VatNumber, new HashSet <string>());
if (!vatNumber.Any())
{
context.Log.LogTrace("No query parameter for '{VatNumber}' in request, skipping build queries", Core.Data.Vocabularies.Vocabularies.CluedInOrganization.VatNumber);
}
else
{
var filteredValues = vatNumber.Where(v => !vatFilter(v)).ToArray();
if (!filteredValues.Any())
{
context.Log.LogWarning("Filter removed all VAT numbers, skipping processing. Original '{Original}'", string.Join(",", vatNumber));
}
else
{
foreach (var value in filteredValues)
{
request.CustomQueryInput = vatNumber.ElementAt(0);
var cleaner = new VatNumberCleaner();
var sanitizedValue = cleaner.CheckVATNumber(value);
if (value != sanitizedValue)
{
context.Log.LogTrace("Sanitized VAT number. Original '{OriginalValue}', Updated '{SanitizedValue}'", value, sanitizedValue);
}
context.Log.LogInformation("External search query produced, ExternalSearchQueryParameter: '{Identifier}' EntityType: '{EntityCode}' Value: '{SanitizedValue}'", ExternalSearchQueryParameter.Identifier, entityType.Code, sanitizedValue);
yield return(new ExternalSearchQuery(this, entityType, ExternalSearchQueryParameter.Identifier, sanitizedValue));
}
}
context.Log.LogTrace("Finished building queries for '{Name}'", request.EntityMetaData.Name);
}
}
}
/**********************************************************************************************************
* METHODS
**********************************************************************************************************/
/// <summary>Builds the queries.</summary>
/// <param name="context">The context.</param>
/// <param name="request">The request.</param>
/// <returns>The search queries.</returns>
public override IEnumerable <IExternalSearchQuery> BuildQueries(ExecutionContext context, IExternalSearchRequest request)
{
var apiToken = TokenProvider?.ApiToken;
foreach (var externalSearchQuery in InternalBuildQueries(context, request, apiToken))
{
yield return(externalSearchQuery);
}
}
public IEnumerable <IExternalSearchQuery> BuildQueries(ExecutionContext context, IExternalSearchRequest request, IDictionary <string, object> config, IProvider provider)
{
var jobData = new VatLayerExternalSearchJobData(config);
foreach (var externalSearchQuery in InternalBuildQueries(context, request, jobData.ApiToken))
{
yield return(externalSearchQuery);
}
}
/// <summary>Gets the preview image.</summary>
/// <param name="context">The context.</param>
/// <param name="result">The result.</param>
/// <param name="request">The request.</param>
/// <returns>The preview image.</returns>
public override IPreviewImage GetPrimaryEntityPreviewImage(ExecutionContext context, IExternalSearchQueryResult result, IExternalSearchRequest request)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (result == null)
{
throw new ArgumentNullException(nameof(result));
}
using (context.Log.BeginScope("{0} {1}: request {2}, result {3}", GetType().Name, "GetPrimaryEntityPreviewImage", request, result))
{
context.Log.LogInformation("Primary entity preview image not produced, returning null");
return(null);
}
}
/// <inheritdoc/>
public override IEntityMetadata GetPrimaryEntityMetadata(ExecutionContext context, IExternalSearchQueryResult result, IExternalSearchRequest request)
{
var resultItem = result.As <PermIdSocialResponse>();
if (resultItem == null)
{
return(null);
}
return(this.CreateMetadata(resultItem));
}
/// <summary>Gets the preview image.</summary>
/// <param name="context">The context.</param>
/// <param name="result">The result.</param>
/// <param name="request">The request.</param>
/// <returns>The preview image.</returns>
public override IPreviewImage GetPrimaryEntityPreviewImage(ExecutionContext context, IExternalSearchQueryResult result, IExternalSearchRequest request)
{
return(this.DownloadPreviewImageBlob <Person>(context, result, r => r.Data.avatar));
}
/**********************************************************************************************************
* METHODS
**********************************************************************************************************/
/// <inheritdoc/>
public override IEnumerable <IExternalSearchQuery> BuildQueries(ExecutionContext context, IExternalSearchRequest request)
{
if (!this.Accepts(request.EntityMetaData.EntityType))
{
yield break;
}
//if (string.IsNullOrEmpty(this.TokenProvider.ApiToken))
// throw new InvalidOperationException("PermId ApiToken have not been configured");
var existingResults = request.GetQueryResults <PermIdSocialResponse>(this).ToList();
Func <string, bool> existingDataFilter = value => existingResults.Any(r => string.Equals(r.Data.OrganizationName.First(), value, StringComparison.InvariantCultureIgnoreCase));
Func <string, bool> nameFilter = value => OrganizationFilters.NameFilter(context, value) || existingResults.Any(r => string.Equals(r.Data.OrganizationName.First(), value, StringComparison.InvariantCultureIgnoreCase));
// Query Input
var entityType = request.EntityMetaData.EntityType;
var organizationName = request.QueryParameters.GetValue(CluedIn.Core.Data.Vocabularies.Vocabularies.CluedInOrganization.OrganizationName, new HashSet <string>());
if (!string.IsNullOrEmpty(request.EntityMetaData.Name))
{
organizationName.Add(request.EntityMetaData.Name);
}
if (!string.IsNullOrEmpty(request.EntityMetaData.DisplayName))
{
organizationName.Add(request.EntityMetaData.DisplayName);
}
if (organizationName != null)
{
var values = organizationName.GetOrganizationNameVariants()
.Select(NameNormalization.Normalize)
.ToHashSetEx();
foreach (var value in values)
{
if (existingDataFilter(value) || nameFilter(value))
{
continue;
}
yield return(new ExternalSearchQuery(this, entityType, ExternalSearchQueryParameter.Name, value));
}
}
}
/**********************************************************************************************************
* METHODS
**********************************************************************************************************/
/// <summary>Builds the queries.</summary>
/// <param name="context">The context.</param>
/// <param name="request">The request.</param>
/// <returns>The search queries.</returns>
public override IEnumerable <IExternalSearchQuery> BuildQueries(ExecutionContext context, IExternalSearchRequest request)
{
yield break;
#region TODO ClearBitEmployeeExternalSearchProvider.BuildQueries(ExecutionContext context, IExternalSearchRequest request) is disabled in code ... review
//if (!this.Accepts(request.EntityMetaData.EntityType))
// yield break;
//var existingResults = request.GetQueryResults<Person>(this).ToList();
//Func<string, bool> domainFilter = value => existingResults.Any(r => string.Equals(r.Data.id, value, StringComparison.InvariantCultureIgnoreCase));
//// Query Input
//var entityType = request.EntityMetaData.EntityType;
//var website = request.QueryParameters.GetValue(CluedIn.Core.Data.Vocabularies.Vocabularies.CluedInOrganization.Website, null);
//var emailDomainNames = request.QueryParameters.GetValue(CluedIn.Core.Data.Vocabularies.Vocabularies.CluedInOrganization.EmailDomainNames, null);
//if (website != null)
//{
// var values = website;
// foreach (var value in values)
// {
// Uri uri;
// if (Uri.TryCreate(value, UriKind.Absolute, out uri) && !domainFilter(uri.Host))
// yield return new ExternalSearchQuery(this, entityType, ExternalSearchQueryParameter.Name, uri.Host);
// else if (!domainFilter(value))
// yield return new ExternalSearchQuery(this, entityType, ExternalSearchQueryParameter.Name, value);
// }
//}
//else if (emailDomainNames != null)
//{
// var values = emailDomainNames.SelectMany(v => v.Split(new[] { ",", ";", "|" }, StringSplitOptions.RemoveEmptyEntries)).ToHashSet();
// foreach (var value in values.Where(v => !domainFilter(v)))
// yield return new ExternalSearchQuery(this, entityType, ExternalSearchQueryParameter.Name, value);
//}
#endregion
}
/// <inheritdoc/>
public override IEntityMetadata GetPrimaryEntityMetadata(ExecutionContext context, IExternalSearchQueryResult result, IExternalSearchRequest request)
{
var resultItem = result.As <Result>();
if (resultItem == null)
{
return(null);
}
return(CreateMetadata(resultItem, request));
}
/// <summary>Gets the primary entity metadata.</summary>
/// <param name="context">The context.</param>
/// <param name="result">The result.</param>
/// <param name="request">The request.</param>
/// <returns>The primary entity metadata.</returns>
public override IEntityMetadata GetPrimaryEntityMetadata(ExecutionContext context, IExternalSearchQueryResult result, IExternalSearchRequest request)
{
var resultItem = result.As <MappingResponse>();
return(this.CreateMetadata(resultItem));
}
/// <summary>Populates the metadata.</summary>
/// <param name="metadata">The metadata.</param>
/// <param name="resultItem">The result item.</param>
private void PopulateMetadata(IEntityMetadata metadata, IExternalSearchQueryResult <Result> resultItem, IExternalSearchRequest request)
{
if (resultItem == null)
{
throw new ArgumentNullException(nameof(resultItem));
}
var code = GetOriginEntityCode(resultItem);
var data = resultItem.Data;
metadata.Name = request.QueryParameters.GetValue(Core.Data.Vocabularies.Vocabularies.CluedInOrganization.OrganizationName, new HashSet <string>()).FirstOrDefault();
metadata.EntityType = EntityType.Organization;
metadata.CreatedDate = resultItem.CreatedDate;
metadata.OriginEntityCode = code;
metadata.Codes.Add(code);
metadata.Properties[DamaVocabularies.Organization.AdressingStreetName] = data.ActualAddress.AdressingStreetName.PrintIfAvailable();
metadata.Properties[DamaVocabularies.Organization.Door] = data.ActualAddress.Door.PrintIfAvailable();
metadata.Properties[DamaVocabularies.Organization.Floor] = data.ActualAddress.Floor.PrintIfAvailable();
metadata.Properties[DamaVocabularies.Organization.HouseNumber] = data.ActualAddress.HouseNumber.PrintIfAvailable();
metadata.Properties[DamaVocabularies.Organization.Id] = data.ActualAddress.Id.PrintIfAvailable();
metadata.Properties[DamaVocabularies.Organization.Zipcode] = data.ActualAddress.Zipcode.PrintIfAvailable();
metadata.Properties[DamaVocabularies.Organization.ZipcodeName] = data.ActualAddress.Zipcodename.PrintIfAvailable();
metadata.Properties[DamaVocabularies.Organization.Status] = data.ActualAddress.Status.PrintIfAvailable();
metadata.Properties[DamaVocabularies.Organization.AdditionalCityName] = data.ActualAddress.AdditionalCityName.PrintIfAvailable();
metadata.Properties[DamaVocabularies.Organization.StreetName] = data.ActualAddress.StreetName.PrintIfAvailable();
metadata.Properties[DamaVocabularies.Organization.EffectiveEnd] = data.ActualAddress.EffectiveEnd.PrintIfAvailable();
metadata.Properties[DamaVocabularies.Organization.EffectiveStart] = data.ActualAddress.EffectiveStart.PrintIfAvailable();
metadata.Uri = new Uri(data.ActualAddress.Href);
}
/**********************************************************************************************************
* METHODS
**********************************************************************************************************/
/// <summary>Builds the queries.</summary>
/// <param name="context">The context.</param>
/// <param name="request">The request.</param>
/// <returns>The search queries.</returns>
public override IEnumerable <IExternalSearchQuery> BuildQueries(ExecutionContext context, IExternalSearchRequest request)
{
if (!this.Accepts(request.EntityMetaData.EntityType))
{
yield break;
}
var existingResults = request.GetQueryResults <MappingResponse>(this).ToList();
Func <string, bool> nameFilter = value => OrganizationFilters.NameFilter(context, value) || existingResults.Any(r => string.Equals(r.Data.Response.Name, value, StringComparison.InvariantCultureIgnoreCase));
// Query Input
//For companies use CluedInOrganization vocab, for people use CluedInPerson and so on for different types.
var entityType = request.EntityMetaData.EntityType;
var organizationTicker = request.QueryParameters.GetValue(CluedIn.Core.Data.Vocabularies.Vocabularies.CluedInOrganization.TickerSymbol, new HashSet <string>());
if (organizationTicker != null)
{
var values = organizationTicker.Select(NameNormalization.Normalize).ToHashSet();
foreach (var value in values.Where(v => !nameFilter(v)))
{
yield return(new ExternalSearchQuery(this, entityType, ExternalSearchQueryParameter.Identifier, value));
}
}
}
/// <summary>Builds the clues.</summary>
/// <param name="context">The context.</param>
/// <param name="query">The query.</param>
/// <param name="result">The result.</param>
/// <param name="request">The request.</param>
/// <returns>The clues.</returns>
public override IEnumerable <Clue> BuildClues(ExecutionContext context, IExternalSearchQuery query, IExternalSearchQueryResult result, IExternalSearchRequest request)
{
var resultItem = result.As <CompanyNew>();
var code = new EntityCode(EntityType.Organization, GetCodeOrigin(), resultItem.Data.company_number);
var clue = new Clue(code, context.Organization);
clue.Data.OriginProviderDefinitionId = Id;
PopulateMetadata(clue.Data.EntityData, resultItem.Data);
yield return(clue);
}
public override IEnumerable <IExternalSearchQuery> BuildQueries(ExecutionContext context, IExternalSearchRequest request)
{
if (!Accepts(request.EntityMetaData.EntityType))
{
yield break;
}
var entityType = request.EntityMetaData.EntityType;
var id = request.QueryParameters.GetValue(HelloWorldVocabularies.User.Id, new HashSet <string>());
var person = new Dictionary <string, string>
{
{ "id", id.FirstOrDefault() }
};
if (person.Any())
{
yield return(new ExternalSearchQuery(this, entityType, person));
}
}
/// <summary>Gets the preview image.</summary>
/// <param name="context">The context.</param>
/// <param name="result">The result.</param>
/// <param name="request">The request.</param>
/// <returns>The preview image.</returns>
public override IPreviewImage GetPrimaryEntityPreviewImage(ExecutionContext context, IExternalSearchQueryResult result, IExternalSearchRequest request)
{
return(null);
}
public override IEnumerable <Clue> BuildClues(ExecutionContext context, IExternalSearchQuery query, IExternalSearchQueryResult result, IExternalSearchRequest request)
{
var resultItem = result.As <User>();
var code = GetOriginEntityCode(resultItem);
var clue = new Clue(code, context.Organization);
PopulateMetadata(clue.Data.EntityData, resultItem);
// If necessary, you can create multiple clues and return them.
return(new[] { clue });
}
public IEnumerable <Clue> BuildClues(ExecutionContext context, IExternalSearchQuery query, IExternalSearchQueryResult result, IExternalSearchRequest request, IDictionary <string, object> config, IProvider provider)
{
return(BuildClues(context, query, result, request));
}
/// <inheritdoc/>
public override IEnumerable <Clue> BuildClues(ExecutionContext context, IExternalSearchQuery query, IExternalSearchQueryResult result, IExternalSearchRequest request)
{
var organizationCode = this.GetOriginEntityCode(result.As <PermIdSocialResponse>());
var organizationClue = new Clue(organizationCode, context.Organization);
this.PopulateMetadata(organizationClue.Data.EntityData, result.As <PermIdSocialResponse>());
yield return(organizationClue);
if (result.As <PermIdSocialResponse>().Data.AdditionalInfo != null)
{
foreach (var person in result.As <PermIdSocialResponse>().Data.AdditionalInfo)
{
var personCode = this.GetPersonEntityCode(person);
var personClue = new Clue(personCode, context.Organization);
this.PopulatePersonMetadata(personClue.Data.EntityData, person);
var personToOrganizationEdge = new EntityEdge(new EntityReference(personCode), new EntityReference(organizationCode), EntityEdgeType.WorksFor);
personClue.Data.EntityData.OutgoingEdges.Add(personToOrganizationEdge);
yield return(personClue);
}
}
}
/**********************************************************************************************************
* METHODS
**********************************************************************************************************/
/// <summary>Builds the queries.</summary>
/// <param name="context">The context.</param>
/// <param name="request">The request.</param>
/// <returns>The search queries.</returns>
public override IEnumerable <IExternalSearchQuery> BuildQueries(ExecutionContext context, IExternalSearchRequest request)
{
if (!Accepts(request.EntityMetaData.EntityType))
{
yield break;
}
var existingResults = request.GetQueryResults <CompanyNew>(this).ToList();
Func <string, bool> idFilter = value => existingResults.Any(r => string.Equals(r.Data.company_number, value, StringComparison.InvariantCultureIgnoreCase));
Func <string, bool> nameFilter = value => existingResults.Any(r => string.Equals(r.Data.company_name, value, StringComparison.InvariantCultureIgnoreCase));
var entityType = request.EntityMetaData.EntityType;
var companyHouseNumber = request.QueryParameters.GetValue(Core.Data.Vocabularies.Vocabularies.CluedInOrganization.CodesCompanyHouse, new HashSet <string>());
var country = request.EntityMetaData.Properties.ContainsKey(Core.Data.Vocabularies.Vocabularies.CluedInOrganization.AddressCountryCode) ? request.EntityMetaData.Properties[Core.Data.Vocabularies.Vocabularies.CluedInOrganization.AddressCountryCode].ToLowerInvariant() : string.Empty;
// TODO: Should put a filter here to only lookup UK based companies.
if (country.Contains("uk") || country.Contains("gb"))
{
var organizationName = request.QueryParameters.GetValue(Core.Data.Vocabularies.Vocabularies.CluedInOrganization.OrganizationName, new HashSet <string>());
if (!string.IsNullOrEmpty(request.EntityMetaData.Name))
{
organizationName.Add(request.EntityMetaData.Name);
}
if (!string.IsNullOrEmpty(request.EntityMetaData.DisplayName))
{
organizationName.Add(request.EntityMetaData.DisplayName);
}
if (organizationName != null)
{
var values = organizationName.Select(NameNormalization.Normalize).ToHashSetEx();
foreach (var value in values.Where(v => !nameFilter(v)))
{
yield return(new ExternalSearchQuery(this, entityType, ExternalSearchQueryParameter.Name, value));
}
}
}
foreach (var value in companyHouseNumber.Where(v => !idFilter(v)))
{
yield return(new ExternalSearchQuery(this, entityType, ExternalSearchQueryParameter.Identifier, value));
}
}
/// <summary>Populates the metadata.</summary>
/// <param name="metadata">The metadata.</param>
/// <param name="resultItem">The result item.</param>
private void PopulateMetadata(IEntityMetadata metadata, IExternalSearchQueryResult <LibpostalResponse> resultItem, IExternalSearchRequest request)
{
var code = GetOriginEntityCode(resultItem, request);
metadata.EntityType = request.EntityMetaData.EntityType;
//Name is required, without it the changes are ignored and not added to the entity.
metadata.Name = request.EntityMetaData.Name;
//metadata.Description = resultItem.Data.description;
metadata.OriginEntityCode = code;
foreach (var item in resultItem.Data.Items)
{
switch (item.label)
{
case "house":
metadata.Properties[LibpostalVocabulary.Location.House] = item.value.ToTitleCase();
break;
case "category":
metadata.Properties[LibpostalVocabulary.Location.Category] = item.value.ToTitleCase();
break;
case "near":
metadata.Properties[LibpostalVocabulary.Location.Near] = item.value.ToTitleCase();
break;
case "house_number":
metadata.Properties[LibpostalVocabulary.Location.House_number] = item.value.ToTitleCase();
break;
case "road":
metadata.Properties[LibpostalVocabulary.Location.Road] = item.value.ToTitleCase();
break;
case "unit":
metadata.Properties[LibpostalVocabulary.Location.Unit] = item.value.ToTitleCase();
break;
case "level":
metadata.Properties[LibpostalVocabulary.Location.Level] = item.value.ToTitleCase();
break;
case "staircase":
metadata.Properties[LibpostalVocabulary.Location.Staircase] = item.value.ToTitleCase();
break;
case "entrance":
metadata.Properties[LibpostalVocabulary.Location.Entrance] = item.value.ToTitleCase();
break;
case "po_box":
metadata.Properties[LibpostalVocabulary.Location.Po_box] = item.value.ToTitleCase();
break;
case "postcode":
metadata.Properties[LibpostalVocabulary.Location.Postcode] = item.value.ToTitleCase();
break;
case "suburb":
metadata.Properties[LibpostalVocabulary.Location.Suburb] = item.value.ToTitleCase();
break;
case "city_district":
metadata.Properties[LibpostalVocabulary.Location.City_district] = item.value.ToTitleCase();
break;
case "city":
metadata.Properties[LibpostalVocabulary.Location.City] = item.value.ToTitleCase();
break;
case "island":
metadata.Properties[LibpostalVocabulary.Location.Island] = item.value.ToTitleCase();
break;
case "state_district":
metadata.Properties[LibpostalVocabulary.Location.State_district] = item.value.ToTitleCase();
break;
case "state":
metadata.Properties[LibpostalVocabulary.Location.State] = item.value.ToTitleCase();
break;
case "country_region":
metadata.Properties[LibpostalVocabulary.Location.Country_region] = item.value.ToTitleCase();
break;
case "country":
metadata.Properties[LibpostalVocabulary.Location.Country] = item.value.ToTitleCase();
break;
case "world_region":
metadata.Properties[LibpostalVocabulary.Location.World_region] = item.value.ToTitleCase();
break;
}
}
metadata.Codes.Add(code);
}
