/// <summary>
/// call back method for asynchronously Executing a Report
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="eventArgs">The <see cref="Intuit.Ipp.Core.AsyncCallCompletedEventArgs"/> instance containing the event data.</param>
private void ExecuteReportAsynCompleted(object sender, AsyncCallCompletedEventArgs eventArgs)
{
ReportCallCompletedEventArgs <Report> reportCallCompletedEventArgs = new ReportCallCompletedEventArgs <Report>();
if (eventArgs.Error == null)
{
try
{
IEntitySerializer responseSerializer = CoreHelper.GetSerializer(this.serviceContext, false);
string response = eventArgs.Result;
if (!response.StartsWith("{\"Report\":"))
{
response = "{\"Report\":" + response + "}";
}
IntuitResponse restResponse = (IntuitResponse)responseSerializer.Deserialize <IntuitResponse>(response);
reportCallCompletedEventArgs.Report = restResponse.AnyIntuitObject as Report;
this.serviceContext.IppConfiguration.Logger.CustomLogger.Log(Diagnostics.TraceLevel.Info, "Finished Executing event Execute ReportAsynCompleted in AsyncService object.");
this.OnExecuteReportAsyncCompleted(this, reportCallCompletedEventArgs);
}
catch (SystemException systemException)
{
IdsException idsException = CreateIdsException(systemException);
this.serviceContext.IppConfiguration.Logger.CustomLogger.Log(TraceLevel.Error, idsException.ToString());
reportCallCompletedEventArgs.Error = idsException;
this.OnExecuteReportAsyncCompleted(this, reportCallCompletedEventArgs);
}
}
else
{
reportCallCompletedEventArgs.Error = eventArgs.Error;
this.OnExecuteReportAsyncCompleted(this, reportCallCompletedEventArgs);
}
}
/// <summary>
/// GetEntitlements Asynchronous call back method
/// </summary>
/// <param name="sender">Rest handler class</param>
/// <param name="eventArgs">callback event arguments</param>
private void GetEntitlementsAsyncCompleted(object sender, AsyncCallCompletedEventArgs eventArgs)
{
EntitlementCallCompletedEventArgs <Intuit.Ipp.Data.EntitlementsResponse> entitlementCallCompletedEventArgs = new EntitlementCallCompletedEventArgs <EntitlementsResponse>();
if (eventArgs.Error == null)
{
try
{
IEntitySerializer responseSerializer = CoreHelper.GetSerializer(this.serviceContext, false);
EntitlementsResponse restResponse = (EntitlementsResponse)responseSerializer.Deserialize <EntitlementsResponse>(eventArgs.Result);
entitlementCallCompletedEventArgs.EntitlementsResponse = restResponse;
this.serviceContext.IppConfiguration.Logger.CustomLogger.Log(Diagnostics.TraceLevel.Info, "Finished Executing event GetEntitlementsAsync in AyncService object.");
// change Response Serialization Format back to Config value
serviceContext.IppConfiguration.Message.Response.SerializationFormat = orginialSerializationFormat;
this.OnGetEntilementAsyncCompleted(this, entitlementCallCompletedEventArgs);
}
catch (SystemException systemException)
{
IdsException idsException = new IdsException(systemException.Message);
this.serviceContext.IppConfiguration.Logger.CustomLogger.Log(TraceLevel.Error, idsException.ToString());
entitlementCallCompletedEventArgs.Error = idsException;
this.OnGetEntilementAsyncCompleted(this, entitlementCallCompletedEventArgs);
}
}
else
{
entitlementCallCompletedEventArgs.Error = eventArgs.Error;
this.OnGetEntilementAsyncCompleted(this, entitlementCallCompletedEventArgs);
}
}
/// <summary>
/// Executes the Service Call using the Retry Policy.
/// </summary>
/// <param name="myRequest">Http Request.</param>
private void ExecuteServiceCallAsync(HttpWebRequest myRequest)
{
AsyncCallCompletedEventArgs resultArguments = null;
// ExecuteAction which calls the service using retry framework.
this.context.IppConfiguration.RetryPolicy.ExecuteAction(
ac =>
{
// Invoke the begin method of the asynchronous call.
myRequest.BeginGetResponse(ac, myRequest);
},
ar =>
{
resultArguments = CreateEventArgsForRequest(ar);
},
() =>
{
// Action to perform if the asynchronous operation
// succeeded.
if (this.OnCallCompleted != null)
{
this.OnCallCompleted(this, resultArguments);
}
},
e =>
{
// Action to perform if the asynchronous operation
// failed after all the retries.
resultArguments = CreateEventArgsForException(e);
this.OnCallCompleted(this, resultArguments);
});
}
/// <summary>
/// call back method for asynchronously Executing a Report
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="eventArgs">The <see cref="Intuit.Ipp.Core.AsyncCallCompletedEventArgs"/> instance containing the event data.</param>
private void AddTaxCodeAsyncCompleted(object sender, AsyncCallCompletedEventArgs eventArgs)
{
GlobalTaxServiceCallCompletedEventArgs <Intuit.Ipp.Data.TaxService> taxServiceCallCompletedEventArgs = new GlobalTaxServiceCallCompletedEventArgs <Intuit.Ipp.Data.TaxService>();
if (eventArgs.Error == null)
{
try
{
IEntitySerializer responseSerializer = CoreHelper.GetSerializer(this.serviceContext, false);
IntuitResponse restResponse = (IntuitResponse)responseSerializer.Deserialize <IntuitResponse>(eventArgs.Result);
taxServiceCallCompletedEventArgs.TaxService = restResponse.AnyIntuitObject as Intuit.Ipp.Data.TaxService;
this.serviceContext.IppConfiguration.Logger.CustomLogger.Log(Diagnostics.TraceLevel.Info, "Finished Executing event AddTaxCodeAsyncCompleted in AyncService object.");
this.OnAddTaxCodeAsyncCompleted(this, taxServiceCallCompletedEventArgs);
}
catch (SystemException systemException)
{
IdsException idsException = CreateIdsException(systemException);
this.serviceContext.IppConfiguration.Logger.CustomLogger.Log(TraceLevel.Error, idsException.ToString());
taxServiceCallCompletedEventArgs.Error = idsException;
this.OnAddTaxCodeAsyncCompleted(this, taxServiceCallCompletedEventArgs);
}
}
else
{
taxServiceCallCompletedEventArgs.Error = eventArgs.Error;
this.OnAddTaxCodeAsyncCompleted(this, taxServiceCallCompletedEventArgs);
}
}
/// <summary>
/// Check the response for any errors it might indicate. Will throw an exception if API response indicates an error.
/// Will throw an exception if it has a problem determining success or error.
/// </summary>
/// <param name="responseXml">the QuickBase response to examine</param>
/// <returns>Asyn Call Completed Arguments.</returns>
private AsyncCallCompletedEventArgs HandleErrors(string responseXml)
{
XmlDocument document = new System.Xml.XmlDocument();
document.LoadXml(responseXml);
AsyncCallCompletedEventArgs resultArguments = null;
XmlNode errCodeNode = document.SelectSingleNode(Utility.UtilityConstants.ERRCODEXPATH);
IdsException exception = null;
if (errCodeNode == null)
{
exception = new IdsException(Resources.ErrorCodeMissing);
resultArguments = new AsyncCallCompletedEventArgs(null, exception);
}
int errorCode;
if (!int.TryParse(errCodeNode.InnerText, out errorCode))
{
exception = new IdsException(string.Format(CultureInfo.InvariantCulture, Resources.ErrorCodeNonNemeric, errorCode));
resultArguments = new AsyncCallCompletedEventArgs(null, exception);
}
if (errorCode == 0)
{
// 0 indicates success
resultArguments = new AsyncCallCompletedEventArgs(responseXml, null);
return(resultArguments);
}
XmlNode errTextNode = document.SelectSingleNode(Utility.UtilityConstants.ERRTEXTXPATH);
if (errTextNode == null)
{
exception = new IdsException(string.Format(CultureInfo.InvariantCulture, Resources.ErrorWithNoText, errorCode));
resultArguments = new AsyncCallCompletedEventArgs(null, exception);
}
string errorText = errTextNode.InnerText;
XmlNode errDetailNode = document.SelectSingleNode(Utility.UtilityConstants.ERRDETAILXPATH);
string errorDetail = errDetailNode != null ? errDetailNode.InnerText : null;
if (!string.IsNullOrEmpty(errorDetail))
{
exception = new IdsException(string.Format(CultureInfo.InvariantCulture, Resources.ErrorDetails0, errorText, errorCode, errorDetail));
resultArguments = new AsyncCallCompletedEventArgs(null, exception);
}
exception = new IdsException(string.Format(CultureInfo.InvariantCulture, Resources.ErrorDetails1, errorText, errorCode));
resultArguments = new AsyncCallCompletedEventArgs(null, exception);
return(resultArguments);
}
/// <summary>
/// call back method for asynchronous batch execution.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="eventArgs">The <see cref="Intuit.Ipp.Core.AsyncCallCompletedEventArgs"/> instance containing the event data.</param>
private void BatchAsyncompleted(object sender, AsyncCallCompletedEventArgs eventArgs)
{
BatchExecutionCompletedEventArgs batchCompletedEventArgs = new BatchExecutionCompletedEventArgs();
try
{
if (eventArgs.Error == null)
{
try
{
IEntitySerializer responseSerializer = CoreHelper.GetSerializer(this.serviceContext, false);
IntuitResponse restResponse = (IntuitResponse)responseSerializer.Deserialize <IntuitResponse>(eventArgs.Result);
foreach (object obj in restResponse.AnyIntuitObjects)
{
BatchItemResponse batchItemResponse = obj as BatchItemResponse;
this.batchResponses.Add(batchItemResponse);
// process batch item
this.intuitBatchItemResponses.Add(ProcessBatchItemResponse(batchItemResponse));
}
batchCompletedEventArgs.Batch = this;
this.OnBatchExecuteAsyncCompleted(this, batchCompletedEventArgs);
}
catch (SystemException systemException)
{
IdsException idsException = new IdsException("Batch execution failed", systemException);
this.serviceContext.IppConfiguration.Logger.CustomLogger.Log(TraceLevel.Error, idsException.ToString());
batchCompletedEventArgs.Error = idsException;
this.OnBatchExecuteAsyncCompleted(this, batchCompletedEventArgs);
}
}
else
{
batchCompletedEventArgs.Error = eventArgs.Error;
this.OnBatchExecuteAsyncCompleted(this, batchCompletedEventArgs);
}
}
catch (Exception e)
{
IdsException idsException = new IdsException("Batch execution failed", e);
this.serviceContext.IppConfiguration.Logger.CustomLogger.Log(TraceLevel.Error, idsException.ToString());
batchCompletedEventArgs.Error = idsException;
this.OnBatchExecuteAsyncCompleted(this, batchCompletedEventArgs);
}
}
/// <summary>
/// Call back method for Find all entities Asynchronously
/// </summary>
/// <param name="result">Asynchronous Result.</param>
private void AsyncExecutionCompleted(IAsyncResult result)
{
AsyncCallCompletedEventArgs resultArguments = null;
try
{
resultArguments = this.CreateEventArgsForRequest(result);
if (this.OnCallCompleted != null)
{
this.OnCallCompleted(this, resultArguments);
}
}
catch (WebException webException)
{
resultArguments = this.CreateEventArgsForException(webException);
this.OnCallCompleted(this, resultArguments);
}
}
/// <summary>
/// Creates the Event Args for Exception/Fault responses from server.
/// </summary>
/// <param name="exception">The exception class.</param>
/// <returns>Async CallCompletedEvent Arguments.</returns>
private AsyncCallCompletedEventArgs CreateEventArgsForException(Exception exception)
{
AsyncCallCompletedEventArgs resultArguments = null;
WebException webException = exception as WebException;
if (webException != null)
{
bool isIps = false;
if (this.context.ServiceType == IntuitServicesType.IPS)
{
isIps = true;
}
FaultHandler handler = new FaultHandler(this.context);
IdsException idsException = handler.ParseResponseAndThrowException(webException, isIps);
if (idsException != null)
{
this.context.IppConfiguration.Logger.CustomLogger.Log(TraceLevel.Error, idsException.ToString());
CoreHelper.AdvancedLogging.Log(idsException.ToString());
resultArguments = new AsyncCallCompletedEventArgs(null, idsException);
}
}
else
{
IdsException idsException = exception as IdsException;
if (idsException != null)
{
this.context.IppConfiguration.Logger.CustomLogger.Log(TraceLevel.Error, idsException.ToString());
CoreHelper.AdvancedLogging.Log(idsException.ToString());
resultArguments = new AsyncCallCompletedEventArgs(null, idsException);
}
else
{
this.context.IppConfiguration.Logger.CustomLogger.Log(TraceLevel.Error, idsException.ToString());
CoreHelper.AdvancedLogging.Log(idsException.ToString());
resultArguments = new AsyncCallCompletedEventArgs(null, new IdsException("Exception has been generated.", exception));
}
}
return(resultArguments);
}
private AsyncCallCompletedEventArgs CreateEventArgsForRequest(IAsyncResult asyncResult)
{
IdsException exception = null;
AsyncCallCompletedEventArgs resultArguments = null;
byte[] receiveBytes = new byte[0];
bool isResponsePdf = false;
// Get the async state of the web request.
HttpWebRequest request = (HttpWebRequest)asyncResult.AsyncState;
// Invoke the end method of the asynchronous call.
HttpWebResponse response = (HttpWebResponse)request.EndGetResponse(asyncResult);
string resultString = string.Empty;
if (!string.IsNullOrWhiteSpace(response.ContentEncoding) && this.ResponseCompressor != null)
{
using (var responseStream = response.GetResponseStream())
{
using (var decompressedStream = this.ResponseCompressor.Decompress(responseStream))
{
if (response.ContentType.ToLower().Contains(CoreConstants.CONTENTTYPE_APPLICATIONPDF.ToLower()))
{
receiveBytes = ConvertResponseStreamToBytes(decompressedStream);
isResponsePdf = true;
}
else
{
// Get the response stream.
StreamReader reader = new StreamReader(decompressedStream);
// Read the Stream
resultString = reader.ReadToEnd();
// Close reader
reader.Close();
}
}
}
}
else
{
using (Stream responseStream = response.GetResponseStream())
{
//get the response in bytes if the conten-type is application/pdf
if (response.ContentType.ToLower().Contains(CoreConstants.CONTENTTYPE_APPLICATIONPDF.ToLower()))
{
receiveBytes = ConvertResponseStreamToBytes(responseStream);
isResponsePdf = true;
}
else
{
// Get the response stream.
StreamReader reader = new StreamReader(responseStream);
// Read the Stream
resultString = reader.ReadToEnd();
// Close reader
reader.Close();
}
}
}
string response_intuit_tid_header = "";
//get intuit_tid header
for (int i = 0; i < response.Headers.Count; ++i)
{
if (response.Headers.Keys[i] == "intuit_tid")
{
response_intuit_tid_header = response.Headers[i];
}
}
// Log the response to Disk.
this.RequestLogging.LogPlatformRequests(" Response Intuit_Tid header: " + response_intuit_tid_header + ", Response Payload: " + resultString, false);
// Log response to Serilog
CoreHelper.AdvancedLogging.Log(" Response Intuit_Tid header: " + response_intuit_tid_header + ", Response Payload: " + resultString);
//log response to logs
TraceSwitch traceSwitch = new TraceSwitch("IPPTraceSwitch", "IPP Trace Switch");
this.context.IppConfiguration.Logger.CustomLogger.Log(TraceLevel.Info, (int)traceSwitch.Level > (int)TraceLevel.Info ? "Got the response from service.\n Start Dump: \n" + resultString : "Got the response from service.");
CoreHelper.AdvancedLogging.Log("Got the response from service.\n Start Dump: \n" + resultString);
//if response is of not type pdf do as usual
if (!isResponsePdf)
{
// If the response string is null then there was a communication mismatch with the server. So throw exception.
if (string.IsNullOrWhiteSpace(resultString))
{
exception = new IdsException(Resources.CommunicationErrorMessage, new CommunicationException(Resources.ResponseStreamNullOrEmptyMessage));
resultArguments = new AsyncCallCompletedEventArgs(null, exception);
}
else
{
if (this.context.ServiceType == IntuitServicesType.IPS)
{
// Handle errors here
resultArguments = this.HandleErrors(resultString);
}
else
{
FaultHandler handler = new FaultHandler(this.context);
IdsException idsException = handler.ParseErrorResponseAndPrepareException(resultString);
if (idsException != null)
{
this.context.IppConfiguration.Logger.CustomLogger.Log(TraceLevel.Error, idsException.ToString());
CoreHelper.AdvancedLogging.Log(idsException.ToString());
resultArguments = new AsyncCallCompletedEventArgs(null, idsException);
}
else
{
resultArguments = new AsyncCallCompletedEventArgs(resultString, null);
}
}
}
}
else //if response is of type pdf act accordingly
{
if (receiveBytes.Length <= 0)
{
//response equivalent to nullorwhitespace above so act in similar way
exception = new IdsException(Resources.CommunicationErrorMessage, new CommunicationException(Resources.ResponseStreamNullOrEmptyMessage));
resultArguments = new AsyncCallCompletedEventArgs(null, exception);
}
//faults not applicable here since we are expecting only pdf in binary
resultArguments = new AsyncCallCompletedEventArgs(null, null, receiveBytes);
}
return(resultArguments);
}
/// <summary>
/// Executes the Asynchronous Request.
/// </summary>
/// <param name="asyncRequest">Asynchronous web request.</param>
private void ExecAsyncRequestWithRetryPolicy(HttpWebRequest asyncRequest)
{
AsyncCallCompletedEventArgs resultArguments = null;
// Check whether the Method is post.
if (asyncRequest.Method == "POST")
{
// If true then ExecuteAction which calls the service using retry framework.
this.context.IppConfiguration.RetryPolicy.ExecuteAction(
ac =>
{
// Invoke the begin method of the asynchronous call.
asyncRequest.BeginGetRequestStream(ac, asyncRequest);
},
ar =>
{
// Invoke the end method of the asynchronous call.
HttpWebRequest request = (HttpWebRequest)ar.AsyncState;
//enabling header logging in Serilogger
WebHeaderCollection allHeaders = request.Headers;
CoreHelper.AdvancedLogging.Log(" RequestUrl: " + request.RequestUri);
CoreHelper.AdvancedLogging.Log("Logging all headers in the request:");
for (int i = 0; i < allHeaders.Count; i++)
{
CoreHelper.AdvancedLogging.Log(allHeaders.GetKey(i) + "-" + allHeaders[i]);
}
// Log Request Body to a file
this.RequestLogging.LogPlatformRequests(" RequestUrl: " + request.RequestUri + ", Request Payload: " + this.requestBody, true);
// Log Request Body to Serilog
CoreHelper.AdvancedLogging.Log(" Request Payload: " + this.requestBody);
// Using encoding get the byte value of the requestBody.
UTF8Encoding encoding = new UTF8Encoding();
byte[] content = encoding.GetBytes(this.requestBody);
TraceSwitch traceSwitch = new TraceSwitch("IPPTraceSwitch", "IPP Trace Switch");
this.context.IppConfiguration.Logger.CustomLogger.Log(TraceLevel.Info, (int)traceSwitch.Level > (int)TraceLevel.Info ? "Adding the payload to request. \n Start dump: " + this.requestBody : "Adding the payload to request.");
// Check whether compression is enabled and compress the stream accordingly.
if (this.RequestCompressor != null)
{
// get the request stream.
using (var requeststream = request.EndGetRequestStream(ar))
{
this.RequestCompressor.Compress(content, requeststream);
}
}
else
{
// Get the Request stream.
using (System.IO.Stream postStream = request.EndGetRequestStream(ar))
{
// Write the byte content to the stream.
postStream.Write(content, 0, content.Length);
}
}
},
() =>
{
// Action to perform if the asynchronous operation
// succeeded.
this.ExecuteServiceCallAsync(asyncRequest);
},
e =>
{
// Action to perform if the asynchronous operation
// failed after all the retries.
IdsException idsException = e as IdsException;
if (idsException != null)
{
resultArguments = new AsyncCallCompletedEventArgs(null, idsException);
}
else
{
resultArguments = new AsyncCallCompletedEventArgs(null, new IdsException("Exception has been generated.", e));
}
this.OnCallCompleted(this, resultArguments);
});
}
else
{
// Call the service without writing the request body to request stream.
this.ExecuteServiceCallAsync(asyncRequest);
}
}
