protected override object DoDeserializeValue(XmlReader reader, bool isSimpleValue) { ICollection <MLQueryResultGroup> result = new List <MLQueryResultGroup>(); if (SoapHelper.ReadEmptyStartElement(reader)) // Read start of enclosing element { return(result); } while (reader.NodeType != XmlNodeType.EndElement) { result.Add(MLQueryResultGroup.Deserialize(reader)); } reader.ReadEndElement(); // End of enclosing element return(result); }
public void TestSoapSerial() { TestClassSoap t = new TestClassSoap { Name = "t", Remark = "test", Soap = new TestClassSoap { Name = "i", Remark = "inner" }, }; testxml = SoapHelper.Serialize(t); }
private static void ImportMessageSoapAction(WsdlContractConversionContext contractContext, MessageDescription message, MessageBinding wsdlMessageBinding, bool isResponse) { string str = SoapHelper.ReadSoapAction(wsdlMessageBinding.OperationBinding); if (((contractContext != null) && (WsdlImporter.WSAddressingHelper.FindWsaActionAttribute(contractContext.GetOperationMessage(message)) == null)) && (str != null)) { if (isResponse) { message.Action = "*"; } else { message.Action = str; } } }
protected override object DoDeserializeValue(XmlReader reader, bool isSimpleValue) { IDictionary <string, MediaCategory_DTO> result_dtos = new Dictionary <string, MediaCategory_DTO>(); if (SoapHelper.ReadEmptyStartElement(reader)) // Read start of enclosing element { return(new List <MediaCategory>()); } while (reader.NodeType != XmlNodeType.EndElement) { MediaCategory_DTO result_dto = MediaCategory_DTO.Deserialize(reader); result_dtos.Add(result_dto.CategoryName, result_dto); } reader.ReadEndElement(); // End of enclosing element return(new List <MediaCategory>(result_dtos.Select(mCatDtoKvp => mCatDtoKvp.Value.GetMediaCategory(result_dtos)))); }
protected override object DoDeserializeValue(XmlReader reader, bool isSimpleValue) { if (SoapHelper.ReadEmptyStartElement(reader)) // Read start of enclosing element { return(null); } Schedule result = null; while (reader.NodeType != XmlNodeType.EndElement) { result = Schedule.Deserialize(reader); } reader.ReadEndElement(); // End of enclosing element return(result); }
public List <ShippingRate> GetShipmentRates(Shipment shipment) { System.Threading.Thread.Sleep(1500); return(new List <ShippingRate>() { new ShippingRate { PackageType = "Package", MailClass = "Endicia Ground", MailService = "Parcel", Zone = "5", Pricing = "Retail", TotalAmount = 23.44m, DeliveryDate = new System.DateTime().AddDays(3) }, new ShippingRate { PackageType = "Package", MailClass = "Endicia Express", MailService = "Letter", Zone = "5", Pricing = "Retail", TotalAmount = 11.32m, DeliveryDate = new System.DateTime().AddDays(2) }, new ShippingRate { PackageType = "Package", MailClass = "Endicia Mail", MailService = "Enveloope", Zone = "5", Pricing = "Retail", TotalAmount = 12.25m, DeliveryDate = new System.DateTime().AddDays(5) }, }); // create request object var requestObject = RequestHelper.CreatePostageRatesRequest(shipment); // send the request to change the passphrase var response = SoapHelper.ProcessRequest <PostageRatesResponse>(requestObject); if (response.Status != 0) { throw new Exception(response.ErrorMessage); } var results = new List <ShippingRate>(); foreach (var rate in response.PostagePrice) { results.Add(new ShippingRate { TotalAmount = rate.TotalAmount, MailClass = rate.MailClass, MailService = rate.Postage.MailService, Pricing = rate.Postage.Pricing, Zone = rate.Postage.Zone }); } return(results); }
static void ImportFaultSoapAction(WsdlContractConversionContext contractContext, FaultDescription fault, FaultBinding wsdlFaultBinding) { string soapAction = SoapHelper.ReadSoapAction(wsdlFaultBinding.OperationBinding); if (contractContext != null) { OperationFault wsdlOperationFault = contractContext.GetOperationFault(fault); string wsaAction = WsdlImporter.WSAddressingHelper.FindWsaActionAttribute(wsdlOperationFault); if (wsaAction == null && soapAction != null) { fault.Action = soapAction; } // } else { // } }
private void SubmitDiagnosticsResult(UserDetail userDetail, HttpPostedFileBase file, FormInformation info) { try { var dbxlTemplateName = ApplicationConstants.ScanDiagnosticsConstant.ScanDiagnosticsTemplateName; var dbxlUrl = ApplicationConstants.ScanDiagnosticsConstant.ScanDiagnosticsDbxlUrl; var dbxlUserName = ApplicationConstants.ScanDiagnosticsConstant.ScanDiagnosticsDbxlUserName; var dbxlPassword = ApplicationConstants.ScanDiagnosticsConstant.ScanDiagnosticsDbxlPassword; if (!String.IsNullOrWhiteSpace(dbxlTemplateName) && !String.IsNullOrWhiteSpace(dbxlUrl) && !String.IsNullOrWhiteSpace(dbxlUserName) && !String.IsNullOrWhiteSpace(dbxlPassword)) { var scanTemplateXml = GetQdScanTemplateXml(info, userDetail); var submitDocument = new SubmitDocument { docTypeName = dbxlTemplateName, xml = scanTemplateXml, name = file.FileName, author = userDetail.UserName }; var submitDocumentXml = GetSerializedXml <SubmitDocument>(submitDocument); dbxlUrl = String.Format("{0}{1}qdabrawebservice/DbxlDocumentService.asmx", dbxlUrl, dbxlUrl.EndsWith("/") ? string.Empty : "/"); SoapHelper.CallSoapService(new SoapServiceRequest { data = submitDocumentXml, overrideAction = false, soapServiceAction = "http://qdabra.com/webservices/SubmitDocument", url = dbxlUrl, useCookie = false }, new NetworkCredential(dbxlUserName, dbxlPassword)); } } catch { } }
private static void ImportFaultSoapAction(WsdlContractConversionContext contractContext, FaultDescription fault, FaultBinding wsdlFaultBinding) { string soapAction = SoapHelper.ReadSoapAction(wsdlFaultBinding.OperationBinding); if (contractContext != null) { OperationFault wsdlOperationFault = contractContext.GetOperationFault(fault); string wsaAction = WsdlImporter.WSAddressingHelper.FindWsaActionAttribute(wsdlOperationFault); if (wsaAction == null && soapAction != null) { fault.Action = soapAction; } //CONSIDER, hsomu: If WS-Addressing action was found, we should verify that it is the same as the SOAP action // (for the request message). } else { //CONSIDER, hsomu: verify SOAP action matches referenced contract.operation.message } }
protected static string CreateResultDocument(DvAction action, IList <OutParameter> outParameters, bool forceSimpleValues) { StringBuilder result = new StringBuilder(2000); using (StringWriterWithEncoding stringWriter = new StringWriterWithEncoding(result, UPnPConsts.UTF8_NO_BOM)) using (XmlWriter writer = XmlWriter.Create(stringWriter, UPnPConfiguration.DEFAULT_XML_WRITER_SETTINGS)) { SoapHelper.WriteSoapEnvelopeStart(writer, true); writer.WriteStartElement("u", action.Name + "Response", action.ParentService.ServiceTypeVersion_URN); foreach (OutParameter parameter in outParameters) { writer.WriteStartElement(parameter.Argument.Name); parameter.Argument.SoapSerializeArgument(parameter.Value, forceSimpleValues, writer); writer.WriteEndElement(); // parameter.Argument.Name } writer.WriteEndElement(); // u:[action.Name]Response SoapHelper.WriteSoapEnvelopeEndAndClose(writer); } return(result.ToString()); }
void IWsdlExportExtension.ExportEndpoint(WsdlExporter exporter, WsdlEndpointConversionContext endpointContext) { bool createdNew; MessageEncodingBindingElement encodingBindingElement = FindMessageEncodingBindingElement(endpointContext, out createdNew); bool useWebSocketTransport = WebSocketHelper.UseWebSocketTransport(this.WebSocketSettings.TransportUsage, endpointContext.ContractConversionContext.Contract.IsDuplex()); EndpointAddress address = endpointContext.Endpoint.Address; if (useWebSocketTransport) { address = new EndpointAddress(WebSocketHelper.GetWebSocketUri(endpointContext.Endpoint.Address.Uri), endpointContext.Endpoint.Address); WsdlNS.SoapAddressBinding binding = SoapHelper.GetSoapAddressBinding(endpointContext.WsdlPort); if (binding != null) { binding.Location = address.Uri.AbsoluteUri; } } TransportBindingElement.ExportWsdlEndpoint(exporter, endpointContext, this.GetWsdlTransportUri(useWebSocketTransport), address, encodingBindingElement.MessageVersion.Addressing); }
public static string CreateFaultDocument(uint errorCode, string errorDescription) { StringBuilder result = new StringBuilder(2000); using (StringWriterWithEncoding stringWriter = new StringWriterWithEncoding(result, UPnPConsts.UTF8_NO_BOM)) using (XmlWriter writer = XmlWriter.Create(stringWriter, UPnPConfiguration.DEFAULT_XML_WRITER_SETTINGS)) { SoapHelper.WriteSoapEnvelopeStart(writer, false); writer.WriteStartElement("Fault", UPnPConsts.NS_SOAP_ENVELOPE); string soapNamespacePrefix = writer.LookupPrefix(UPnPConsts.NS_SOAP_ENVELOPE); writer.WriteElementString("faultcode", soapNamespacePrefix + ":Client"); writer.WriteElementString("faultstring", "UPnPError"); writer.WriteStartElement("detail"); writer.WriteStartElement(string.Empty, "UPnPError", UPnPConsts.NS_UPNP_CONTROL); writer.WriteElementString("errorCode", errorCode.ToString()); writer.WriteElementString("errorDescription", errorDescription); writer.WriteEndElement(); // UPnPError writer.WriteEndElement(); // detail writer.WriteEndElement(); // s:Fault SoapHelper.WriteSoapEnvelopeEndAndClose(writer); } return(result.ToString()); }
internal static void ExportWsdlEndpoint(WsdlExporter exporter, WsdlEndpointConversionContext endpointContext, string wsdlTransportUri, AddressingVersion addressingVersion) { if (exporter == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("context"); } if (endpointContext == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("endpointContext"); } endpointContext.Endpoint.Binding.CreateBindingElements(); if (wsdlTransportUri != null) { SoapBinding orCreateSoapBinding = SoapHelper.GetOrCreateSoapBinding(endpointContext, exporter); if (orCreateSoapBinding != null) { orCreateSoapBinding.Transport = wsdlTransportUri; } } if (endpointContext.WsdlPort != null) { WsdlExporter.WSAddressingHelper.AddAddressToWsdlPort(endpointContext.WsdlPort, endpointContext.Endpoint.Address, addressingVersion); } }
public void BasicSoapAuthTest() { var authenticationHeader = OAuthHelper.GetAuthenticationHeader(); var serviceUriString = SoapHelper.GetSoapServiceUriString(UserSessionServiceName, ClientConfiguration.Default.UriString); var endpointAddress = new System.ServiceModel.EndpointAddress(serviceUriString); var binding = SoapHelper.GetBinding(); var client = new UserSessionServiceClient(binding, endpointAddress); var channel = client.InnerChannel; UserSessionInfo sessionInfo = null; using (OperationContextScope operationContextScope = new OperationContextScope(channel)) { HttpRequestMessageProperty requestMessage = new HttpRequestMessageProperty(); requestMessage.Headers[OAuthHelper.OAuthHeader] = authenticationHeader; OperationContext.Current.OutgoingMessageProperties[HttpRequestMessageProperty.Name] = requestMessage; sessionInfo = ((UserSessionService)channel).GetUserSessionInfo(new GetUserSessionInfo()).result; } Assert.IsNotNull(sessionInfo); Assert.IsNotNull(sessionInfo.UserId); }
private ActionResult InternalCallSoapService(SoapServiceRequest request) { // TODO: Add SSO handling SoapResult result = new SoapResult(); try { // 2017/03/02 -- Move the code to SoapHelper. var uploadResult = SoapHelper.CallSoapService(request, GetCredentials(request.url)); result.resultBody = GetBodyFromSoapResult(uploadResult); result.success = true; } catch (WebException ex) { if (ex.Response == null) { result.message = String.Format("The request to the service failed with an error: {0}", ex.Message); } else { var fault = GetSoapFault(ex); result.fault = fault; result.message = !String.IsNullOrWhiteSpace(fault.faultstring) ? String.Format("The service failed with an error: {0}", fault.faultstring) : String.Format("The request failed with status {0}", fault.faultcode); } } catch (Exception ex) { result.message = String.Format("The request to the service failed with an error: {0}", ex.Message); } return(new ObjectResult <SoapResult>(result)); }
/// <summary> /// Adds "wsse:security" element to a message, or replaces existing element. /// </summary> /// <param name="request">Request string.</param> /// <returns>Request string with added (updated) "wsse:security" element.</returns> public string ApplySecurity(string request) { DeviceEnvironment env = ContextController.GetDeviceEnvironment(); string secureRequest; if (!string.IsNullOrEmpty(env.Credentials.UserName)) { SoapHelper soapHelper = new SoapHelper(); secureRequest = soapHelper.ApplySecurity( request, env.Credentials.UserName, env.Credentials.Password, env.Credentials.UseUTCTimeStamp, true); } else { secureRequest = request; } return(secureRequest); }
public override async Task <ResponseInfo> GetRates(RequestInfo request, ServerCallContext context) { var response = new ResponseInfo(); var res = await SoapHelper.CallWebService( CBR_DAILY_SERIVCE_URL, NAMESPACE, VERB, "GetCursOnDate", new Dictionary <string, string> { { "On_date", DateTime.Now.ToString("yyyy-MM-dd") }, }); var doc = new XmlDocument(); doc.LoadXml(res); var datas = doc.SelectNodes("//ValuteCursOnDate"); _context.Rates.RemoveRange(_context.Rates); _context.SaveChanges(); foreach (XmlElement data in datas) { try { _context.Rates.Add(new CbrRate { Code = data.SelectSingleNode("VchCode").InnerText.Trim(), Title = data.SelectSingleNode("Vname").InnerText.Trim(), Count = short.Parse(data.SelectSingleNode("Vnom").InnerText), Rate = double.Parse(data.SelectSingleNode("Vcurs").InnerText, CultureInfo.InvariantCulture), }); } catch (Exception ex) { Debug.WriteLine(ex.Message); } } _context.SaveChanges(); var rates = await GetDataFromContextByODataFilterAsync <DataContext, IEnumerable <DtoRate> >(request.Query); foreach (var rate in rates) { var eRate = new ExchangeRate { Code = new StringValue(), Title = new StringValue(), Count = new Int32Value(), Rate = new DoubleValue() }; if (!string.IsNullOrEmpty(rate.Code)) { eRate.Code.Value = rate.Code; } if (!string.IsNullOrEmpty(rate.Title)) { eRate.Title.Value = rate.Title; } if (rate.Count.HasValue) { eRate.Count.Value = rate.Count.Value; } if (rate.Rate.HasValue) { eRate.Rate.Value = rate.Rate.Value; } response.Rates.Add(eRate); } return(response); }
/// <summary> /// Helper method to be used within the <see cref="SoapDeserializeValue"/> method to check if the serialization is /// a <c>null</c> value. /// The reader will read the end element tag after it encountered a <c>null</c> value. /// </summary> /// <param name="reader">XML reader which is positioned at the starting tag of the XML element enclosing the value.</param> protected bool SoapReadNull(XmlReader reader) { return(SoapHelper.ReadNull(reader)); }
/// <summary> /// Helper method to be used within the <see cref="SoapSerializeValue"/> method to write a <c>null</c> value /// into a SOAP serialization. /// </summary> /// <param name="writer">XML writer which is positioned at the starting tag of the XML element enclosing the value.</param> protected void SoapWriteNull(XmlWriter writer) { SoapHelper.WriteNull(writer); }
public async Task <String> GetMethodRequest(string uri, string method) { var soapRequest = await SoapHelper.BuildSoapRequest(uri, method); return(XmlFormatParserHelper.GetFormattedXml(soapRequest)); }
protected static IList <object> ParseResult(TextReader textReader, CpAction action, bool sourceSupportsUPnP11) { object[] outParameterValues = new object[action.OutArguments.Count]; using (XmlReader reader = XmlReader.Create(textReader, UPnPConfiguration.DEFAULT_XML_READER_SETTINGS)) { reader.MoveToContent(); // Parse SOAP envelope reader.ReadStartElement("Envelope", UPnPConsts.NS_SOAP_ENVELOPE); reader.ReadStartElement("Body", UPnPConsts.NS_SOAP_ENVELOPE); // Reader is positioned at the action element string serviceTypeVersion_URN = reader.NamespaceURI; string type; int version; // Parse service and action if (!ParserHelper.TryParseTypeVersion_URN(serviceTypeVersion_URN, out type, out version)) { throw new ArgumentException("Invalid service type or version"); } string actionName = reader.LocalName; if (!actionName.EndsWith("Response") || actionName.Substring(0, actionName.Length - "Response".Length) != action.Name) { throw new ArgumentException("Invalid action name in result message"); } // UPnP spec says we have to be able to handle return values being out // of order to support UPnP 1.0 devices. See UPnP-arch-DeviceArchitecture-v1.1 // section 2.5.4. We need a dictionary to make this easy. IDictionary <string, int> formalArgIdxDictionary = new Dictionary <string, int>(); for (int i = 0; i < action.OutArguments.Count; i++) { formalArgIdxDictionary.Add(action.OutArguments[i].Name, i); } int outArgCount = 0; if (!SoapHelper.ReadEmptyStartElement(reader)) { // Parse and check output parameters while (reader.NodeType != XmlNodeType.EndElement) { string argumentName = reader.Name; // Arguments don't have a namespace, so take full name int formalArgumentIndex; if (!formalArgIdxDictionary.TryGetValue(argumentName, out formalArgumentIndex)) { throw new ArgumentException("Invalid argument name"); } CpArgument formalArgument = action.OutArguments[formalArgumentIndex]; // Get the argument value and store it in the correct position in the return list. object value = null; if (!SoapHelper.ReadNull(reader)) { formalArgument.SoapParseArgument(reader, !sourceSupportsUPnP11, out value); } outParameterValues[formalArgumentIndex] = value; outArgCount++; // Don't allow duplicates of the same argument. formalArgIdxDictionary.Remove(formalArgument.Name); } } if (outArgCount != action.OutArguments.Count) // Too few arguments { throw new ArgumentException("Invalid out argument count"); } } return(outParameterValues); }
/// <summary> /// Serializes the given <paramref name="value"/> as contents of the current element in the /// given XML <paramref name="writer"/> in the formatting rules given by this data type. /// </summary> /// <param name="value">Value to serialize. The value must be of this data type.</param> /// <param name="writer">XML writer where the value will be serialized to. The value will be serialized as /// contents of the writer's current element. /// The writer's position is the start of the parent element, the result should go. The caller will write the end /// element tag.</param> public void SoapSerializeValue(object value, XmlWriter writer) { if (value == null) { SoapHelper.WriteNull(writer); return; } switch (_upnpTypeName) { case "ui1": case "ui2": case "ui4": case "ui8": case "i1": case "i2": case "i4": case "i8": case "int": writer.WriteString(value.ToString()); break; case "r4": case "r8": case "number": case "float": writer.WriteString(((Double)value).ToString("E", CultureInfo.InvariantCulture)); break; case "fixed.14.4": writer.WriteString(((Double)value).ToString("0.##############E+0", CultureInfo.InvariantCulture)); break; case "char": case "string": case "uuid": writer.WriteString(value.ToString()); break; case "date": writer.WriteString(((DateTime)value).ToString("yyyy-MM-dd")); break; case "dateTime": writer.WriteString(((DateTime)value).ToString("s")); break; case "dateTime.tz": writer.WriteString(((DateTime)value).ToUniversalTime().ToString("u")); break; case "time": writer.WriteString(((DateTime)value).ToString("T")); break; case "time.tz": writer.WriteString(((DateTime)value).ToUniversalTime().ToString("hh:mm:ss")); break; case "boolean": writer.WriteValue((bool)value); break; case "bin.base64": writer.WriteValue(value); break; case "bin.hex": writer.WriteString(EncodingUtils.ToHexString((byte[])value)); break; case "uri": writer.WriteString(((Uri)value).AbsoluteUri); break; default: throw new NotImplementedException(string.Format("UPnP standard data type '{0}' is not implemented", _upnpTypeName)); } }
public IntegrationContract() { _soapHelper = AutofacHostFactory.Container.Resolve <SoapHelper>(); _mediator = AutofacHostFactory.Container.Resolve <IMediator>(); }
private void ProcessWSERequest(SoapEnvelope envelope, WSE.Security security) { // by default we consider that SOAP messages is not signed bool IsSigned = false; // if security element is null // the call is made not from WSE-enabled client if (security != null) { foreach (ISecurityElement element in security.Elements) { if (element is MessageSignature) { // The given context contains a Signature element. MessageSignature sign = element as MessageSignature; if (CheckSignature(envelope, security, sign)) { // The SOAP message is signed. if (sign.SigningToken is UsernameToken) { UsernameToken token = sign.SigningToken as UsernameToken; // The SOAP message is signed // with a UsernameToken. IsSigned = true; } } } } } // throw an exception if the message did not pass all the tests if (!IsSigned) { throw new SecurityFault("SOAP response should be signed."); } // check encryption bool IsEncrypted = false; foreach (ISecurityElement element in security.Elements) { if (element is EncryptedData) { EncryptedData encryptedData = element as EncryptedData; System.Xml.XmlElement targetElement = encryptedData.TargetElement; if (SoapHelper.IsBodyElement(targetElement)) { // The given SOAP message has the Body element Encrypted. IsEncrypted = true; } } } if (!IsEncrypted) { throw new SecurityFault("SOAP response should be encrypted."); } }
public WebServiceSituationCenter() { _soapHelper = AutofacHostFactory.Container.Resolve <SoapHelper>(); _mediator = AutofacHostFactory.Container.Resolve <IMediator>(); }
/// <summary> /// Handler method for SOAP control requests. /// </summary> /// <param name="service">The service whose action was called.</param> /// <param name="messageStream">The stream which contains the HTTP message body with the SOAP envelope.</param> /// <param name="streamEncoding">Encoding of the <paramref name="messageStream"/>.</param> /// <param name="subscriberSupportsUPnP11">Should be set if the requester sent a user agent header which denotes a UPnP /// version of 1.1. If set to <c>false</c>, in- and out-parameters with extended data type will be deserialized/serialized /// using the string-equivalent of the values.</param> /// <param name="context">Context object holding data for the current action call.</param> /// <param name="result">SOAP result - may be an action result, a SOAP fault or <c>null</c> if no body should /// be sent in the HTTP response.</param> /// <returns>HTTP status code to be sent. Should be /// <list> /// <item><see cref="HttpStatusCode.OK"/> If the action could be evaluated correctly and produced a SOAP result.</item> /// <item><see cref="HttpStatusCode.InternalServerError"/> If the result is a SOAP fault.</item> /// <item><see cref="HttpStatusCode.BadRequest"/> If the message stream was malformed.</item> /// </list> /// </returns> public static HttpStatusCode HandleRequest(DvService service, Stream messageStream, Encoding streamEncoding, bool subscriberSupportsUPnP11, CallContext context, out string result) { UPnPError res; try { IList <object> inParameterValues = null; // Default to null if there aren't parameters, will be lazily initialized later DvAction action; using (StreamReader streamReader = new StreamReader(messageStream, streamEncoding)) using (XmlReader reader = XmlReader.Create(streamReader, UPnPConfiguration.DEFAULT_XML_READER_SETTINGS)) { reader.MoveToContent(); // Parse SOAP envelope reader.ReadStartElement("Envelope", UPnPConsts.NS_SOAP_ENVELOPE); reader.ReadStartElement("Body", UPnPConsts.NS_SOAP_ENVELOPE); // Reader is positioned at the action element string serviceTypeVersion_URN = reader.NamespaceURI; string type; int version; // Parse service and action if (!ParserHelper.TryParseTypeVersion_URN(serviceTypeVersion_URN, out type, out version)) { throw new MediaPortal.Utilities.Exceptions.InvalidDataException("Unable to parse service type and version URN '{0}'", serviceTypeVersion_URN); } string actionName = reader.LocalName; if (!service.Actions.TryGetValue(actionName, out action)) { result = CreateFaultDocument(401, "Invalid Action"); return(HttpStatusCode.InternalServerError); } IEnumerator <DvArgument> formalArgumentEnumer = action.InArguments.GetEnumerator(); if (!SoapHelper.ReadEmptyStartElement(reader)) // Action name { while (reader.NodeType != XmlNodeType.EndElement) { string argumentName = reader.Name; // Arguments don't have a namespace, so take full name if (!formalArgumentEnumer.MoveNext() || formalArgumentEnumer.Current.Name != argumentName) { // Too many arguments result = CreateFaultDocument(402, "Invalid Args"); return(HttpStatusCode.InternalServerError); } object value; if (SoapHelper.ReadNull(reader)) { value = null; } else { res = formalArgumentEnumer.Current.SoapParseArgument(reader, !subscriberSupportsUPnP11, out value); if (res != null) { result = CreateFaultDocument(res.ErrorCode, res.ErrorDescription); return(HttpStatusCode.InternalServerError); } } if (inParameterValues == null) { inParameterValues = new List <object>(); } inParameterValues.Add(value); } } if (formalArgumentEnumer.MoveNext()) { // Too few arguments result = CreateFaultDocument(402, "Invalid Args"); return(HttpStatusCode.InternalServerError); } } IList <object> outParameterValues; // Invoke action try { res = action.InvokeAction(inParameterValues, out outParameterValues, false, context); // outParameterValues can be null if the action has no output parameters. Setting it to an empty list makes // it easier to check parameter count later. if (outParameterValues == null) { outParameterValues = EMPTY_OBJECT_LIST; } } catch (Exception e) { UPnPConfiguration.LOGGER.Warn("SOAPHandler: Error invoking UPnP action '{0}'", e, action.Name); result = CreateFaultDocument(501, "Action Failed"); return(HttpStatusCode.InternalServerError); } if (res != null) { result = CreateFaultDocument(res.ErrorCode, res.ErrorDescription); return(HttpStatusCode.InternalServerError); } // Check output parameters IList <DvArgument> formalArguments = action.OutArguments; if (outParameterValues.Count != formalArguments.Count) { result = CreateFaultDocument(501, "Action Failed"); return(HttpStatusCode.InternalServerError); } IList <OutParameter> outParams = formalArguments.Select((t, i) => new OutParameter(t, outParameterValues[i])).ToList(); result = CreateResultDocument(action, outParams, !subscriberSupportsUPnP11); return(HttpStatusCode.OK); } catch (Exception e) { string message = "Error handling SOAP request: " + e.Message; UPnPConfiguration.LOGGER.Warn(message); // Don't log the whole exception; it's only a communication error with a client result = CreateFaultDocument(500, message); // Also send message to client return(HttpStatusCode.InternalServerError); } }
public void TestSoapDeserial() { var s = SoapHelper.Deserialize(testxml); }
public static MediaItemAspect Deserialize(XmlReader reader) { if (!reader.MoveToAttribute("Id")) { throw new ArgumentException("Media item aspect cannot be deserialized: 'Id' attribute missing"); } Guid aspectTypeId = new Guid(reader.ReadContentAsString()); bool deleted = false; if (reader.MoveToAttribute("Deleted")) { deleted = reader.ReadContentAsBoolean(); } reader.MoveToElement(); IMediaItemAspectTypeRegistration miatr = ServiceRegistration.Get <IMediaItemAspectTypeRegistration>(); MediaItemAspectMetadata miaType; if (!miatr.LocallyKnownMediaItemAspectTypes.TryGetValue(aspectTypeId, out miaType)) { throw new ArgumentException(string.Format("Media item aspect cannot be deserialized: Unknown media item aspect type '{0}' in [{1} / {2}]", aspectTypeId, string.Join(",", miatr.LocallyKnownMediaItemAspectTypes.Keys), string.Join(",", miatr.LocallyKnownMediaItemAspectTypes.Values.ToList().Select(x => x.Name)))); } MediaItemAspect result = null; if (miaType is SingleMediaItemAspectMetadata) { result = new SingleMediaItemAspect((SingleMediaItemAspectMetadata)miaType); } else if (miaType is MultipleMediaItemAspectMetadata) { result = new MultipleMediaItemAspect((MultipleMediaItemAspectMetadata)miaType); } result.Deleted = deleted; if (SoapHelper.ReadEmptyStartElement(reader, "Aspect")) { return(result); } while (reader.NodeType != XmlNodeType.EndElement) { if (!reader.MoveToAttribute("Name")) { throw new ArgumentException("Media item aspect attribute cannot be deserialized: 'Name' attribute missing"); } String attributeName = reader.ReadContentAsString(); reader.MoveToElement(); if (SoapHelper.ReadEmptyStartElement(reader, "Attr")) { continue; } MediaItemAspectMetadata.AttributeSpecification attributeSpec; if (!miaType.AttributeSpecifications.TryGetValue(attributeName, out attributeSpec)) { throw new ArgumentException(string.Format( "Media item aspect attribute cannot be deserialized: Unknown attribute specification '{0}'", attributeName)); } if (attributeSpec.IsCollectionAttribute) { IList valuesCollection = attributeSpec.CreateValuesCollection(); while (reader.NodeType != XmlNodeType.EndElement) { valuesCollection.Add(DeserializeValue(reader, attributeSpec.AttributeType)); } result.SetCollectionAttribute(attributeSpec, valuesCollection); } else { result.SetAttribute(attributeSpec, DeserializeValue(reader, attributeSpec.AttributeType)); } reader.ReadEndElement(); // Attr } reader.ReadEndElement(); // Aspect return(result); }
public WebServiceIntelEGov() { _soapHelper = AutofacHostFactory.Container.Resolve <SoapHelper>(); _mediator = AutofacHostFactory.Container.Resolve <IMediator>(); }
/// <summary> /// Deserializes the contents of the given XML <paramref name="reader"/>'s current element in the formatting rules /// given by this data type. /// </summary> /// <param name="reader">XML reader whose current element's value will be deserialized. /// The reader's position is the start of the parent element, the result should go. After this method returns, the reader /// must have read the end element.</param> /// <returns>Deserialized object of this data type (may be <c>null</c>).</returns> public object SoapDeserializeValue(XmlReader reader) { object result; if (SoapHelper.ReadNull(reader)) { result = null; } else { switch (_upnpTypeName) { case "ui1": case "ui2": case "ui4": case "ui8": case "i1": case "i2": case "i4": case "i8": case "int": case "r4": case "r8": case "number": case "fixed.14.4": case "float": case "char": result = reader.ReadElementContentAs(_dotNetType, null); break; case "string": case "uuid": result = reader.ReadElementContentAsString(); break; case "date": result = System.DateTime.ParseExact(reader.ReadElementContentAsString(), "yyyy-MM-dd", null); break; case "dateTime": result = System.DateTime.ParseExact(reader.ReadElementContentAsString(), "s", null); break; case "dateTime.tz": result = System.DateTime.ParseExact(reader.ReadElementContentAsString(), "u", null).ToLocalTime(); break; case "time": result = System.DateTime.ParseExact(reader.ReadElementContentAsString(), "T", null); break; case "time.tz": result = System.DateTime.ParseExact(reader.ReadElementContentAsString(), "hh:mm:ss", null).ToLocalTime(); break; case "boolean": result = reader.ReadElementContentAs(_dotNetType, null); break; case "bin.base64": result = reader.ReadElementContentAs(_dotNetType, null); break; case "bin.hex": result = EncodingUtils.FromHexString(reader.ReadElementContentAsString()); break; case "uri": result = new Uri(reader.ReadElementContentAsString()); break; default: throw new NotImplementedException(string.Format("UPnP standard data type '{0}' is not implemented", _upnpTypeName)); } // Reader will already have read the end element in the methods ReadElementContentXXX } return(result); }