/// <summary>
/// Serialize a SignedDelivery object to a XmlDocument. using defaultnamespaceV3.
/// </summary>
public XmlDocument SerializeToXmlDocumentV3(SignedDelivery signedDelivery, string defaultNameSpace)
{
logger.LogTrace(string.Format("SE.GOV.MM.Integration.Signing.Helper.SerializeHelperV3: incoming SerializeToXmlDocumentV3"));
var xmlDocument = new XmlDocument();
xmlDocument.PreserveWhitespace = false;
var xmlSerializerNameSpace = new XmlSerializerNamespaces();
xmlSerializerNameSpace.Add("", defaultNameSpace);
using (var memoryStream = new MemoryStream())
{
var xmlWriterSettings = new XmlWriterSettings();
xmlWriterSettings.OmitXmlDeclaration = true;
xmlWriterSettings.Encoding = Encoding.UTF8;
using (var xmlWriter = XmlWriter.Create(memoryStream, xmlWriterSettings))
{
var xmlSerializer = new XmlSerializer(typeof(SignedDelivery), defaultNameSpace);
xmlSerializer.Serialize(xmlWriter, (SignedDelivery)signedDelivery, xmlSerializerNameSpace);
}
memoryStream.Position = 0;
xmlDocument.Load(memoryStream);
}
logger.LogTrace(string.Format("SE.GOV.MM.Integration.Signing.Helper.SerializeHelper: leaving SerializeToXmlDocumentV3"));
return(xmlDocument);
}
/// <summary>
/// Handles sending message to user.
/// </summary>
/// <param name="SignedDelivery">Message to process</param>
/// <param name="endpointAdressRecipient">Endpoint to send recipient request </param>
/// <param name="endpointAdressAuthority">Endpoint to send authority request</param>
/// <param name="signingCertificateSubjectName">Certificate name in store</param>
/// <returns>Result of sending message</returns>
public async Task <DeliveryResult> distributeSecure(SignedDelivery SignedDelivery, string endpointAdressRecipient, string endpointAdressAuthority, string signingCertificateSubjectName)
{
logger.LogTrace(string.Format("SE.GOV.MM.Integration.Infrastructure.MessageService: entering distributeSecure"));
try
{
var log = new Logger <CertificateHelper>(new NullLoggerFactory());
// Get X509Certificate
var certificateHelper = new CertificateHelper(log);
var x509Certificate = certificateHelper.GetXMLSigningCertificateFromStore(signingCertificateSubjectName);
logger.LogTrace(string.Format("SE.GOV.MM.Integration.Infrastructure.MessageService: leaving distributeSecure"));
return(await handleDistributeSecure(SignedDelivery, endpointAdressAuthority, endpointAdressRecipient, x509Certificate));
}
catch (Exception ex)
{
logger.LogError(ex, ex.Message);
throw ex;
}
}
/// <summary>
/// Handles sending message to user.
/// </summary>
/// <param name="SignedDelivery">Message to process</param>
/// <param name="endpointAdressRecipient">Endpoint to send recipient request </param>
/// <param name="endpointAdressAuthority">Endpoint to send authority request</param>
/// <param name="x509Certificate2">Certificate to sign with</param>
/// <returns></returns>
public async Task <DeliveryResult> distributeSecure(SignedDelivery SignedDelivery, string endpointAdressRecipient, string endpointAdressAuthority, X509Certificate2 x509Certificate2)
{
logger.LogTrace(string.Format("SE.GOV.MM.Integration.Infrastructure.MessageService: entering distributeSecure"));
try
{
if (!x509Certificate2.HasPrivateKey)
{
var errorMessage = string.Format("SE.GOV.MM.Integration.Infrastructure.MessageService.distributeSecure: No valid certificate, private key missing");
logger.LogError(errorMessage);
throw new Exception(errorMessage);
}
logger.LogTrace(string.Format("SE.GOV.MM.Integration.Infrastructure.MessageService: leaving distributeSecure"));
return(await handleDistributeSecure(SignedDelivery, endpointAdressAuthority, endpointAdressRecipient, x509Certificate2));
}
catch (Exception ex)
{
logger.LogError(ex, ex.Message);
throw ex;
}
}
private async Task <DeliveryResult> handleDistributeSecure(SignedDelivery SignedDelivery, string endpointAdressAuthority, string endpointAdressRecipient, X509Certificate2 x509Certificate)
{
logger.LogTrace(string.Format("SE.GOV.MM.Integration.Infrastructure.MessageService: entering handleDistributeSecure"));
// Initilize messageHandler
var messageHandler = new MessageHandler(logger);
//Check if valid Sender
var senders = await GetSenders(endpointAdressAuthority, x509Certificate);
if (!senders.Select(x => x.Id).Contains(SignedDelivery.Delivery.Header.Sender.Id))
{
var errorMessage = $"SE.GOV.MM.Integration.Infrastructure.MessageService: not valid SenderId={SignedDelivery.Delivery.Header.Sender.Id} in metod handleDistributeSecure";
logger.LogWarning(errorMessage);
throw new Exception(errorMessage);
}
// Initiate serializeHelper
var serializehelper = new SerializeHelper(logger);
// SerializeToXmlDocument
string defaultNamespace = DefaultNamespace.v3.AsString(EnumFormat.Description);
var xmlDocSignedDelivery = serializehelper.SerializeToXmlDocumentV3(SignedDelivery, defaultNamespace);
// Initiate signingHandler
var signingHandler = new SigningHandler(x509Certificate);
// Check if signed by Sender, otherwize sign SignedDelivery
if (!signingHandler.IsMessageSigned(xmlDocSignedDelivery))
{
signingHandler.SignXmlDocument(xmlDocSignedDelivery, TagName.Delivery.AsString(EnumFormat.Description));
SignedDelivery = serializehelper.DeserializeXmlToSignedDeliveryV3(xmlDocSignedDelivery, defaultNamespace);
}
// Create signed sealeddelivery
var SealedDelivery = CreateSealadDelivery();
SealedDelivery.SignedDelivery = SignedDelivery;
var xmlDocSealedDelivery = serializehelper.SerializeToXmlDocumentV3(SealedDelivery, defaultNamespace);
signingHandler.SignXmlDocument(xmlDocSealedDelivery, TagName.Seal.AsString(EnumFormat.Description));
SealedDelivery = serializehelper.DeserializeXmlToSealedDeliveryV3(xmlDocSealedDelivery, defaultNamespace);
// Verify that Receiver is reachable
var isReachable = await handleIsUserReachableInFaRV3(
SignedDelivery.Delivery.Header.Recipient,
SignedDelivery.Delivery.Header.Sender.Id,
endpointAdressRecipient, x509Certificate);
// Send to Operator
if (isReachable == null || isReachable.Count() == 0)
{
throw new Exception($"SE.GOV.MM.Integration.Infrastructure.MessageService: Recipient is not reachable {SignedDelivery.Delivery.Header.Recipient}");
}
if (!isReachable[0].SenderAccepted)
{
throw new Exception($"SE.GOV.MM.Integration.Infrastructure.MessageService: Recipient '{SignedDelivery.Delivery.Header.Recipient}' " +
$"does not accept delivery from supplier '{SignedDelivery.Delivery.Header.Sender.Id}' ");
}
if (isReachable[0]?.AccountStatus?.ServiceSupplier == null && isReachable[0]?.AccountStatus?.ServiceSupplier?.UIAdress == null)
{
throw new Exception($"SE.GOV.MM.Integration.Infrastructure.MessageService: Recipient does not have an account in FaR {SignedDelivery.Delivery.Header.Recipient}");
}
var baseAdressServiceSupplier = isReachable[0].AccountStatus.ServiceSupplier.ServiceAdress;
logger.LogTrace(string.Format("SE.GOV.MM.Integration.Infrastructure.MessageService: leaving handleDistributeSecure"));
return(await messageHandler.SendMessageToMailBoxOperator(SealedDelivery, x509Certificate, baseAdressServiceSupplier));
}
