/// <summary>
/// Process a document using the configured rules.
/// </summary>
/// <param name="source">Source document.</param>
/// <param name="parsed">Parsed document.</param>
/// <param name="parseResult">Parse result.</param>
/// <returns>Metadata result.</returns>
public async Task <MetadataResult> ProcessDocument(SourceDocument source, ParsedDocument parsed, ParseResult parseResult)
{
if (source == null)
{
throw new ArgumentNullException(nameof(source));
}
if (parsed == null)
{
throw new ArgumentNullException(nameof(parsed));
}
if (parseResult == null)
{
throw new ArgumentNullException(nameof(parseResult));
}
MetadataResult result = new MetadataResult();
result.Source = source;
result.Parsed = parsed;
result.ParseResult = parseResult;
List <MetadataRule> matchingRules = GetMatchingRules(source, parsed, parseResult);
if (matchingRules == null || matchingRules.Count < 1)
{
return(result);
}
foreach (MetadataRule rule in matchingRules)
{
result.MatchingRules.Add(rule);
if (rule.AddMetadataDocument != null && rule.AddMetadataDocument.Count > 0)
{
foreach (AddMetadataDocumentAction addDocAction in rule.AddMetadataDocument)
{
if (addDocAction.Properties == null || addDocAction.Properties.Count < 1)
{
continue;
}
#region Retrieve-Index-Clients
KomodoIndex src = _Indices.GetIndexClient(source.IndexGUID);
if (src == null)
{
throw new InvalidOperationException("Unable to find source index " + source.IndexGUID);
}
KomodoIndex dst = _Indices.GetIndexClient(addDocAction.IndexGUID);
if (dst == null)
{
throw new InvalidOperationException("Unable to find destination index " + addDocAction.IndexGUID);
}
#endregion
#region Generate-Derived-Metadata-Document
Dictionary <string, object> derivedDocument = new Dictionary <string, object>();
foreach (MetadataDocumentProperty prop in addDocAction.Properties)
{
if (prop.ValueAction == PropertyValueAction.CopyFromDocument)
{
string val = GetValueFromParseResult(parseResult, prop.SourceProperty);
derivedDocument.Add(prop.Key, val);
}
else if (prop.ValueAction == PropertyValueAction.Static)
{
derivedDocument.Add(prop.Key, prop.Value);
}
}
byte[] derivedDocBytes = Encoding.UTF8.GetBytes(Common.SerializeJson(derivedDocument, true));
#endregion
#region Store-in-Database
MetadataDocument metadataDoc = new MetadataDocument();
metadataDoc.Created = DateTime.UtcNow;
metadataDoc.GUID = Guid.NewGuid().ToString();
metadataDoc.IndexGUID = source.IndexGUID;
metadataDoc.OwnerGUID = source.OwnerGUID;
metadataDoc.SourceDocumentGUID = source.GUID;
metadataDoc.TargetIndexGUID = addDocAction.IndexGUID;
metadataDoc.Type = DocType.Json;
metadataDoc = src.AddMetadata(source, metadataDoc);
#endregion
#region Index
SourceDocument derivedSourceDoc = new SourceDocument(
metadataDoc.GUID,
source.OwnerGUID,
addDocAction.IndexGUID,
addDocAction.Name,
addDocAction.Title,
addDocAction.Tags,
DocType.Json,
null,
"application/json",
derivedDocBytes.Length,
Common.Md5(derivedDocBytes));
IndexResult idxResult = await dst.Add(derivedSourceDoc, derivedDocBytes, new ParseOptions(), addDocAction.Parse);
#endregion
#region Store-Results
result.MetadataDocuments.Add(metadataDoc);
result.DerivedDocuments.Add(idxResult.SourceDocument);
result.DerivedDocumentsData.Add(derivedDocument);
result.DerivedIndexResults.Add(idxResult);
#endregion
}
}
}
foreach (MetadataRule rule in matchingRules)
{
if (rule.Postback != null &&
rule.Postback.Urls != null &&
rule.Postback.Urls.Count > 0)
{
MetadataResult postbackMetadata = Common.CopyObject <MetadataResult>(result);
if (!rule.Postback.IncludeSource)
{
postbackMetadata.Source = null;
}
if (!rule.Postback.IncludeParsed)
{
postbackMetadata.Parsed = null;
}
if (!rule.Postback.IncludeParseResult)
{
postbackMetadata.ParseResult = null;
}
if (!rule.Postback.IncludeMetadata)
{
postbackMetadata.MetadataDocuments = null;
}
if (!rule.Postback.IncludeRules)
{
postbackMetadata.MatchingRules = null;
}
if (!rule.Postback.IncludeDerivedDocuments)
{
postbackMetadata.DerivedDocuments = null;
}
rule.Postback.Urls = rule.Postback.Urls.Distinct().ToList();
foreach (string url in rule.Postback.Urls)
{
if (String.IsNullOrEmpty(url))
{
continue;
}
RestRequest req = new RestRequest(
url,
HttpMethod.POST,
null,
"application/json");
RestResponse resp = req.Send(Common.SerializeJson(result, true));
result.PostbackStatusCodes.Add(url, resp.StatusCode);
}
}
}
return(result);
}
