public Fault(FaultException e) : base(e.Reason.ToString(), e)
{
this.Code = "qc:E502"; // 502 : by default a bad gateway
if (e.Code.SubCode != null)
{
Code = formatFaultCode(e.Code.SubCode);
}
if (e.Code.SubCode.SubCode != null)
{
SubCode = formatFaultCode(e.Code.SubCode.SubCode);
}
MessageFault msgFault = e.CreateMessageFault();
if (msgFault.HasDetail)
{
MessageInserts = msgFault.GetReaderAtDetailContents().ReadOuterXml();
XmlReader reader = msgFault.GetReaderAtDetailContents();
if (reader.ReadToFollowing("messageInserts"))
{
MessageInserts = reader.ReadOuterXml();
}
}
}
public Fault(FaultException e) : base(e.Reason.ToString(), e)
{
if (e.Code.SubCode != null)
{
Code = e.Code.SubCode.Name;
}
else
{
Code = "502";
}
if (e.Code.SubCode.SubCode != null)
{
SubCode = e.Code.SubCode.SubCode.Name;
}
MessageFault msgFault = e.CreateMessageFault();
if (msgFault.HasDetail)
{
MessageInserts = msgFault.GetReaderAtDetailContents().ReadOuterXml();
XmlReader reader = msgFault.GetReaderAtDetailContents();
if (reader.ReadToFollowing("messageInserts"))
{
MessageInserts = reader.ReadOuterXml();
}
}
}
public static AdwsFault ConstructFault(Message response)
{
AdwsFault adwsFault;
MessageBuffer buffer = AdwsMessage.MessageToBuffer(response);
MessageFault messageFault = MessageFault.CreateFault(AdwsMessage.BufferToMessage(buffer), 0x500000);
object obj = null;
if (messageFault.HasDetail)
{
try
{
string str = string.Concat(messageFault.Code.SubCode.Namespace, ":", messageFault.Code.SubCode.Name);
Type item = (Type)AdwsFaultUtil._faultSubCodeType[str];
if (item != null)
{
XmlReader readerAtDetailContents = messageFault.GetReaderAtDetailContents();
XmlSerializer xmlSerializer = new XmlSerializer(item);
obj = xmlSerializer.Deserialize(readerAtDetailContents);
}
}
catch (Exception exception)
{
}
}
if (obj == null)
{
adwsFault = new AdwsFault(messageFault);
}
else
{
adwsFault = new AdwsFault(messageFault, obj);
}
return(adwsFault);
}
public async void EditVideoAsync(VideoSubmition v)
{
try
{
using (EnsureCredentialsUseContext context = new EnsureCredentialsUseContext(
this.Username, this.Password, this.AccessKey, _client.InnerChannel))
{
await this._client.EditVideoAsync(v, null, null);
}
}
catch (FaultException faultException)
{
MessageFault messageFault = faultException.CreateMessageFault();
if (messageFault.HasDetail)
{
string innerErrorXml;
using (var xmlReader = messageFault.GetReaderAtDetailContents())
{
innerErrorXml = xmlReader.ReadInnerXml();
}
if (innerErrorXml != null)
{
throw new Exception(innerErrorXml);
}
throw;
}
}
}
public IAsyncOperation <string> DummyEchoAsync(string echoStr)
{
try
{
using (EnsureCredentialsUseContext context = new EnsureCredentialsUseContext(
this.Username, this.Password, this.Accesskey, _client.InnerChannel))
{
return(_client
.DummyEchoAsync(echoStr)
.ContinueWith(t => t.Result.DummyEchoResult)
.AsAsyncOperation());
}
}
catch (FaultException faultException)
{
MessageFault messageFault = faultException.CreateMessageFault();
if (messageFault.HasDetail)
{
string innerErrorXml;
using (var xmlReader = messageFault.GetReaderAtDetailContents())
{
innerErrorXml = xmlReader.ReadInnerXml();
}
if (innerErrorXml != null)
{
throw new Exception(innerErrorXml);
}
throw;
}
}
throw new Exception("Request cannot be fulfilled");
}
private static void LogFaultException(FaultException ex)
{
if (ex == null)
{
return;
}
try
{
TraceHelper.WriteError("Fault Exception");
TraceHelper.WriteError("Fault Message: {0}", ex.Message);
TraceHelper.WriteError("Fault Action: {0}", ex.Action);
TraceHelper.WriteError("Fault Code: {0}-{1}", ex.Code.Name, ex.Code);
TraceHelper.WriteError("Fault Reason: {0}", ex.Reason);
MessageFault fault = ex.CreateMessageFault();
if (fault.HasDetail)
{
XmlReader reader = fault.GetReaderAtDetailContents();
if (reader != null && reader.Name == "ExceptionDetail")
{
var detail = fault.GetDetail <ExceptionDetail>();
if (detail != null)
{
TraceHelper.WriteError("-Detail Message: {0}", detail.Message);
TraceHelper.WriteError("-Detail Stack: {0}", detail.StackTrace);
}
}
}
}
catch (Exception e)
{
TraceHelper.WriteError("Error handling Fault Exception: {0}", e.Message);
}
}
static public bool TryCreateFault(Message message, MessageFault fault, out MakeConnectionMessageFault wsmcFault)
{
// all WS-MakeConnection faults are receiver faults
if (!fault.Code.IsReceiverFault)
{
wsmcFault = null;
return(false);
}
if ((fault.Code.SubCode == null) ||
(fault.Code.SubCode.Namespace != MakeConnectionConstants.Namespace))
{
wsmcFault = null;
return(false);
}
XmlDictionaryReader detailReader = null;
string subcodeName = fault.Code.SubCode.Name;
if (fault.HasDetail)
{
detailReader = fault.GetReaderAtDetailContents();
}
wsmcFault = CreateMakeConnectionFault(message, fault.Code, subcodeName, fault.Reason, detailReader);
return(wsmcFault != null);
}
// TO DO: Add this method to SellBitcoins
private async void GetQuote()
{
try
{
// Gets a quote for bitcoins - Not a balance. Bad Method Name - TODO
FiatAmount = Convert.ToDecimal(txtAmount.Text);
// TODO: Refresh Service Reference
// BitcoinAmount = await client.GetBitcoinAmountAsync(FiatAmount, "AUD");
Price = BitcoinAmount / FiatAmount;
txtBitcoins.Text = BitcoinAmount.ToString();
txtRate.Text = Price.ToString();
}
catch (FaultException ex)
{
string msg = "FaultException: " + ex.Message;
MessageFault fault = ex.CreateMessageFault();
if (fault.HasDetail == true)
{
System.Xml.XmlReader reader = fault.GetReaderAtDetailContents();
if (reader.Name == "ExceptionDetail")
{
ExceptionDetail detail = fault.GetDetail <ExceptionDetail>();
msg += "\n\nStack Trace: " + detail.StackTrace;
}
}
MessageBox.Show(msg);
}
}
public static Exception GetExceptionFromFaultMessage(MessageFault fault)
{
if (fault.Code?.SubCode == null)
{
return(new FaultException(fault));
}
switch (fault.Code.SubCode.Name)
{
case "InvalidRepresentation":
return(GetInvalidRepresentationException(fault));
case "PermissionDenied":
return(GetPermissionDeniedException(fault));
case "UnwillingToPerform":
return(GetUnwillingToPerformException(fault));
case "AuthorizationRequiredFault":
return(GetAuthorizationRequiredException(fault));
default:
break;
}
return(new FaultException(fault, fault.GetReaderAtDetailContents().ReadOuterXml()));
}
public static T DeserializeMessageWithPayload <T>(this MessageFault messageWithPayload)
{
if (!messageWithPayload.HasDetail)
{
return(default(T));
}
if (typeof(IXmlSerializable).IsAssignableFrom(typeof(T)))
{
IXmlSerializable serializable = (IXmlSerializable)Activator.CreateInstance(typeof(T));
serializable.ReadXml(messageWithPayload.GetReaderAtDetailContents());
return((T)serializable);
}
XmlSerializer xs = new XmlSerializer(typeof(T));
return((T)xs.Deserialize(messageWithPayload.GetReaderAtDetailContents()));
}
private void FillErrors(MessageFault messageFault)
{
var reader = messageFault.GetReaderAtDetailContents();
XElement xElement = (XElement)XNode.ReadFrom(reader);
Errors = new List <T>();
xElement.Elements().ForEach(x => Errors.Add(x.DeserializeFromXML <T>()));
}
private static void CreateFaultException(Message message)
{
//TODO: Get the maxFaultSize from somewhere other than a hardcoded version.
MessageFault messageFault = MessageFault.CreateFault(message, 0x10000);
XmlDictionaryReader reader = messageFault.GetReaderAtDetailContents();
DataContractSerializer serializer = new DataContractSerializer(typeof(InfoServiceFaultContract));
InfoServiceFaultContract faultContract = (InfoServiceFaultContract)serializer.ReadObject(reader);
throw new FaultException <InfoServiceFaultContract>(faultContract, messageFault.Reason, messageFault.Code, message.Headers.Action);
}
protected override FaultException CreateFaultException(MessageFault messageFault, string action)
{
IList <XmlSerializerOperationBehavior.Reflector.XmlSerializerFaultContractInfo> faultInfos;
if (action != null)
{
faultInfos = new List <XmlSerializerOperationBehavior.Reflector.XmlSerializerFaultContractInfo>();
for (int i = 0; i < _xmlSerializerFaultContractInfos.Count; i++)
{
if (_xmlSerializerFaultContractInfos[i].FaultContractInfo.Action == action ||
_xmlSerializerFaultContractInfos[i].FaultContractInfo.Action == MessageHeaders.WildcardAction)
{
faultInfos.Add(_xmlSerializerFaultContractInfos[i]);
}
}
}
else
{
faultInfos = _xmlSerializerFaultContractInfos;
}
Type detailType = null;
object detailObj = null;
for (int i = 0; i < faultInfos.Count; i++)
{
XmlSerializerOperationBehavior.Reflector.XmlSerializerFaultContractInfo faultInfo = faultInfos[i];
XmlDictionaryReader detailReader = messageFault.GetReaderAtDetailContents();
XmlObjectSerializer serializer = faultInfo.Serializer;
if (serializer.IsStartObject(detailReader))
{
detailType = faultInfo.FaultContractInfo.Detail;
try
{
detailObj = serializer.ReadObject(detailReader);
FaultException faultException = CreateFaultException(messageFault, action,
detailObj, detailType, detailReader);
if (faultException != null)
{
return(faultException);
}
}
catch (SerializationException)
{
}
}
}
return(new FaultException(messageFault, action));
}
private static MethodFault GetVIServerFault(FaultException soapEx)
{
if (soapEx == null)
{
throw new ArgumentNullException("soapEx");
}
PropertyInfo property = soapEx.GetType().GetTypeInfo().GetProperty("Detail");
VimApi_65.MethodFault methodFault;
if (property != (PropertyInfo)null)
{
methodFault = property.GetValue((object)soapEx) as VimApi_65.MethodFault;
}
else
{
MessageFault messageFault = soapEx.CreateMessageFault();
XmlSerializer xmlSerializer = FaultUtility.GetFaultSerializer();
if (xmlSerializer == null)
{
/* XElement xelement = (XElement)XNode.ReadFrom((XmlReader)messageFault.GetReaderAtDetailContents());
* System.Type type = typeof(VimApi_65.MethodFault).Assembly.GetType(string.Format("{0}.{1}", (object)typeof(VimApi_65.MethodFault).Namespace, (object)xelement.Attribute(XName.Get("type", "http://www.w3.org/2001/XMLSchema-instance")).Value));
* XmlRootAttribute xmlRootAttribute = new XmlRootAttribute(xelement.Name.LocalName);
* // ISSUE: variable of the null type
* __Null local1 = null;
* // ISSUE: variable of the null type
* __Null local2 = null;
* XmlRootAttribute root = xmlRootAttribute;
* string defaultNamespace = "urn:vim25";
* xmlSerializer = new XmlSerializer(type, (XmlAttributeOverrides)local1, (System.Type[])local2, root, defaultNamespace); */
XElement xElement = (XElement)XNode.ReadFrom(messageFault.GetReaderAtDetailContents());
XAttribute xAttribute = xElement.Attribute(XName.Get("type", "http://www.w3.org/2001/XMLSchema-instance"));
string name = string.Format("{0}.{1}", typeof(VimApi_65.MethodFault).Namespace, xAttribute.Value);
Type arg_D0_0 = typeof(VimApi_65.MethodFault).Assembly.GetType(name);
XmlRootAttribute root = new XmlRootAttribute(xElement.Name.LocalName);
xmlSerializer = new XmlSerializer(arg_D0_0, null, null, root, "urn:vim25");
}
StringReader stringReader = new StringReader(messageFault.GetDetail <XElement>().ToString().Replace("xsd:", ""));
using (XmlReader xmlReader = XmlReader.Create((TextReader)stringReader, new XmlReaderSettings()
{
ConformanceLevel = ConformanceLevel.Fragment,
CloseInput = true
}))
{
int content = (int)xmlReader.MoveToContent();
methodFault = xmlSerializer.Deserialize(xmlReader) as VimApi_65.MethodFault;
}
}
return(VIConvert.ToVim((object)methodFault) as MethodFault);
}
public async Task <string> CreateVideoAsync(IStorageFile file, Video v)
{
VideoSubmition videoSubmition = new VideoSubmition
{
Tags = v.Tags,
Title = v.Title,
Synopse = v.Synopse
};
Video createdVideo = null;
try
{
using (EnsureCredentialsUseContext context = new EnsureCredentialsUseContext(
this.Username, this.Password, this.AccessKey, _client.InnerChannel))
{
createdVideo = await this._client.AddVideoPostAsync(videoSubmition, null);
}
}
catch (FaultException faultException)
{
MessageFault messageFault = faultException.CreateMessageFault();
if (messageFault.HasDetail)
{
string innerErrorXml;
using (var xmlReader = messageFault.GetReaderAtDetailContents())
{
innerErrorXml = xmlReader.ReadInnerXml();
}
if (innerErrorXml != null)
{
throw new Exception(innerErrorXml);
}
throw;
}
}
string token = createdVideo.Token;
BackgroundUploader uploader = new BackgroundUploader();
UploadOperation uploadOperation =
await VideosServiceClient.CreateUploadOperationForCreateVideo(file, token, uploader);
await uploadOperation.StartAsync();
return(await GetResponseMessage(uploadOperation));
}
protected override FaultException CreateFaultException(MessageFault messageFault, string action)
{
IList <XmlSerializerOperationBehavior.Reflector.XmlSerializerFaultContractInfo> faultInfos;
if (action != null)
{
faultInfos = new List <XmlSerializerOperationBehavior.Reflector.XmlSerializerFaultContractInfo>();
for (int i = 0; i < _xmlSerializerFaultContractInfos.Count; i++)
{
if (_xmlSerializerFaultContractInfos[i].FaultContractInfo.Action == action ||
_xmlSerializerFaultContractInfos[i].FaultContractInfo.Action == MessageHeaders.WildcardAction)
{
faultInfos.Add(_xmlSerializerFaultContractInfos[i]);
}
}
}
else
{
faultInfos = _xmlSerializerFaultContractInfos;
}
for (int i = 0; i < faultInfos.Count; i++)
{
XmlSerializerOperationBehavior.Reflector.XmlSerializerFaultContractInfo faultInfo = faultInfos[i];
XmlDictionaryReader detailReader = messageFault.GetReaderAtDetailContents();
XmlObjectSerializer serializer = faultInfo.Serializer;
if (serializer.IsStartObject(detailReader))
{
Type detailType = faultInfo.FaultContractInfo.Detail;
try
{
object detailObj = serializer.ReadObject(detailReader);
FaultException faultException = CreateFaultException(messageFault, action,
detailObj, detailType, detailReader);
if (faultException != null)
{
return(faultException);
}
}
#pragma warning disable CA1031 // Do not catch general exception types - if we can't deserialie the message fault detail, return plain FaultException
catch (SerializationException)
{
}
#pragma warning restore CA1031 // Do not catch general exception types
}
}
return(new FaultException(messageFault, action));
}
protected virtual FaultException CreateFaultException(MessageFault messageFault, string action)
{
IList <FaultContractInfo> faultInfos;
if (action != null)
{
faultInfos = new List <FaultContractInfo>();
for (int i = 0; i < _faultContractInfos.Length; i++)
{
if (_faultContractInfos[i].Action == action || _faultContractInfos[i].Action == MessageHeaders.WildcardAction)
{
faultInfos.Add(_faultContractInfos[i]);
}
}
}
else
{
faultInfos = _faultContractInfos;
}
for (int i = 0; i < faultInfos.Count; i++)
{
FaultContractInfo faultInfo = faultInfos[i];
XmlDictionaryReader detailReader = messageFault.GetReaderAtDetailContents();
XmlObjectSerializer serializer = faultInfo.Serializer;
if (serializer.IsStartObject(detailReader))
{
Type detailType = faultInfo.Detail;
try
{
object detailObj = serializer.ReadObject(detailReader);
FaultException faultException = CreateFaultException(messageFault, action,
detailObj, detailType, detailReader);
if (faultException != null)
{
return(faultException);
}
}
#pragma warning disable CA1031 // Do not catch general exception types - return a non-specific FaultException is can't deserializer MessageFault
catch (SerializationException)
{
}
#pragma warning restore CA1031 // Do not catch general exception types
}
}
return(new FaultException(messageFault, action));
}
protected override FaultException CreateFaultException(MessageFault messageFault, string action)
{
IList <XmlSerializerOperationBehavior.Reflector.XmlSerializerFaultContractInfo> xmlSerializerFaultContractInfos;
if (action != null)
{
xmlSerializerFaultContractInfos = new List <XmlSerializerOperationBehavior.Reflector.XmlSerializerFaultContractInfo>();
for (int j = 0; j < this.xmlSerializerFaultContractInfos.Count; j++)
{
if ((this.xmlSerializerFaultContractInfos[j].FaultContractInfo.Action == action) || (this.xmlSerializerFaultContractInfos[j].FaultContractInfo.Action == "*"))
{
xmlSerializerFaultContractInfos.Add(this.xmlSerializerFaultContractInfos[j]);
}
}
}
else
{
xmlSerializerFaultContractInfos = this.xmlSerializerFaultContractInfos;
}
System.Type detailType = null;
object detailObj = null;
for (int i = 0; i < xmlSerializerFaultContractInfos.Count; i++)
{
XmlSerializerOperationBehavior.Reflector.XmlSerializerFaultContractInfo info = xmlSerializerFaultContractInfos[i];
XmlDictionaryReader readerAtDetailContents = messageFault.GetReaderAtDetailContents();
XmlObjectSerializer serializer = info.Serializer;
if (serializer.IsStartObject(readerAtDetailContents))
{
detailType = info.FaultContractInfo.Detail;
try
{
detailObj = serializer.ReadObject(readerAtDetailContents);
FaultException exception = base.CreateFaultException(messageFault, action, detailObj, detailType, readerAtDetailContents);
if (exception != null)
{
return(exception);
}
}
catch (SerializationException)
{
}
}
}
return(new FaultException(messageFault, action));
}
protected virtual FaultException CreateFaultException(MessageFault messageFault, string action)
{
IList <FaultContractInfo> faultContractInfos;
if (action != null)
{
faultContractInfos = new List <FaultContractInfo>();
for (int j = 0; j < this.faultContractInfos.Length; j++)
{
if ((this.faultContractInfos[j].Action == action) || (this.faultContractInfos[j].Action == "*"))
{
faultContractInfos.Add(this.faultContractInfos[j]);
}
}
}
else
{
faultContractInfos = this.faultContractInfos;
}
System.Type detailType = null;
object detailObj = null;
for (int i = 0; i < faultContractInfos.Count; i++)
{
FaultContractInfo info = faultContractInfos[i];
XmlDictionaryReader readerAtDetailContents = messageFault.GetReaderAtDetailContents();
XmlObjectSerializer serializer = info.Serializer;
if (serializer.IsStartObject(readerAtDetailContents))
{
detailType = info.Detail;
try
{
detailObj = serializer.ReadObject(readerAtDetailContents);
FaultException exception = this.CreateFaultException(messageFault, action, detailObj, detailType, readerAtDetailContents);
if (exception != null)
{
return(exception);
}
}
catch (SerializationException)
{
}
}
}
return(new FaultException(messageFault, action));
}
/// <summary>
/// A method used to verify argument out of range exception.
/// </summary>
/// <param name="faultException">A parameter represents a fault exception.</param>
/// <param name="argumentName">A parameter represents an argument name.</param>
/// <returns>A return value represents the fault exception's type and its argument name.</returns>
public bool VerifyArgumentOutOfRangeException(FaultException faultException, string argumentName)
{
MessageFault fault = faultException.CreateMessageFault();
XmlDocument doc = new XmlDocument();
doc.Load(fault.GetReaderAtDetailContents());
XmlNamespaceManager xnm = new XmlNamespaceManager(doc.NameTable);
xnm.AddNamespace("ex", @"http://schemas.datacontract.org/2004/07/System.ServiceModel");
XmlNode messageNode = doc.SelectNodes("//ex:Message", xnm).OfType <XmlNode>().SingleOrDefault();
XmlNode typeNode = doc.SelectNodes("//ex:Type", xnm).OfType <XmlNode>().SingleOrDefault();
string message = messageNode.InnerText;
string type = typeNode.InnerText;
return(type.Contains("ArgumentOutOfRangeException") && message.Contains(argumentName));
}
//Tested providing username
public async Task <User> GetUserDetailsAsync(string username)
{
User user = new User
{
username = username,
};
try
{
using (EnsureCredentialsUseContext context = new EnsureCredentialsUseContext(
this.Username, this.Password, this.Accesskey, _client.InnerChannel))
{
return(await this._client
.UserDetailsAsync(user, new Format())
.ContinueWith(t =>
{
if (t.Result.result.ok)
{
return t.Result.user;
}
throw new Exception("Server returned error");
}));
}
}
catch (FaultException faultException)
{
MessageFault messageFault = faultException.CreateMessageFault();
if (messageFault.HasDetail)
{
string innerErrorXml;
using (var xmlReader = messageFault.GetReaderAtDetailContents())
{
innerErrorXml = xmlReader.ReadInnerXml();
}
if (innerErrorXml != null)
{
throw new Exception(innerErrorXml);
}
throw;
}
}
throw new Exception("Request cannot be fulfilled");
}
protected override FaultException CreateFaultException(MessageFault messageFault, string action)
{
IList<XmlSerializerOperationBehavior.Reflector.XmlSerializerFaultContractInfo> xmlSerializerFaultContractInfos;
if (action != null)
{
xmlSerializerFaultContractInfos = new List<XmlSerializerOperationBehavior.Reflector.XmlSerializerFaultContractInfo>();
for (int j = 0; j < this.xmlSerializerFaultContractInfos.Count; j++)
{
if ((this.xmlSerializerFaultContractInfos[j].FaultContractInfo.Action == action) || (this.xmlSerializerFaultContractInfos[j].FaultContractInfo.Action == "*"))
{
xmlSerializerFaultContractInfos.Add(this.xmlSerializerFaultContractInfos[j]);
}
}
}
else
{
xmlSerializerFaultContractInfos = this.xmlSerializerFaultContractInfos;
}
System.Type detailType = null;
object detailObj = null;
for (int i = 0; i < xmlSerializerFaultContractInfos.Count; i++)
{
XmlSerializerOperationBehavior.Reflector.XmlSerializerFaultContractInfo info = xmlSerializerFaultContractInfos[i];
XmlDictionaryReader readerAtDetailContents = messageFault.GetReaderAtDetailContents();
XmlObjectSerializer serializer = info.Serializer;
if (serializer.IsStartObject(readerAtDetailContents))
{
detailType = info.FaultContractInfo.Detail;
try
{
detailObj = serializer.ReadObject(readerAtDetailContents);
FaultException exception = base.CreateFaultException(messageFault, action, detailObj, detailType, readerAtDetailContents);
if (exception != null)
{
return exception;
}
}
catch (SerializationException)
{
}
}
}
return new FaultException(messageFault, action);
}
//ImageAddToAlbumAsync requires not only the Album::id but also Album::idSpecified
public async Task <bool> AddImageToAlbums(string imageId, int[] albunsIds)
{
Image img = new Image {
uid = imageId, albums = new Album[albunsIds.Length]
};
for (int i = 0; i < img.albums.Length; i++)
{
img.albums[i] = new Album {
id = albunsIds[i], idSpecified = true
};
}
try
{
using (EnsureCredentialsUseContext context = new EnsureCredentialsUseContext(
this.Username, this.Password, this.Accesskey, _client.InnerChannel))
{
return(await this._client
.ImageAddToAlbumAsync(img, PhotosServiceClient.FotosSapoPtInterface)
.ContinueWith(t => t.Result.result.ok));
}
}
catch (FaultException faultException)
{
MessageFault messageFault = faultException.CreateMessageFault();
if (messageFault.HasDetail)
{
string innerErrorXml;
using (var xmlReader = messageFault.GetReaderAtDetailContents())
{
innerErrorXml = xmlReader.ReadInnerXml();
}
if (innerErrorXml != null)
{
throw new Exception(innerErrorXml);
}
throw;
}
}
throw new Exception("Request cannot be fulfilled");
}
public async Task <bool> DeleteImageAsync(string imageUid)
{
Image img = new Image {
uid = imageUid
};
try
{
using (EnsureCredentialsUseContext context = new EnsureCredentialsUseContext(
this.Username, this.Password, this.Accesskey, _client.InnerChannel))
{
return(await this._client.ImageDeleteAsync(img).ContinueWith(t =>
{
if (t.Result.ok)
{
return t.Result.ok;
}
throw new Exception("Server returned error");
}));
}
}
catch (FaultException faultException)
{
MessageFault messageFault = faultException.CreateMessageFault();
if (messageFault.HasDetail)
{
string innerErrorXml;
using (var xmlReader = messageFault.GetReaderAtDetailContents())
{
innerErrorXml = xmlReader.ReadInnerXml();
}
if (innerErrorXml != null)
{
throw new Exception(innerErrorXml);
}
throw;
}
}
throw new Exception("Request cannot be fulfilled");
}
public async Task <Video[]> QueryAsync(string emails, string tags,
int cos, int limit, string order, int viewAll, string itfc, int showTags)
{
try
{
using (EnsureCredentialsUseContext context = new EnsureCredentialsUseContext(
this.Username, this.Password, this.AccessKey, _client.InnerChannel))
{
return(await this._client.QueryAsync(emails, tags, cos, limit, order, viewAll, itfc, showTags)
.ContinueWith(t => t.Result.QueryResult));
}
}
catch (AggregateException e)
{
var faultException = e.InnerException as FaultException;
if (faultException != null)
{
MessageFault messageFault = faultException.CreateMessageFault();
if (messageFault.HasDetail)
{
string innerErrorXml;
using (var xmlReader = messageFault.GetReaderAtDetailContents())
{
innerErrorXml = xmlReader.ReadInnerXml();
}
if (innerErrorXml != null)
{
throw new Exception(innerErrorXml);
}
throw;
}
}
}
throw new Exception("Error!");
}
public async Task <Album[]> GetUserAlbumsList()
{
User user = new User()
{
username = "******",
};
try
{
using (EnsureCredentialsUseContext context = new EnsureCredentialsUseContext(
this.Username, this.Password, this.Accesskey, _client.InnerChannel))
{
return(await this._client
.AlbumGetListByUserAsync(user, 0, null, FotosSapoPtInterface)
.ContinueWith(t => t.Result.albums));
}
}
catch (FaultException faultException)
{
MessageFault messageFault = faultException.CreateMessageFault();
if (messageFault.HasDetail)
{
string innerErrorXml;
using (var xmlReader = messageFault.GetReaderAtDetailContents())
{
innerErrorXml = xmlReader.ReadInnerXml();
}
if (innerErrorXml != null)
{
throw new Exception(innerErrorXml);
}
throw;
}
}
throw new Exception("Request cannot be fulfilled");
}
public async Task <Video[]> GetUserVideos(string email, string Interface, string order, int limit, int page)
{
try
{
using (EnsureCredentialsUseContext context = new EnsureCredentialsUseContext(
this.Username, this.Password, this.AccessKey, _client.InnerChannel))
{
return(await this._client.ListUserVideosAsync(email, Interface, order, limit, page)
.ContinueWith(t => t.Result.ListUserVideosResult));
}
}
catch (AggregateException e)
{
var faultException = e.InnerException as FaultException;
if (faultException != null)
{
MessageFault messageFault = faultException.CreateMessageFault();
if (messageFault.HasDetail)
{
string innerErrorXml;
using (var xmlReader = messageFault.GetReaderAtDetailContents())
{
innerErrorXml = xmlReader.ReadInnerXml();
}
if (innerErrorXml != null)
{
throw new Exception(innerErrorXml);
}
throw;
}
}
}
throw new Exception("Error!");
}
private bool PlaceBuyOrder(string PublicKey, decimal btc)
{
try
{
srAtm.Order order = client.CreateOrder(PublicKey, btc);
return(true);
}
catch (FaultException ex)
{
string msg = "FaultException: " + ex.Message;
MessageFault fault = ex.CreateMessageFault();
if (fault.HasDetail == true)
{
System.Xml.XmlReader reader = fault.GetReaderAtDetailContents();
if (reader.Name == "ExceptionDetail")
{
ExceptionDetail detail = fault.GetDetail <ExceptionDetail>();
msg += "\n\nStack Trace: " + detail.StackTrace;
}
}
MessageBox.Show(msg);
}
return(false);
}
public static bool TryCreateFault12(ReliableMessagingVersion reliableMessagingVersion, Message message,
MessageFault fault, out WsrmHeaderFault wsrmFault)
{
// All wsrm header faults must be sender or receiver faults.
if (!fault.Code.IsSenderFault && !fault.Code.IsReceiverFault)
{
wsrmFault = null;
return false;
}
if ((fault.Code.SubCode == null)
|| (fault.Code.SubCode.Namespace != WsrmIndex.GetNamespaceString(reliableMessagingVersion)) || !fault.HasDetail)
{
wsrmFault = null;
return false;
}
string subcodeName = fault.Code.SubCode.Name;
XmlDictionaryReader detailReader = fault.GetReaderAtDetailContents();
wsrmFault = CreateWsrmHeaderFault(reliableMessagingVersion, fault.Code, subcodeName, fault.Reason,
detailReader);
return (wsrmFault != null);
}
object Request(OperationDescription od, bool isAsync, ref object [] parameters, OperationContext context)
{
ClientOperation op = runtime.Operations [od.Name];
object [] inspections = new object [runtime.MessageInspectors.Count];
Message req = CreateRequest(op, parameters, context);
for (int i = 0; i < inspections.Length; i++)
{
inspections [i] = runtime.MessageInspectors [i].BeforeSendRequest(ref req, this);
}
Message res = Request(req, OperationTimeout);
if (res.IsFault)
{
var resb = res.CreateBufferedCopy(runtime.MaxFaultSize);
MessageFault fault = MessageFault.CreateFault(resb.CreateMessage(), runtime.MaxFaultSize);
var conv = OperationChannel.GetProperty <FaultConverter> () ?? FaultConverter.GetDefaultFaultConverter(res.Version);
Exception ex;
if (!conv.TryCreateException(resb.CreateMessage(), fault, out ex))
{
if (fault.HasDetail)
{
Type detailType = typeof(ExceptionDetail);
var freader = fault.GetReaderAtDetailContents();
DataContractSerializer ds = null;
foreach (var fci in op.FaultContractInfos)
{
if (res.Headers.Action == fci.Action || fci.Serializer.IsStartObject(freader))
{
detailType = fci.Detail;
ds = fci.Serializer;
break;
}
}
if (ds == null)
{
ds = new DataContractSerializer(detailType);
}
var detail = ds.ReadObject(freader);
ex = (Exception)Activator.CreateInstance(typeof(FaultException <>).MakeGenericType(detailType), new object [] { detail, fault.Reason, fault.Code, res.Headers.Action });
}
if (ex == null)
{
ex = new FaultException(fault);
}
}
throw ex;
}
for (int i = 0; i < inspections.Length; i++)
{
runtime.MessageInspectors [i].AfterReceiveReply(ref res, inspections [i]);
}
if (!op.DeserializeReply)
{
return(res);
}
if (isAsync && od.EndMethod != null)
{
var endParams = od.EndMethod.GetParameters();
parameters = new object [endParams.Length - 1];
}
return(op.Formatter.DeserializeReply(res, parameters));
}
private void button1_Click(object sender, EventArgs e)
{
string txtDestinationFolder = @"c:\pobrane_z_ePUAP";
//string txtAdresSkrytki = "/zsisigidspzoo/skrytkaKD";
string txtAdresSkrytki = "skrytkaKD";
string txtNazwaSkrytki = "test KD";
string txtPodmiot = "zsisigidspzoo";
//nowy komentarz
//parametry do zapytania
ZapytaniePullOczekujaceTyp zapBody = new ZapytaniePullOczekujaceTyp();
zapBody.adresSkrytki = txtAdresSkrytki;
zapBody.nazwaSkrytki = txtNazwaSkrytki;
zapBody.podmiot = txtPodmiot;
textBox1.AppendText("Adres skrytki: " + zapBody.adresSkrytki + Environment.NewLine);
textBox1.AppendText("Nazwa skrytki: " + zapBody.nazwaSkrytki + Environment.NewLine);
textBox1.AppendText("Podmiot: " + zapBody.podmiot + Environment.NewLine);
CustomBinding pullBinding = CreatePullBinding();
EndpointAddress pullEndpoint = CreatePullEndpoint();
//klient pull
pullClient _client = new pullClient(pullBinding, pullEndpoint);
X509Certificate2 certyfikatKlienta = GetClientCert();
X509Certificate2 certyfikatSerwisu = GetServiceCert();
_client.ClientCredentials.ClientCertificate.Certificate = certyfikatKlienta;
_client.ClientCredentials.ServiceCertificate.DefaultCertificate = certyfikatSerwisu;
//certyfikat dostarczony przez ePUAP do podpisywanie nie daje się zwalidować pod względem nadrzędnych instytucji
//tzn. chyba sami go sobie wystawiają
_client.ClientCredentials.ServiceCertificate.Authentication.CertificateValidationMode = X509CertificateValidationMode.None;
try
{
//sprawdź oczekujące dokumenty
OdpowiedzPullOczekujaceTyp odp = _client.oczekujaceDokumenty(zapBody);
textBox1.AppendText("Oczekujące dokumenty: " + odp.oczekujace.ToString());
}
catch (MessageSecurityException ex)
{
try
{
System.ServiceModel.FaultException exInner = (FaultException)ex.InnerException;
textBox1.AppendText("Wyjątek 1: " + ex.Message);
if (ex.InnerException == null)
{
throw new Exception("Brak szczegółowych informacji o błędzie.");
}
FaultException fe = ex.InnerException as FaultException;
textBox1.AppendText("Wyjątek 2: " + fe.Message);
if (fe == null)
{
throw new Exception("Szczegółowe informacje zapisane zostały w nieprzewidzianym formacie.");
}
MessageFault mf = fe.CreateMessageFault();
if (mf == null)
{
throw new Exception("Wystąpił problem podczas odtwarzania szczegółowych informacji.");
}
XmlReader xr = mf.GetReaderAtDetailContents();
XmlDocument xd = new XmlDocument();
xd.Load(xr);
XmlNode elemKomunikat = xd.SelectSingleNode("//*[local-name() = 'komunikat']");
XmlNode elemKod = xd.SelectSingleNode("//*[local-name() = 'kod']");
StringBuilder msg = new StringBuilder();
msg.Append("Wystąpił problem z doręczeniem dokumentów. Poniżej znajdują się szczegółowe informacje (komunikaty) przekazane przez ePUAP.");
msg.AppendFormat("Informacja z ePUAP: \"{0}, kod błędu: {1}\"", elemKomunikat.InnerText, elemKod.InnerText);
textBox1.AppendText(msg.ToString());
}
catch (Exception iex)
{
//textBox1.AppendText(ex.Message);
//textBox1.AppendText(iex.Message);
}
}
catch (Exception ex)
{
textBox1.AppendText(string.Format("Wystąpił błąd podczas pobierania liczby oczekujacych dokumentow: " + ex.Message));
textBox1.AppendText(string.Format("Wystąpił błąd podczas pobierania liczby oczekujacych source: " + ex));
}
}
public static bool TryCreateFault(Message message, MessageFault fault, out MakeConnectionMessageFault wsmcFault)
{
// all WS-MakeConnection faults are receiver faults
if (!fault.Code.IsReceiverFault)
{
wsmcFault = null;
return false;
}
if ((fault.Code.SubCode == null)
|| (fault.Code.SubCode.Namespace != MakeConnectionConstants.Namespace))
{
wsmcFault = null;
return false;
}
XmlDictionaryReader detailReader = null;
string subcodeName = fault.Code.SubCode.Name;
if (fault.HasDetail)
{
detailReader = fault.GetReaderAtDetailContents();
}
wsmcFault = CreateMakeConnectionFault(message, fault.Code, subcodeName, fault.Reason, detailReader);
return (wsmcFault != null);
}
protected override FaultException CreateFaultException(MessageFault messageFault, string action)
{
IList<XmlSerializerOperationBehavior.Reflector.XmlSerializerFaultContractInfo> faultInfos;
if (action != null)
{
faultInfos = new List<XmlSerializerOperationBehavior.Reflector.XmlSerializerFaultContractInfo>();
for (int i = 0; i < _xmlSerializerFaultContractInfos.Count; i++)
{
if (_xmlSerializerFaultContractInfos[i].FaultContractInfo.Action == action
|| _xmlSerializerFaultContractInfos[i].FaultContractInfo.Action == MessageHeaders.WildcardAction)
{
faultInfos.Add(_xmlSerializerFaultContractInfos[i]);
}
}
}
else
{
faultInfos = _xmlSerializerFaultContractInfos;
}
Type detailType = null;
object detailObj = null;
for (int i = 0; i < faultInfos.Count; i++)
{
XmlSerializerOperationBehavior.Reflector.XmlSerializerFaultContractInfo faultInfo = faultInfos[i];
XmlDictionaryReader detailReader = messageFault.GetReaderAtDetailContents();
XmlObjectSerializer serializer = faultInfo.Serializer;
if (serializer.IsStartObject(detailReader))
{
detailType = faultInfo.FaultContractInfo.Detail;
try
{
detailObj = serializer.ReadObject(detailReader);
FaultException faultException = CreateFaultException(messageFault, action,
detailObj, detailType, detailReader);
if (faultException != null)
return faultException;
}
catch (SerializationException)
{
}
}
}
return new FaultException(messageFault, action);
}
public async Task <CreateImageResult> CreateImageAsync(IStorageFile file, Image img)
{
ImageCreateResult res = null;
try
{
using (EnsureCredentialsUseContext context = new EnsureCredentialsUseContext(
this.Username, this.Password, this.Accesskey, _client.InnerChannel))
{
res = await this._client.ImageCreateAsync(img, FotosSapoPtInterface);
}
}
catch (FaultException faultException)
{
MessageFault messageFault = faultException.CreateMessageFault();
if (messageFault.HasDetail)
{
string innerErrorXml;
using (var xmlReader = messageFault.GetReaderAtDetailContents())
{
innerErrorXml = xmlReader.ReadInnerXml();
}
if (innerErrorXml != null)
{
throw new Exception(innerErrorXml);
}
throw;
}
}
if (res != null && res.result.ok)
{
BackgroundUploader uploader = new BackgroundUploader();
//Default HTTP Method is POST (http://msdn.microsoft.com/en-us/library/windows/apps/xaml/windows.networking.backgroundtransfer.backgrounduploader.method.aspx)
//uploader.Method = "POST";
UploadOperation uploadOperation =
await PhotosServiceClient.CreateUploadOperationForCreateImage(file, res.token, uploader);
await uploadOperation.StartAsync();
ResponseInformation responseInformation = uploadOperation.GetResponseInformation();
uint contentLength = Convert.ToUInt32(responseInformation.Headers["Content-Length"]);
uint statusCode = responseInformation.StatusCode;
IInputStream resultStreamAt = uploadOperation.GetResultStreamAt(0);
IBuffer result = await resultStreamAt.ReadAsync(
new Windows.Storage.Streams.Buffer(contentLength),
contentLength,
InputStreamOptions.None);
Stream responseStream = result.AsStream();
XDocument xDocument = XDocument.Load(responseStream);
/*
*
* Bug!! Root element ("Upload") as diferent cases in error and in success responses
*
* Must ask SAPO Photos Team about the latency at User creation
*
* How can an application post photos for a user not being that user? Seems to be possible.
*
* Return usefull information
*
*/
string resultCode =
xDocument
.Descendants("uploadPost")
.Select(e => e.Element("Result").Value)
.SingleOrDefault();
return(new CreateImageResult(res.image, resultCode));
}
throw new Exception("Request cannot be fulfilled");
}
