/// <summary>
/// Calls service method which implements the X-Road operation.
/// </summary>
protected virtual void InvokeServiceMethod(XRoadContextClassic context)
{
if (context.ServiceMap != null)
{
context.Result = InvokeMetaService(context);
return;
}
context.ServiceMap = context.Request.GetSerializerCache().GetServiceMap(context.Request.RootElementName);
context.Response.BinaryMode = context.ServiceMap.OperationDefinition.OutputBinaryMode;
var serviceObject = GetServiceObject(context);
DeserializeMethodInput(context);
try
{
var parameters = context.ServiceMap.RequestValueDefinition.ParameterInfo != null ? new[] { context.Parameters } : new object[0];
context.Result = context.ServiceMap.OperationDefinition.MethodInfo.Invoke(serviceObject, parameters);
}
catch (Exception exception)
{
context.Exception = exception;
OnInvocationError(context);
if (context.Result == null)
{
throw;
}
}
}
/// <summary>
/// Deserializes X-Road request from SOAP message payload.
/// </summary>
protected virtual void DeserializeMethodInput(XRoadContextClassic context)
{
var args = new BeforeDeserializationEventArgs();
OnBeforeDeserialization(context, args);
context.Request.ContentStream.Position = 0;
var reader = XmlReader.Create(context.Request.ContentStream, args.XmlReaderSettings);
reader.MoveToPayload(context.Request.RootElementName);
context.Parameters = context.ServiceMap.DeserializeRequest(reader, context.Request);
OnAfterDeserialization(context);
}
/// <summary>
/// Handle incoming request.
/// </summary>
public virtual void ProcessRequest(HttpContext httpContext)
{
httpContext.Request.InputStream.Position = 0;
httpContext.Response.ContentType = $"text/xml; charset={encoding.HeaderName}";
using (var context = new XRoadContextClassic(httpContext))
{
try
{
HandleRequest(context);
}
catch (Exception exception)
{
OnExceptionOccured(context, exception, null, null, null, null);
}
}
}
/// <summary>
/// Serializes service result to a X-Road message response.
/// </summary>
protected virtual void SerializeXRoadResponse(XRoadContextClassic context)
{
OnBeforeSerialization(context);
context.Request.ContentStream.Position = 0;
using (var reader = XmlReader.Create(context.Request.ContentStream, new XmlReaderSettings {
CloseInput = false
}))
{
var writer = new XmlTextWriter(context.Response.ContentStream, context.Response.ContentEncoding);
writer.WriteStartDocument();
if (reader.MoveToElement(0) && reader.IsCurrentElement(0, "Envelope", NamespaceConstants.SOAP_ENV))
{
writer.WriteStartElement(reader.Prefix, "Envelope", NamespaceConstants.SOAP_ENV);
writer.WriteAttributes(reader, true);
}
else
{
writer.WriteStartElement(PrefixConstants.SOAP_ENV, "Envelope", NamespaceConstants.SOAP_ENV);
writer.WriteAttributeString("xmlns", PrefixConstants.SOAP_ENV, NamespaceConstants.XMLNS, NamespaceConstants.SOAP_ENV);
}
if (reader.MoveToElement(1) && reader.IsCurrentElement(1, "Header", NamespaceConstants.SOAP_ENV))
{
writer.WriteNode(reader, true);
}
writer.WriteStartElement("Body", NamespaceConstants.SOAP_ENV);
if (reader.IsCurrentElement(1, "Body", NamespaceConstants.SOAP_ENV) || reader.MoveToElement(1, "Body", NamespaceConstants.SOAP_ENV))
{
writer.WriteAttributes(reader, true);
}
context.ServiceMap.SerializeResponse(writer, context.Result, context.Response, reader, CustomSerialization);
writer.WriteEndDocument();
writer.Flush();
}
context.Response.SaveTo(context.HttpContext);
OnAfterSerialization(context);
}
/// <summary>
/// Handle current X-Road operation.
/// </summary>
protected override void HandleRequest(XRoadContextClassic context)
{
if (context.HttpContext.Request.InputStream.Length == 0)
{
throw XRoadException.InvalidQuery("Empty request content");
}
context.Request.LoadRequest(context.HttpContext, StoragePath.GetValueOrDefault(Path.GetTempPath()), supportedProtocols);
if (context.Request.Protocol == null && context.Request.MetaServiceMap == null)
{
var supportedProtocolsString = string.Join(", ", supportedProtocols.Select(x => $@"""{x.Name}"""));
throw XRoadException.InvalidQuery($"Could not detect X-Road message protocol version from request message. Adapter supports following protocol versions: {supportedProtocolsString}.");
}
context.Response.Copy(context.Request);
context.ServiceMap = context.Request.MetaServiceMap;
OnRequestLoaded(context);
InvokeServiceMethod(context);
SerializeXRoadResponse(context);
}
/// <summary>
/// Handles service description request.
/// </summary>
protected override void HandleRequest(XRoadContextClassic context)
{
Protocol.WriteServiceDescription(context.HttpContext.Response.OutputStream, Version);
}
/// <summary>
/// Intercept X-Road service request handling after serialization of the response message.
/// </summary>
protected virtual void OnAfterSerialization(XRoadContextClassic context)
{
}
/// <summary>
/// Intercept X-Road service request handling before serialization of the response message.
/// </summary>
protected virtual void OnBeforeSerialization(XRoadContextClassic context)
{
}
/// <summary>
/// Customize XML reader settings before deserialization of the X-Road message.
/// </summary>
protected virtual void OnBeforeDeserialization(XRoadContextClassic context, BeforeDeserializationEventArgs args)
{
}
/// <summary>
/// Handle exception that occured on service method invokation.
/// </summary>
protected virtual void OnInvocationError(XRoadContextClassic context)
{
}
/// <summary>
/// Intercept X-Road service request after request message is loaded.
/// </summary>
protected virtual void OnRequestLoaded(XRoadContextClassic context)
{
}
/// <summary> /// Get main service object which implements the functionality of /// the operation. /// </summary> protected abstract object GetServiceObject(XRoadContextClassic context);
/// <summary> /// Handle X-Road message protocol meta-service request. /// </summary> protected abstract object InvokeMetaService(XRoadContextClassic context);
/// <summary>
/// Handles all exceptions as technical SOAP faults.
/// </summary>
protected virtual void OnExceptionOccured(XRoadContextClassic context, Exception exception, FaultCode faultCode, string faultString, string faultActor, string details)
{
using (var writer = new XmlTextWriter(context.HttpContext.Response.OutputStream, encoding))
SoapMessageHelper.SerializeSoapFaultResponse(writer, faultCode, faultString, faultActor, details, exception);
}
/// <summary> /// Handle current X-Road operation. /// </summary> protected abstract void HandleRequest(XRoadContextClassic context);
/// <inheritdoc />
protected override void HandleRequest(XRoadContextClassic context)
{
ServiceManager.CreateServiceDescription(version: Version)
.SaveTo(context.HttpContext.Response.OutputStream);
}
