private IServiceMap AddServiceMap(XName qualifiedName)
{
var operationDefinition = GetOperationDefinition(contractAssembly, qualifiedName);
if (operationDefinition == null || qualifiedName.NamespaceName != operationDefinition.Name.NamespaceName)
{
throw XRoadException.UnknownOperation(qualifiedName);
}
var requestValueDefinition = schemaDefinitionProvider.GetRequestValueDefinition(operationDefinition);
var inputTypeMap = GetContentDefinitionTypeMap(requestValueDefinition, null);
var outputTuple = GetReturnValueTypeMap(operationDefinition);
var responseValueDefinition = outputTuple.Item1;
var outputTypeMap = outputTuple.Item2;
var serviceMap = (IServiceMap)Activator.CreateInstance(
operationDefinition.ServiceMapType,
this,
operationDefinition,
requestValueDefinition,
responseValueDefinition,
inputTypeMap,
outputTypeMap
);
return(serviceMaps.GetOrAdd(qualifiedName, serviceMap));
}
/// <summary>
/// Deserializes X-Road message response or throws <see>XRoadFaultException</see> when
/// X-Road fault is parsed from the message instead of expected result value.
/// </summary>
public static object DeserializeMessageContent(this XRoadMessage message, IServiceMap serviceMap)
{
if (serviceMap.ResponseValueDefinition.ContainsNonTechnicalFault)
{
ThrowIfXRoadFault(message, serviceMap);
}
message.ContentStream.Position = 0;
using (var reader = XmlReader.Create(message.ContentStream))
{
reader.MoveToBody();
if (!reader.MoveToElement(2))
{
throw XRoadException.InvalidQuery("No payload element in SOAP message.");
}
if (reader.NamespaceURI == NamespaceConstants.SOAP_ENV && reader.LocalName == "Fault")
{
throw new SoapFaultException(SoapMessageHelper.DeserializeSoapFault(reader));
}
var result = serviceMap.DeserializeResponse(reader, message);
var fault = result as XRoadFault;
if (fault != null)
{
throw new XRoadFaultException(fault);
}
return(result);
}
}
private Tuple <ITypeMap, ITypeMap> AddTypeMap(XName qualifiedName)
{
var typeDefinition = GetRuntimeTypeDefinition(qualifiedName);
if (typeDefinition == null)
{
return(null);
}
if (qualifiedName.NamespaceName != typeDefinition.Name.NamespaceName)
{
throw XRoadException.UnknownType(qualifiedName.ToString());
}
if (!typeDefinition.Type.GetTypeInfo().IsEnum&& !typeDefinition.Type.GetTypeInfo().IsAbstract&& typeDefinition.Type.GetTypeInfo().GetConstructor(Type.EmptyTypes) == null)
{
throw XRoadException.NoDefaultConstructorForType(typeDefinition.Name);
}
ITypeMap typeMap;
if (typeDefinition.TypeMapType != null)
{
typeMap = (ITypeMap)Activator.CreateInstance(typeDefinition.TypeMapType, this, typeDefinition);
}
else if (typeDefinition.Type.GetTypeInfo().IsEnum)
{
typeMap = (ITypeMap)Activator.CreateInstance(typeof(EnumTypeMap), typeDefinition);
}
else if (typeDefinition.Type.GetTypeInfo().IsAbstract)
{
typeMap = (ITypeMap)Activator.CreateInstance(typeof(AbstractTypeMap), typeDefinition);
}
else if (typeDefinition.HasStrictContentOrder)
{
typeMap = (ITypeMap)Activator.CreateInstance(typeof(SequenceTypeMap <>).MakeGenericType(typeDefinition.Type), this, typeDefinition);
}
else
{
typeMap = (ITypeMap)Activator.CreateInstance(typeof(AllTypeMap <>).MakeGenericType(typeDefinition.Type), this, typeDefinition);
}
var arrayTypeMap = (ITypeMap)Activator.CreateInstance(typeof(ArrayTypeMap <>).MakeGenericType(typeDefinition.Type), this, schemaDefinitionProvider.GetCollectionDefinition(typeDefinition), typeMap);
var typeMapTuple = Tuple.Create(typeMap, arrayTypeMap);
if (!(typeMap is ICompositeTypeMap compositeTypeMap))
{
return(xmlTypeMaps.GetOrAdd(qualifiedName, typeMapTuple));
}
var partialTypeMaps = new Dictionary <Type, ITypeMap>
{
{ compositeTypeMap.Definition.Type, compositeTypeMap },
{ arrayTypeMap.Definition.Type, arrayTypeMap }
};
compositeTypeMap.InitializeProperties(GetRuntimeProperties(typeDefinition, partialTypeMaps), availableFilters);
return(xmlTypeMaps.GetOrAdd(qualifiedName, typeMapTuple));
}
private static bool ReadPropertyValue(XmlReader reader, IPropertyMap propertyMap, IXmlTemplateNode templateNode, XRoadMessage message, bool validateRequired, T dtoObject)
{
var templateName = propertyMap.Definition.TemplateName;
var propertyNode = templateNode[templateName, message.Version];
if (propertyNode == null)
{
reader.ConsumeUnusedElement();
return(false);
}
var isNull = reader.IsNilElement();
if (validateRequired && isNull && propertyNode.IsRequired)
{
throw XRoadException.MissingRequiredPropertyValues(Enumerable.Repeat(propertyMap.Definition.Content.Name.LocalName, 1));
}
if ((isNull || propertyMap.Deserialize(reader, dtoObject, propertyNode, message)) && !string.IsNullOrWhiteSpace(templateName))
{
dtoObject.OnMemberDeserialized(templateName);
}
reader.ConsumeNilElement(isNull);
return(propertyNode.IsRequired);
}
private IXmlTemplateNode MoveToProperty(XmlReader reader, IEnumerator <IPropertyMap> properties, IXmlTemplateNode templateNode, XRoadMessage message, bool validateRequired)
{
IPropertyMap propertyMap = null;
while (properties.MoveNext())
{
propertyMap = properties.Current;
var propertyName = propertyMap.Definition.GetSerializedName();
var propertyNode = templateNode[properties.Current.Definition.TemplateName, message.Version];
if (reader.LocalName == propertyName)
{
return(propertyNode);
}
if (!propertyMap.Definition.IsOptional)
{
throw XRoadException.UnexpectedElementInQuery(Definition.Name, propertyName, reader.LocalName);
}
if (validateRequired && propertyNode != null && propertyNode.IsRequired)
{
throw XRoadException.MissingRequiredPropertyValues(Enumerable.Repeat(propertyName, 1));
}
}
if (propertyMap == null)
{
throw XRoadException.InvalidQuery($"Element `{reader.LocalName}` was unexpected at given location while deserializing type `{Definition.Name}`.");
}
else
{
throw XRoadException.UnexpectedElementInQuery(Definition.Name, propertyMap.Definition.GetSerializedName(), reader.LocalName);
}
}
public static Tuple <MethodInfo, XRoadServiceAttribute> FindMethodDeclaration(this MethodInfo method, string operationName, IDictionary <MethodInfo, IDictionary <string, XRoadServiceAttribute> > serviceContracts)
{
if (method.DeclaringType == null)
{
return(null);
}
var methodContracts = method.DeclaringType
.GetTypeInfo()
.GetInterfaces()
.Select(iface => method.DeclaringType.GetTypeInfo().GetRuntimeInterfaceMap(iface))
.Where(map => map.TargetMethods.Contains(method))
.Select(map => map.InterfaceMethods[Array.IndexOf(map.TargetMethods, method)])
.ToList();
if (methodContracts.Count > 1)
{
throw XRoadException.AmbiguousMatch(operationName);
}
var methodContract = methodContracts.SingleOrDefault();
if (methodContract == null || !serviceContracts.TryGetValue(methodContract, out var serviceContract))
{
throw XRoadException.UndefinedContract(operationName);
}
if (!serviceContract.TryGetValue(operationName, out var serviceAttribute))
{
throw XRoadException.UndefinedContract(operationName);
}
return(Tuple.Create(methodContract, serviceAttribute));
}
/// <inheritdoc />
public object DeserializeResponse(XmlReader reader, XRoadMessage message)
{
var requestName = ResponseDefinition.RequestElementName;
var responseName = ResponseDefinition.ResponseElementName;
if (OperationDefinition.CopyRequestPartToResponse)
{
if (!reader.MoveToElement(3, requestName))
{
throw XRoadException.InvalidQuery($"Expected payload element `{requestName}` was not found in SOAP message.");
}
reader.Read();
}
var hasResponseElement = reader.MoveToElement(3);
if (hasResponseElement && !ResponseDefinition.ContainsNonTechnicalFault && reader.LocalName == ResponseDefinition.FaultName)
{
return(reader.ReadXRoadFault(4));
}
if (!hasResponseElement || reader.LocalName != responseName)
{
throw XRoadException.InvalidQuery($"Expected payload element `{responseName}` in SOAP message, but `{reader.LocalName}` was found instead.");
}
var hasWrapperElement = HasWrapperResultElement;
if (hasWrapperElement && !reader.MoveToElement(4, ResponseDefinition.Content.Name.LocalName, ResponseDefinition.Content.Name.NamespaceName))
{
throw XRoadException.InvalidQuery($"Expected result wrapper element `{ResponseDefinition.Content.Name}` was not found in SOAP message.");
}
return(ProcessResponseValue(DeserializeValue(reader, outputTypeMap, message.ResponseNode, ResponseDefinition.Content, message)));
}
public bool Deserialize(XmlReader reader, IXRoadSerializable dtoObject, IXmlTemplateNode templateNode, XRoadMessage message)
{
if (message.EnableFiltering && !filters.Contains(message.FilterName))
{
reader.ConsumeUnusedElement();
return(false);
}
string typeAttribute;
if (typeMap.Definition.IsAnonymous && !(typeMap is IArrayTypeMap) && (typeAttribute = reader.GetAttribute("type", NamespaceConstants.XSI)) != null)
{
throw XRoadException.InvalidQuery($"Expected anonymous type, but `{typeAttribute}` was given.");
}
var concreteTypeMap = (typeMap.Definition.IsInheritable ? serializer.GetTypeMapFromXsiType(reader) : null) ?? typeMap;
var propertyValue = concreteTypeMap.Deserialize(reader, templateNode, Definition.Content, message);
if (propertyValue == null)
{
return(true);
}
setValueMethod(dtoObject, propertyValue);
return(true);
}
private static Tuple <XName, bool> GetTypeAttributeValue(XmlReader reader, XName attributeName, bool isArrayType = false)
{
var typeValue = reader.GetAttribute(attributeName.LocalName, attributeName.NamespaceName);
if (typeValue == null)
{
return(null);
}
var namespaceSeparatorIndex = typeValue.IndexOf(':');
var namespacePrefix = namespaceSeparatorIndex < 0 ? string.Empty : typeValue.Substring(0, namespaceSeparatorIndex);
var typeName = namespaceSeparatorIndex < 0 ? typeValue : typeValue.Substring(namespaceSeparatorIndex + 1);
var typeNamespace = reader.LookupNamespace(namespacePrefix);
if (typeNamespace == null)
{
throw XRoadException.InvalidQuery($"Undefined namespace prefix `{namespacePrefix}` given in XML message for element `{reader.LocalName}` xsi:type.");
}
if (isArrayType)
{
typeName = typeName.Substring(0, typeName.LastIndexOf('['));
}
var qualifiedName = XName.Get(typeName, typeNamespace);
return(qualifiedName != qnSoapEncArray?Tuple.Create(qualifiedName, isArrayType) : GetTypeAttributeValue(reader, qnSoapEncArrayType, true));
}
public XName GetXmlTypeName(Type type)
{
if (type.IsNullable())
{
return(GetXmlTypeName(Nullable.GetUnderlyingType(type)));
}
switch (type.FullName)
{
case "System.Byte": return(XName.Get("byte", NamespaceConstants.XSD));
case "System.DateTime": return(XName.Get("dateTime", NamespaceConstants.XSD));
case "System.Boolean": return(XName.Get("boolean", NamespaceConstants.XSD));
case "System.Single": return(XName.Get("float", NamespaceConstants.XSD));
case "System.Double": return(XName.Get("double", NamespaceConstants.XSD));
case "System.Decimal": return(XName.Get("decimal", NamespaceConstants.XSD));
case "System.Int64": return(XName.Get("long", NamespaceConstants.XSD));
case "System.Int32": return(XName.Get("int", NamespaceConstants.XSD));
case "System.String": return(XName.Get("string", NamespaceConstants.XSD));
}
if (ReferenceEquals(type.GetTypeInfo().Assembly, contractAssembly))
{
return(XName.Get(type.Name, Protocol.ProducerNamespace));
}
throw XRoadException.AndmetüübileVastavNimeruumPuudub(type.FullName);
}
public override object Deserialize(XmlReader reader, IXmlTemplateNode templateNode, ContentDefinition content, XRoadMessage message)
{
var dtoObject = new T();
dtoObject.SetTemplateMembers(templateNode.ChildNames);
var validateRequired = content.Particle is RequestDefinition;
if (contentPropertyMap != null)
{
ReadPropertyValue(reader, contentPropertyMap, templateNode, message, validateRequired, dtoObject);
return(dtoObject);
}
var existingPropertyNames = new HashSet <string>();
if (reader.IsEmptyElement)
{
ValidateRemainingProperties(existingPropertyNames, content);
return(MoveNextAndReturn(reader, dtoObject));
}
var parentDepth = reader.Depth;
var itemDepth = parentDepth + 1;
var requiredCount = 0;
reader.Read();
while (parentDepth < reader.Depth)
{
if (reader.NodeType != XmlNodeType.Element || reader.Depth != itemDepth)
{
reader.Read();
continue;
}
var propertyMap = GetPropertyMap(reader);
if (!propertyMap.Definition.Content.IsOptional)
{
existingPropertyNames.Add(reader.LocalName);
}
if (ReadPropertyValue(reader, propertyMap, templateNode, message, validateRequired, dtoObject) && validateRequired)
{
requiredCount++;
}
}
if (validateRequired && requiredCount < templateNode.CountRequiredNodes(message.Version))
{
throw XRoadException.MissingRequiredPropertyValues(GetMissingRequiredPropertyNames(dtoObject, templateNode, message));
}
ValidateRemainingProperties(existingPropertyNames, content);
return(dtoObject);
}
private IXRoadProtocol ParseXRoadProtocol(XmlReader reader)
{
if (!reader.MoveToElement(0, "Envelope", NamespaceConstants.SOAP_ENV))
{
throw XRoadException.InvalidQuery("Päringus puudub SOAP-ENV:Envelope element.");
}
return(supportedProtocols.SingleOrDefault(p => p.IsDefinedByEnvelope(reader)));
}
private IServiceManager DetectServiceManager(XmlReader reader)
{
if (!reader.MoveToElement(0, "Envelope", NamespaceConstants.SOAP_ENV))
{
throw XRoadException.InvalidQuery("Päringus puudub SOAP-ENV:Envelope element.");
}
return(serviceManagers.SingleOrDefault(p => p.IsDefinedByEnvelope(reader)));
}
/// <summary>
/// Fast-forward XML reader position to payload element.
/// </summary>
public static void MoveToPayload(this XmlReader reader, XName rootElementName)
{
reader.MoveToBody();
if (!reader.MoveToElement(2, rootElementName.LocalName, rootElementName.NamespaceName))
{
throw XRoadException.InvalidQuery("Payload is missing from request content.");
}
}
private IPropertyMap GetPropertyMap(XmlReader reader)
{
IPropertyMap propertyMap;
if (deserializationPropertyMaps.TryGetValue(reader.LocalName, out propertyMap))
{
return(propertyMap);
}
throw XRoadException.UnknownProperty(reader.LocalName, Definition.Name);
}
private static XRoadClientIdentifier ReadClient(XmlReader reader)
{
var qualifiedName = reader.GetXName();
if (reader.IsEmptyElement)
{
throw XRoadException.InvalidQuery($"Element `{qualifiedName}` cannot be empty.");
}
var client = new XRoadClientIdentifier();
var depth = reader.Depth;
var objectType = reader.GetAttribute("objectType", NamespaceConstants.XROAD_V4_ID);
if (string.IsNullOrWhiteSpace(objectType))
{
throw XRoadException.InvalidQuery($"Element `{qualifiedName}` must have attribute `{XName.Get("objectType", NamespaceConstants.XROAD_V4_ID)}` value.");
}
client.ObjectType = GetObjectType(objectType);
if (!reader.MoveToElement(depth + 1) || reader.LocalName != "xRoadInstance" || reader.NamespaceURI != NamespaceConstants.XROAD_V4_ID)
{
throw XRoadException.InvalidQuery($"Element `{qualifiedName}` must have child element `{XName.Get("xRoadInstance", NamespaceConstants.XROAD_V4_ID)}`.");
}
client.XRoadInstance = reader.ReadElementContentAsString();
if (!reader.MoveToElement(depth + 1) || reader.LocalName != "memberClass" || reader.NamespaceURI != NamespaceConstants.XROAD_V4_ID)
{
throw XRoadException.InvalidQuery($"Element `{qualifiedName}` must have child element `{XName.Get("memberClass", NamespaceConstants.XROAD_V4_ID)}`.");
}
client.MemberClass = reader.ReadElementContentAsString();
if (!reader.MoveToElement(depth + 1) || reader.LocalName != "memberCode" || reader.NamespaceURI != NamespaceConstants.XROAD_V4_ID)
{
throw XRoadException.InvalidQuery($"Element `{qualifiedName}` must have child element `{XName.Get("memberCode", NamespaceConstants.XROAD_V4_ID)}`.");
}
client.MemberCode = reader.ReadElementContentAsString();
var success = reader.MoveToElement(depth + 1);
if (success && reader.LocalName == "subsystemCode" && reader.NamespaceURI == NamespaceConstants.XROAD_V4_ID)
{
client.SubsystemCode = reader.ReadElementContentAsString();
success = reader.MoveToElement(depth + 1);
}
if (success)
{
throw XRoadException.InvalidQuery($"Unexpected element `{reader.GetXName()}` in element `{qualifiedName}`.");
}
return(client);
}
private void ValidateRemainingProperties(IEnumerator <IPropertyMap> properties, IContentDefinition contentDefinition)
{
while (properties.MoveNext())
{
if (!properties.Current.Definition.IsOptional)
{
var typeName = Definition?.Name ?? (((contentDefinition as ArrayItemDefinition)?.WrapperDefinition) as PropertyDefinition)?.DeclaringTypeDefinition?.Name;
throw XRoadException.InvalidQuery($"Element `{properties.Current.Definition.GetSerializedName()}` is required by type `{typeName}` definition.");
}
}
}
public override object Deserialize(XmlReader reader, IXmlTemplateNode templateNode, ContentDefinition content, XRoadMessage message)
{
var contentID = reader.GetAttribute("href");
if (string.IsNullOrWhiteSpace(contentID))
{
if (message.IsMultipartContainer)
{
throw XRoadException.InvalidQuery("Missing `href` attribute to multipart content.");
}
var tempAttachment = new XRoadAttachment(new MemoryStream())
{
IsMultipartContent = false
};
message.AllAttachments.Add(tempAttachment);
if (reader.IsEmptyElement)
{
return(MoveNextAndReturn(reader, tempAttachment.ContentStream));
}
reader.Read();
const int bufferSize = 1000;
int bytesRead;
var buffer = new byte[bufferSize];
while ((bytesRead = reader.ReadContentAsBase64(buffer, 0, bufferSize)) > 0)
{
tempAttachment.ContentStream.Write(buffer, 0, bytesRead);
}
return(tempAttachment.ContentStream);
}
var attachment = message.GetAttachment(contentID.Substring(4));
if (attachment == null)
{
throw XRoadException.PäringusPuudubAttachment(contentID);
}
if (reader.IsEmptyElement)
{
return(MoveNextAndReturn(reader, attachment.ContentStream));
}
reader.ReadToEndElement();
return(attachment.ContentStream);
}
/// <summary>
/// Fast-forward XML reader position to SOAP Body element.
/// </summary>
public static void MoveToBody(this XmlReader reader)
{
if (!reader.MoveToElement(0, "Envelope", NamespaceConstants.SOAP_ENV))
{
throw XRoadException.InvalidQuery($"Element `{NamespaceConstants.SOAP}:Envelope` is missing from request content.");
}
if (!reader.MoveToElement(1, "Body", NamespaceConstants.SOAP_ENV))
{
throw XRoadException.InvalidQuery($"Element `{NamespaceConstants.SOAP}:Body` is missing from request content.");
}
}
/// <inheritdoc />
public object DeserializeRequest(XmlReader reader, XRoadMessage message)
{
var requestName = RequestDefinition.RequestElementName;
if (!RequestDefinition.Content.MergeContent && !reader.MoveToElement(3, requestName))
{
throw XRoadException.InvalidQuery($"Päringus puudub X-tee `{requestName}` element.");
}
return(RequestDefinition.ParameterInfo != null
? ProcessRequestValue(DeserializeValue(reader, inputTypeMap, message.RequestNode, RequestDefinition.Content, message))
: null);
}
/// <summary>
/// Read next header value from the XML reader object.
/// </summary>
public virtual void ReadHeaderValue(XmlReader reader)
{
if (reader.NamespaceURI == NamespaceConstants.XROAD_V4_REPR && reader.LocalName == "representedParty")
{
RepresentedParty = ReadRepresentedParty(reader);
return;
}
if (reader.NamespaceURI == NamespaceConstants.XROAD_V4)
{
switch (reader.LocalName)
{
case "client":
Client = ReadClient(reader);
return;
case "service":
Service = ReadService(reader);
return;
case "centralService":
CentralService = ReadCentralService(reader);
return;
case "id":
Id = reader.ReadElementContentAsString();
return;
case "userId":
UserId = reader.ReadElementContentAsString();
return;
case "issue":
Issue = reader.ReadElementContentAsString();
return;
case "protocolVersion":
ProtocolVersion = reader.ReadElementContentAsString();
return;
case "requestHash":
RequestHash = ReadRequestHash(reader);
return;
}
}
throw XRoadException.InvalidQuery($"Unexpected X-Road header element `{reader.GetXName()}`.");
}
/// <summary>
/// Deserializes X-Road fault from message which is known to contain fault.
/// </summary>
public static IXRoadFault DeserializeXRoadFault(this IServiceMap serviceMap, XRoadMessage message)
{
message.ContentStream.Position = 0;
using (var reader = XmlReader.Create(message.ContentStream))
{
reader.MoveToPayload(message.RootElementName);
var responseName = serviceMap.ResponseValueDefinition.ResponseElementName;
if (!reader.MoveToElement(3, responseName))
{
throw XRoadException.InvalidQuery($"X-Road fault should be wrapped inside `{responseName}` element.");
}
return(reader.ReadXRoadFault(4));
}
}
/// <summary>
/// Check for presence of mandatory parts.
/// </summary>
public virtual void Validate()
{
if (Client == null)
{
throw XRoadException.InvalidQuery("X-Road header `client` element is mandatory.");
}
if (Id == null)
{
throw XRoadException.InvalidQuery("X-Road header `id` element is mandatory.");
}
if (ProtocolVersion == null)
{
throw XRoadException.InvalidQuery("X-Road header `protocolVersion` element is mandatory.");
}
}
private void ValidateRemainingProperties(ICollection <string> existingPropertyNames, ContentDefinition content)
{
if (existingPropertyNames.Count == requiredPropertiesCount.Value)
{
return;
}
var typeName = Definition?.Name ?? ((content.Particle as ArrayItemDefinition)?.Array as PropertyDefinition)?.DeclaringTypeDefinition?.Name;
var missingProperties = deserializationPropertyMaps.Where(kv => !existingPropertyNames.Contains(kv.Key) && !kv.Value.Definition.Content.IsOptional).Select(kv => $"`{kv.Key}`").ToList();
var propertyMessage = string.Join(", ", missingProperties);
var errorMessage = missingProperties.Count > 1
? $"Elements {propertyMessage} are required by type `{typeName}` definition."
: $"Element {propertyMessage} is required by type `{typeName}` definition.";
throw XRoadException.InvalidQuery(errorMessage);
}
private static XRoadObjectType GetObjectType(string value)
{
switch (value.Trim())
{
case "MEMBER":
return(XRoadObjectType.Member);
case "SUBSYSTEM":
return(XRoadObjectType.Subsystem);
case "SERVICE":
return(XRoadObjectType.Service);
case "CENTRALSERVICE":
return(XRoadObjectType.CentralService);
default:
throw XRoadException.InvalidQuery($"Invalid `{XName.Get("objectType", NamespaceConstants.XROAD_V4_ID)}` attribute value `{value}`.");
}
}
private TypeDefinition GetRuntimeTypeDefinition(XName qualifiedName)
{
if (!qualifiedName.NamespaceName.StartsWith("http://"))
{
var type = contractAssembly.GetType($"{qualifiedName.Namespace}.{qualifiedName.LocalName}");
return(type != null && type.IsXRoadSerializable() ? schemaDefinitionProvider.GetTypeDefinition(type) : null);
}
var typeDefinition = contractAssembly.GetTypes()
.Where(type => type.IsXRoadSerializable())
.Where(type => !Version.HasValue || type.GetTypeInfo().ExistsInVersion(Version.Value))
.Select(type => schemaDefinitionProvider.GetTypeDefinition(type))
.SingleOrDefault(definition => definition.Name == qualifiedName);
if (typeDefinition != null)
{
return(typeDefinition);
}
throw XRoadException.UnknownType(qualifiedName.ToString());
}
/// <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);
}
private static XRoadCentralServiceIdentifier ReadCentralService(XmlReader reader)
{
var qualifiedName = reader.GetXName();
if (reader.IsEmptyElement)
{
throw XRoadException.InvalidQuery($"Element `{qualifiedName}` cannot be empty.");
}
var centralService = new XRoadCentralServiceIdentifier();
var depth = reader.Depth;
var objectType = reader.GetAttribute("objectType", NamespaceConstants.XROAD_V4_ID);
if (string.IsNullOrWhiteSpace(objectType))
{
throw XRoadException.InvalidQuery($"Element `{qualifiedName}` must have attribute `{XName.Get("objectType", NamespaceConstants.XROAD_V4_ID)}` value.");
}
centralService.ObjectType = GetObjectType(objectType);
if (!reader.MoveToElement(depth + 1) || reader.LocalName != "xRoadInstance" || reader.NamespaceURI != NamespaceConstants.XROAD_V4_ID)
{
throw XRoadException.InvalidQuery($"Element `{qualifiedName}` must have child element `{XName.Get("xRoadInstance", NamespaceConstants.XROAD_V4_ID)}`.");
}
centralService.XRoadInstance = reader.ReadElementContentAsString();
if (!reader.MoveToElement(depth + 1) || reader.LocalName != "serviceCode" || reader.NamespaceURI != NamespaceConstants.XROAD_V4_ID)
{
throw XRoadException.InvalidQuery($"Element `{qualifiedName}` must have child element `{XName.Get("serviceCode", NamespaceConstants.XROAD_V4_ID)}`.");
}
centralService.ServiceCode = reader.ReadElementContentAsString();
if (reader.MoveToElement(depth + 1))
{
throw XRoadException.InvalidQuery($"Unexpected element `{reader.GetXName()}` in element `{qualifiedName}`.");
}
return(centralService);
}
private static Func <byte[], Encoding, byte[]> GetByteDecoder(string contentTransferEncoding)
{
if (string.IsNullOrEmpty(contentTransferEncoding))
{
return(null);
}
switch (contentTransferEncoding.ToLower())
{
case "quoted-printable":
case "7bit":
case "8bit":
case "binary":
return(null);
case "base64":
return(DecodeFromBase64);
default:
throw XRoadException.ToetamataKodeering(contentTransferEncoding);
}
}
private byte[] ReadNextPart(Stream targetStream, Func <byte[], Encoding, byte[]> decoder, Encoding useEncoding, byte[] boundaryMarker)
{
var addNewLine = false;
while (true)
{
byte[] buffer;
var chunkStop = ReadChunkOrLine(out buffer, BUFFER_SIZE);
if (boundaryMarker != null && BufferStartsWith(buffer, boundaryMarker))
{
return(buffer);
}
if (boundaryMarker != null && chunkStop == ChunkStop.EndOfStream)
{
throw XRoadException.MultipartManusegaSõnumiOotamatuLõpp();
}
if (decoder != null)
{
buffer = decoder(buffer, useEncoding);
}
if (decoder == null && addNewLine)
{
targetStream.Write(newLine, 0, newLine.Length);
}
targetStream.Write(buffer, 0, buffer.Length);
if (chunkStop == ChunkStop.EndOfStream)
{
return(buffer);
}
addNewLine = chunkStop == ChunkStop.NewLine;
}
}
