private static XmlDocument GetMetadataformEntityID(string entityID)
{
XmlDocument adfsMetaData = new XmlDocument();
adfsMetaData.LoadXml(Settings.Default.ADFSMetaData);
MetadataDocument metadataDocument = MetadataDocument.Instance();
if (!metadataDocument.SignatureValid)
{
throw new Exception("Metadata Signature invalid");
}
lock (metadataDocument.ReadLock)
{
var xmlNamespaceManager = AdfsNamespaceManager(metadataDocument.Document);
string xpathTemplate = Settings.Default.XPath2Copy;
string xpath = String.Format(xpathTemplate, entityID);
var entitiesDescriptorNode = metadataDocument.Document.SelectSingleNode(xpath, xmlNamespaceManager);
XmlNode copiedNode = adfsMetaData.ImportNode(entitiesDescriptorNode, true);
adfsMetaData.DocumentElement.AppendChild(copiedNode);
}
return(adfsMetaData);
}
private async Task <ObjectId> InsertDocumentAsync(IMongoCollection <AppDocument> collection, AppDocument newDoc)
{
newDoc.Created = DateTime.Now;
await collection.InsertOneAsync(newDoc);
var databaseName = collection.Database.DatabaseNamespace.DatabaseName;
var medatadataColl = this._database.GetCollection <MetadataDocument>(collection.CollectionNamespace.FullName.Replace(databaseName + ".", ""));
var medadataDoc = new MetadataDocument {
LatestID = newDoc.Id
};
await medatadataColl.ReplaceOneAsync(item => item.Id == METADATA_ID, medadataDoc, new UpdateOptions { IsUpsert = true });
return(newDoc.Id);
}
public void OpprettForsendelseMedUtvidelse()
{
var raw = "<?xml version=\"1.0\" encoding=\"utf-8\"?><lenke xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\" xmlns=\"http://begrep.difi.no/sdp/utvidelser/lenke\"><url>https://www.test.no</url><beskrivelse lang=\"nb\">This was raw string</beskrivelse></lenke>";
MetadataDocument metadataDocument = new MetadataDocument("lenke.xml", "application/vnd.difi.dpi.lenke", raw);
Avsender avsender = null; //Som initiert tidligere
PostInfo postInfo = null; //Som initiert tidligere
Dokumentpakke dokumentpakke = null; //Som initiert tidligere
var forsendelse = new Forsendelse(avsender, postInfo, dokumentpakke)
{
MetadataDocument = metadataDocument
};
}
public SmokeTestsHelper Create_Digital_Forsendelse_with_Datatype()
{
_forsendelse = DomainUtility.GetForsendelseForDataType();
var raw = "<?xml version=\"1.0\" encoding=\"utf-8\"?>" +
"<lenke xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\" xmlns=\"http://begrep.difi.no/sdp/utvidelser/lenke\">" +
"<url>https://www..no</url>" +
"<beskrivelse lang=\"nb\">Dette er en lenke utvidelse</beskrivelse>" +
"</lenke>";
MetadataDocument metadataDocument = new MetadataDocument("lenke.xml", "application/vnd.difi.dpi.lenke+xml", raw);
_forsendelse.MetadataDocument = metadataDocument;
return(this);
}
private void IntializeDocument(IModule moduleToValidate)
{
this.document = new MetadataDocument() { Module = moduleToValidate };
}
public UserMetadataDocument(MetadataDocument other)
{
BaseUrl = other.BaseUrl;
DocumentBody = other.DocumentBody;
}
public UserMetadataDocument(MetadataDocument other)
{
BaseUrl = other.BaseUrl;
DocumentBody = other.DocumentBody;
}
public async Task <Transportkvittering> SendMessage(StandardBusinessDocument standardBusinessDocument,
Dokumentpakke dokumentpakke, MetadataDocument metadataDocument)
{
var openRequestUri = new Uri(ClientConfiguration.Miljø.Url, "/api/messages/out/");
var putRequestUri = new Uri(openRequestUri, $"{standardBusinessDocument.GetConversationId()}");
JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions
{
IgnoreNullValues = true,
};
string json = JsonSerializer.Serialize(standardBusinessDocument, standardBusinessDocument.GetType(), jsonSerializerOptions);
JObject sbdobj = JObject.Parse(json);
sbdobj.Add(standardBusinessDocument.any is DigitalForretningsMelding ? "digital" : "print", sbdobj["any"]);
sbdobj.Remove("any");
string newjson = sbdobj.ToString();
StringContent content = new StringContent(newjson, Encoding.UTF8, "application/json");
try
{
await CreateMessage(content, openRequestUri);
await addDocument(dokumentpakke.Hoveddokument, putRequestUri);
if (metadataDocument != null)
{
await addDocument(metadataDocument, putRequestUri);
}
foreach (Dokument vedlegg in dokumentpakke.Vedlegg)
{
await addDocument(vedlegg, putRequestUri);
}
await CloseMessage(putRequestUri);
return(new TransportOkKvittering());
}
catch (TransportFeiletException e)
{
_logger.LogError($"Feil ifbm opprettelse av forsendelse mot integrasjonspunkt: {e.TransportFeiletKvittering.ToString()}");
return(e.TransportFeiletKvittering);
}
}
public IActionResult IndexMetadata(MetadataDocument metadata)
{
return(Ok(_documentService.IndexMetadata(metadata.Content)));
}
/// <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);
}
