private ItemType[] HandleGetItemResponse(BaseResponseMessageType response)
{
ResponseMessageType[] array = this.HandleBaseResponseMessage(response);
if (array == null)
{
Globals.ConsistencyChecksTracer.TraceDebug((long)this.GetHashCode(), "GetItem returned NULL responseType.");
return(null);
}
List <ItemType> list = new List <ItemType>();
foreach (ResponseMessageType responseMessageType in array)
{
if (responseMessageType.ResponseCode != ResponseCodeType.NoError)
{
Globals.ConsistencyChecksTracer.TraceDebug <ResponseCodeType>((long)this.GetHashCode(), "Web request returned ResponseCodeType {0}.", responseMessageType.ResponseCode);
}
else
{
ItemInfoResponseMessageType itemInfoResponseMessageType = responseMessageType as ItemInfoResponseMessageType;
if (itemInfoResponseMessageType == null || itemInfoResponseMessageType.Items == null || itemInfoResponseMessageType.Items.Items == null)
{
Globals.ConsistencyChecksTracer.TraceDebug((long)this.GetHashCode(), "GetItem web request returned NULL ItemType.");
}
else
{
list.AddRange(itemInfoResponseMessageType.Items.Items);
}
}
}
return(list.ToArray());
}
/// <summary>
/// Verify the UploadItemsResponseType related requirements when UploadItems executes unsuccessfully.
/// </summary>
/// <param name="uploadItemsResponse">The UploadItemsResponseType instance returned from the server.</param>
protected void VerifyUploadItemsErrorResponse(BaseResponseMessageType uploadItemsResponse)
{
foreach (UploadItemsResponseMessageType responseMessage in uploadItemsResponse.ResponseMessages.Items)
{
// If the UploadItems operation is unsuccessful, the ResponseClass should be set to "Error", then requirement MS-OXWSBTRF_R2009 can be captured.
// Add debug information.
Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXWSBTRF_R2009");
// Verify requirement: MS-OXWSBTRF_R2009.
Site.CaptureRequirementIfAreEqual <ResponseClassType>(
ResponseClassType.Error,
responseMessage.ResponseClass,
2009,
@"[In tns:UploadItemsSoapOut Message]
If the request [UploadItems request] is unsuccessful, the UploadItems operation returns an UploadItemsResponse element
with the ResponseClass attribute of the UploadItemsResponseMessage element set to ""Error"".");
// If the ResponseCode is correspond to the schema, the ResponseCode should be a value of the ResponseCodeType simple type, then requirement MS-OXWSBTRF_R2010 can be captured.
// Add debug information.
Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXWSBTRF_R2010");
// Verify requirement: MS-OXWSBTRF_R2010
Site.CaptureRequirementIfIsTrue(
this.IsSchemaValidated,
2010,
@"[In tns:UploadItemsSoapOut Message][If the request UploadItems request is unsuccessful]The ResponseCode element of the UploadItemsResponseMessage element is set to a value of the ResponseCodeType simple type, as specified in [MS-OXWSCDATA] section 2.2.5.24.");
}
}
/// <summary>
/// Verify whether the response is a valid response message and extract the ResponseClass and ResponseCode.
/// </summary>
/// <param name="baseResponseMessage">The response message.</param>
private void VerifyResponseMessage(BaseResponseMessageType baseResponseMessage)
{
this.InitializeCollections();
Site.Assert.IsNotNull(baseResponseMessage, @"The response should not be null.");
Site.Assert.IsNotNull(baseResponseMessage.ResponseMessages, @"The ResponseMessages in response should not be null.");
Site.Assert.IsNotNull(baseResponseMessage.ResponseMessages.Items, @"The items of ResponseMessages in response should not be null.");
Site.Assert.IsTrue(baseResponseMessage.ResponseMessages.Items.Length > 0, @"The items of ResponseMessages in response should not be null.");
int messageCount = baseResponseMessage.ResponseMessages.Items.Length;
for (int i = 0; i < messageCount; i++)
{
ResponseMessageType responseMessage = baseResponseMessage.ResponseMessages.Items[i];
this.ResponseClass.Add(responseMessage.ResponseClass);
if (responseMessage.ResponseCodeSpecified)
{
this.responseCode.Add(responseMessage.ResponseCode);
}
if (responseMessage.ResponseClass == ResponseClassType.Success && !(baseResponseMessage is DeleteItemResponseType))
{
ItemInfoResponseMessageType itemInfo = responseMessage as ItemInfoResponseMessageType;
Site.Assert.IsNotNull(itemInfo.Items, @"The items of ResponseMessages in response should not be null.");
Site.Assert.IsNotNull(itemInfo.Items.Items, @"The task items in response should not be null.");
Site.Assert.IsTrue(itemInfo.Items.Items.Length > 0, @"There is one task item at least in response.");
foreach (ItemType item in itemInfo.Items.Items)
{
Site.Assert.IsNotNull(item.ItemId, @"The task item id in response should not be null.");
}
}
}
}
/// <summary>
/// Handle the server response.
/// </summary>
/// <param name="request">The request messages.</param>
/// <param name="response">The response messages.</param>
/// <param name="isSchemaValidated">Whether the schema is validated.</param>
protected void ExchangeServiceBinding_ResponseEvent(
BaseRequestType request,
BaseResponseMessageType response,
bool isSchemaValidated)
{
this.IsSchemaValidated = isSchemaValidated;
}
/// <summary>
/// Get the items' id and change key from successful response.
/// </summary>
/// <param name="response">Response message from server.</param>
/// <returns>Item ids contained in response.</returns>
public static ItemIdType[] GetItemIdsFromInfoResponse(BaseResponseMessageType response)
{
ArrayList arrayOfItems = new ArrayList();
ArrayOfResponseMessagesType responseMessages = response.ResponseMessages;
foreach (ResponseMessageType responseMessage in responseMessages.Items)
{
if (responseMessage.ResponseCode != ResponseCodeType.NoError ||
responseMessage.ResponseClass != ResponseClassType.Success)
{
continue;
}
ItemInfoResponseMessageType itemInfoResponseMessage = responseMessage as ItemInfoResponseMessageType;
ArrayOfRealItemsType arrayOfRealItemsType = itemInfoResponseMessage.Items;
if (arrayOfRealItemsType.Items == null)
{
continue;
}
foreach (ItemType tempItem in arrayOfRealItemsType.Items)
{
arrayOfItems.Add(tempItem.ItemId);
}
}
return((ItemIdType[])arrayOfItems.ToArray(typeof(ItemIdType)));
}
/// <summary>
/// Verify the response returned by server when the operating multiple items.
/// </summary>
/// <param name="response">A response returned by server.</param>
/// <returns>The validation result.</returns>
protected bool VerifyMultipleResponse(BaseResponseMessageType response)
{
bool isValidResponse = false;
if (response != null &&
response.ResponseMessages != null &&
response.ResponseMessages.Items != null &&
response.ResponseMessages.Items.Length > 0)
{
Site.Assert.AreEqual <int>(2, response.ResponseMessages.Items.Length, "There should be two Items elements in the operation response because this case only design for operate two items");
bool isValidFirstItemsofResponse = string.Equals(response.ResponseMessages.Items[0].ResponseClass.ToString(), "Success", System.StringComparison.CurrentCultureIgnoreCase);
if (!isValidFirstItemsofResponse)
{
Site.Assert.Fail("The operation failed with response code '{0}'", response.ResponseMessages.Items[0].ResponseCode.ToString());
}
bool isValidSecondItemsofResponse = string.Equals(response.ResponseMessages.Items[1].ResponseClass.ToString(), "Success", System.StringComparison.CurrentCultureIgnoreCase);
if (!isValidSecondItemsofResponse)
{
Site.Assert.Fail("The operation failed with response code '{0}'", response.ResponseMessages.Items[1].ResponseCode.ToString());
}
isValidResponse = isValidFirstItemsofResponse && isValidSecondItemsofResponse;
}
return(isValidResponse);
}
/// <summary>
/// Get the items from successful response.
/// </summary>
/// <typeparam name="T">The type of item</typeparam>
/// <param name="response">Response message from server.</param>
/// <returns>Items contained in response.</returns>
public static T[] GetItemsFromInfoResponse <T>(BaseResponseMessageType response)
where T : ItemType, new()
{
T itemReturnedByServer = null;
ArrayList arrayOfItems = new ArrayList();
ArrayOfResponseMessagesType responseMessages = response.ResponseMessages;
foreach (ResponseMessageType responseMessage in responseMessages.Items)
{
if (responseMessage.ResponseCode != ResponseCodeType.NoError ||
responseMessage.ResponseClass != ResponseClassType.Success)
{
continue;
}
ItemInfoResponseMessageType itemRet = responseMessage as ItemInfoResponseMessageType;
ArrayOfRealItemsType aorit = itemRet.Items;
if (aorit.Items == null)
{
continue;
}
foreach (ItemType tempItem in aorit.Items)
{
itemReturnedByServer = tempItem as T;
arrayOfItems.Add(itemReturnedByServer);
}
}
return((T[])arrayOfItems.ToArray(typeof(T)));
}
private ResponseMessageType[] ExecuteWebMethod(Func<BaseResponseMessageType> webMethodDelegate)
{
ExchangeService.Tracer.TraceDebug<ExchangeService, string>((long)this.GetHashCode(), "{0}: calling {1}", this, webMethodDelegate.Method.Name);
BaseResponseMessageType response = null;
int num = 0;
for (;;)
{
Exception exception = null;
try
{
GrayException.MapAndReportGrayExceptions(delegate()
{
ExchangeService.Tracer.TraceDebug<string>((long)this.GetHashCode(), "Calling {0}", webMethodDelegate.Method.Name);
try
{
response = webMethodDelegate();
}
catch (SoapException exception)
{
SoapException exception = exception;
}
catch (WebException exception2)
{
SoapException exception = exception2;
}
catch (IOException exception3)
{
SoapException exception = exception3;
}
catch (InvalidOperationException exception4)
{
SoapException exception = exception4;
}
});
}
catch (GrayException ex)
{
ExchangeService.Tracer.TraceError<ExchangeService, string, GrayException>((long)this.GetHashCode(), "{0}: Failed request {1} with gray exception {2}", this, webMethodDelegate.Method.Name, ex);
throw new UnexpectedRemoteDataException(ex);
}
if (exception == null)
{
goto IL_10A;
}
ExchangeService.Tracer.TraceError<ExchangeService, string, Exception>((long)this.GetHashCode(), "{0}: failed request {1} with exception {2}", this, webMethodDelegate.Method.Name, exception);
if (num >= 3 || HttpWebRequestExceptionHandler.IsConnectionException(exception, ExchangeService.Tracer))
{
break;
}
num++;
}
throw new FailedCommunicationException(CS$<>8__locals2.exception);
IL_10A:
if (response == null || response.ResponseMessages == null || response.ResponseMessages.Items == null || response.ResponseMessages.Items.Length == 0)
{
ExchangeService.Tracer.TraceError<ExchangeService, string>((long)this.GetHashCode(), "{0}: received empty response from request {1}", this, webMethodDelegate.Method.Name);
throw new UnexpectedRemoteDataException();
}
return response.ResponseMessages.Items;
}
/// <summary>
/// Verify the UploadItemsResponseType related requirements when UploadItems operation executes successfully.
/// </summary>
/// <param name="uploadItemsResponse">The UploadItemsResponseType instance returned from the server.</param>
protected void VerifyUploadItemsSuccessResponse(BaseResponseMessageType uploadItemsResponse)
{
foreach (UploadItemsResponseMessageType responseMessage in uploadItemsResponse.ResponseMessages.Items)
{
Site.Assert.IsNotNull(responseMessage, "The response got from server should not be null.");
// If the length of items in UploadItems response is equal to this.ItemCount, and uploaded Items' subject are the same as created items' subject then requirement MS-OXWSBTRF_R207 can be captured.
Site.Assert.AreEqual <int>(uploadItemsResponse.ResponseMessages.Items.Length, this.ItemCount, "The count of uploaded items should be the same as the count of created items");
// Add the debug information.
Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXWSBTRF_R2007.");
// Verify requirement: MS-OXWSBTRF_R2007
Site.CaptureRequirementIfAreEqual <ResponseClassType>(
ResponseClassType.Success,
responseMessage.ResponseClass,
2007,
@"[In tns:UploadItemsSoapOut Message]If the request [UploadItems request] is successful, the UploadItems operation returns an
UploadItemsResponse element with the ResponseClass attribute of the UploadItemsResponseMessage element set to ""Success"".");
// Add the debug information.
Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXWSBTRF_R2008.");
// Verify requirement: MS-OXWSBTRF_R2008
Site.CaptureRequirementIfAreEqual <ResponseCodeType>(
ResponseCodeType.NoError,
responseMessage.ResponseCode,
2008,
@"[In tns:UploadItemsSoapOut Message][If the UploadItems request is successful]
The ResponseCode element of the UploadItemsResponseMessage element is set to ""NoError"".");
}
}
private UserConfigurationType HandleGetUserConfigurationResponse(BaseResponseMessageType response, out bool itemNotFound)
{
itemNotFound = false;
ResponseMessageType responseMessageType = this.HandleBaseResponseMessage(response);
if (responseMessageType == null)
{
Globals.ConsistencyChecksTracer.TraceDebug((long)this.GetHashCode(), "GetUserConfiguration returned NULL responseType.");
return(null);
}
if (responseMessageType.ResponseCode == ResponseCodeType.ErrorItemNotFound)
{
itemNotFound = true;
return(null);
}
if (responseMessageType.ResponseCode != ResponseCodeType.NoError)
{
Globals.ConsistencyChecksTracer.TraceDebug <ResponseCodeType>((long)this.GetHashCode(), "Web request returned ResponseCodeType {0}.", responseMessageType.ResponseCode);
return(null);
}
GetUserConfigurationResponseMessageType getUserConfigurationResponseMessageType = responseMessageType as GetUserConfigurationResponseMessageType;
if (getUserConfigurationResponseMessageType == null || getUserConfigurationResponseMessageType.UserConfiguration == null)
{
Globals.ConsistencyChecksTracer.TraceDebug((long)this.GetHashCode(), "GetUserConfiguration web request returned NULL UserConfiguration.");
return(null);
}
return(getUserConfigurationResponseMessageType.UserConfiguration);
}
private ItemType[] HandleGetItemResponse(BaseResponseMessageType response)
{
ResponseMessageType responseMessageType = this.HandleBaseResponseMessage(response);
ItemInfoResponseMessageType itemInfoResponseMessageType = responseMessageType as ItemInfoResponseMessageType;
if (itemInfoResponseMessageType == null || itemInfoResponseMessageType.Items == null || itemInfoResponseMessageType.Items.Items == null)
{
Globals.ConsistencyChecksTracer.TraceDebug((long)this.GetHashCode(), "GetItem web request returned NULL ItemType.");
return(null);
}
return(itemInfoResponseMessageType.Items.Items);
}
/// <summary>
/// Get items in ResponseMessages.
/// </summary>
/// <typeparam name="T">An enumerator type.</typeparam>
/// <param name="response">A web service call response.</param>
/// <returns>An array instance of the specified ResponseMessageType items.</returns>
public static T[] GetResponseMessages <T>(BaseResponseMessageType response)
where T : ResponseMessageType
{
T[] responseMessages = new T[response.ResponseMessages.Items.Length];
for (int i = 0; i < response.ResponseMessages.Items.Length; i++)
{
// Get the uploaded ExportItemsResponseMessageType items
responseMessages[i] = (T)response.ResponseMessages.Items[i];
}
return(responseMessages);
}
/// <summary>
/// Parses items in ResponseMessages
/// </summary>
/// <typeparam name="T">the type of the items.</typeparam>
/// <param name="response">a web service call Response</param>
/// <returns>An array instance of the specified ResponseMessageType</returns>
public static T[] ParseResponse <T>(BaseResponseMessageType response)
where T : ResponseMessageType
{
T[] responseMessage;
responseMessage = new T[response.ResponseMessages.Items.Length];
for (int i = 0; i < responseMessage.Length; i++)
{
responseMessage[i] = response.ResponseMessages.Items[i] as T;
}
return(responseMessage);
}
private ResponseMessageType[] HandleBaseResponseMessage(BaseResponseMessageType response)
{
if (response.ResponseMessages == null || response.ResponseMessages.Items == null)
{
Globals.ConsistencyChecksTracer.TraceDebug((long)this.GetHashCode(), "Web request returned NULL ResponseMessages.");
return(null);
}
ResponseMessageType[] items = response.ResponseMessages.Items;
if (items == null || items.Length < 1)
{
Globals.ConsistencyChecksTracer.TraceDebug((long)this.GetHashCode(), "Web request returned NULL ResponseMessageType.");
return(null);
}
return(items);
}
/// <summary>
/// Verify the validation of a response returned by server.
/// </summary>
/// <param name="response">A response returned by server.</param>
/// <returns>The validation result.</returns>
protected bool VerifyResponse(BaseResponseMessageType response)
{
bool isValidResponse = false;
if (response != null &&
response.ResponseMessages != null &&
response.ResponseMessages.Items != null &&
response.ResponseMessages.Items.Length > 0 &&
response.ResponseMessages.Items[0] != null)
{
isValidResponse = string.Equals(response.ResponseMessages.Items[0].ResponseClass.ToString(), "Success", StringComparison.CurrentCultureIgnoreCase);
if (!isValidResponse && response.ResponseMessages.Items[0].ResponseCodeSpecified)
{
Site.Assert.Fail("The operation failed with response code '{0}'", response.ResponseMessages.Items[0].ResponseCode.ToString());
}
}
return(isValidResponse);
}
/// <summary>
/// Check the response and the count of items in ResponseMessages.
/// </summary>
/// <param name="response">The response of a operation.</param>
/// <param name="expectedItemCount">The count of expected items in ResponseMessages.</param>
/// <param name="site">An instance of interface ITestSite which provides logging, assertions, and adapters for test code onto its execution context.</param>
public static void CheckOperationSuccess(BaseResponseMessageType response, int expectedItemCount, ITestSite site)
{
site.Assert.AreEqual <int>(
expectedItemCount,
response.ResponseMessages.Items.GetLength(0),
"Expected Item Count: {0}, Actual Item Count: {1}",
expectedItemCount,
response.ResponseMessages.Items.GetLength(0));
foreach (ResponseMessageType responseMessage in response.ResponseMessages.Items)
{
site.Assert.AreEqual <ResponseClassType>(
ResponseClassType.Success,
responseMessage.ResponseClass,
string.Format(
"The operation should be successful! Expected response code: {0}, actual response code: {1}",
ResponseCodeType.NoError,
responseMessage.ResponseCode));
}
}
/// <summary>
/// Parses the first item in ResponseMessages, ensure the returned value is correct.
/// </summary>
/// <typeparam name="T">Type of the item.</typeparam>
/// <param name="response">A web service call response.</param>
/// <returns>An instance of the specified ResponseMessageType.</returns>
public static T EnsureResponse <T>(BaseResponseMessageType response)
where T : ResponseMessageType
{
T[] responseMessage = ParseResponse <T>(response);
if (responseMessage.Length != 1)
{
throw new IncorrectItemCountException("There should be only 1 item in the response.");
}
if (responseMessage[0].ResponseClass != ResponseClassType.Success || responseMessage[0].ResponseCode != ResponseCodeType.NoError)
{
throw new ResponseErrorException(
string.Format(
"ResponseClass or ResponseCode error. Response Code: {0}; Response Class: {1}; MessageText: {2}",
responseMessage[0].ResponseCode,
responseMessage[0].ResponseClass,
responseMessage[0].MessageText));
}
return(responseMessage[0]);
}
/// <summary>
/// Get message related Item elements of ItemInfoResponseMessageType type in a response message returned from server.
/// </summary>
/// <param name="response">A response message returned by an operation: GetItem, CopyItem, CreateItem, MoveItem, or UpdateItem.</param>
/// <returns>Message related Item elements of ItemInfoResponseMessageType type.</returns>
public static ItemInfoResponseMessageType[] GetInfoItemsInResponse(BaseResponseMessageType response)
{
ItemInfoResponseMessageType[] infoItems = null;
if (response != null &&
response.ResponseMessages != null &&
response.ResponseMessages.Items != null &&
response.ResponseMessages.Items.Length > 0)
{
List <ItemInfoResponseMessageType> infoItemList = new List <ItemInfoResponseMessageType>();
foreach (ResponseMessageType item in response.ResponseMessages.Items)
{
infoItemList.Add(item as ItemInfoResponseMessageType);
}
if (infoItemList.Count > 0)
{
infoItems = infoItemList.ToArray();
}
}
return(infoItems);
}
private ItemType[] HandleFindItemResponse(BaseResponseMessageType response)
{
ResponseMessageType[] array = this.HandleBaseResponseMessage(response);
if (array == null || array[0] == null)
{
Globals.ConsistencyChecksTracer.TraceDebug((long)this.GetHashCode(), "FindItem returned NULL responseType.");
return(null);
}
ResponseMessageType responseMessageType = array[0];
if (responseMessageType.ResponseCode != ResponseCodeType.NoError)
{
Globals.ConsistencyChecksTracer.TraceDebug <ResponseCodeType>((long)this.GetHashCode(), "Web request returned ResponseCodeType {0}.", responseMessageType.ResponseCode);
return(null);
}
FindItemResponseMessageType findItemResponseMessageType = responseMessageType as FindItemResponseMessageType;
if (findItemResponseMessageType == null)
{
Globals.ConsistencyChecksTracer.TraceDebug((long)this.GetHashCode(), "FindItem web request returned NULL FindItemResponseMessageType.");
return(null);
}
if (findItemResponseMessageType.RootFolder == null || findItemResponseMessageType.RootFolder.Item == null)
{
Globals.ConsistencyChecksTracer.TraceDebug((long)this.GetHashCode(), "FindItem web request returned NULL RootFolder.");
return(null);
}
ArrayOfRealItemsType arrayOfRealItemsType = findItemResponseMessageType.RootFolder.Item as ArrayOfRealItemsType;
if (arrayOfRealItemsType == null || arrayOfRealItemsType.Items == null || arrayOfRealItemsType.Items[0] == null)
{
Globals.ConsistencyChecksTracer.TraceDebug((long)this.GetHashCode(), "FindItem web request returned NULL ItemType.");
return(null);
}
return(arrayOfRealItemsType.Items);
}
private ResponseMessageType HandleBaseResponseMessage(BaseResponseMessageType response)
{
return(null);
}
private static void CallEwsWithRetries(Func<BaseResponseMessageType> delegateEwsCall, Func<ResponseMessageType, int, bool> responseMessageProcessor, StoreRetentionPolicyTagHelper srpth)
{
ExDateTime t = ExDateTime.UtcNow.Add(StoreRetentionPolicyTagHelper.TotalExecutionTimeWindow);
Exception ex = null;
int num = -1;
bool flag;
do
{
ex = null;
flag = false;
try
{
BaseResponseMessageType baseResponseMessageType = delegateEwsCall();
num++;
int i = 0;
while (i < baseResponseMessageType.ResponseMessages.Items.Length)
{
ResponseMessageType responseMessageType = baseResponseMessageType.ResponseMessages.Items[i];
if (responseMessageProcessor != null && responseMessageProcessor(responseMessageType, i))
{
ExTraceGlobals.ELCTracer.TraceDebug(0L, "Successfully executed EWS call");
break;
}
if (responseMessageType.ResponseClass == ResponseClassType.Error)
{
if (responseMessageType.ResponseCode == ResponseCodeType.ErrorCrossSiteRequest)
{
ExTraceGlobals.ELCTracer.TraceDebug(0L, "Crosssite request error , recreate exchange binding and reset the url caches");
flag = true;
StoreRetentionPolicyTagHelper.InitializePrincipal(srpth);
StoreRetentionPolicyTagHelper.InitializeServiceBinding(srpth);
break;
}
if (!StoreRetentionPolicyTagHelper.TransientServiceErrors.Contains(responseMessageType.ResponseCode))
{
ExTraceGlobals.ELCTracer.TraceError(0L, string.Format("Permanent error encountered: {0}, {1}, {2}", responseMessageType.ResponseClass.ToString(), responseMessageType.ResponseCode.ToString(), responseMessageType.MessageText.ToString()));
throw new ElcUserConfigurationException(Strings.FailedToGetElcUserConfigurationFromService(responseMessageType.ResponseClass.ToString(), responseMessageType.ResponseCode.ToString(), responseMessageType.MessageText.ToString()));
}
flag = true;
ex = new ElcUserConfigurationException(Strings.FailedToGetElcUserConfigurationFromService(responseMessageType.ResponseClass.ToString(), responseMessageType.ResponseCode.ToString(), responseMessageType.MessageText.ToString()));
ExTraceGlobals.ELCTracer.TraceDebug(0L, "Transient error encountered, will attempt to retry, Exception: " + ex);
break;
}
else
{
i++;
}
}
}
catch (CommunicationException ex2)
{
ex = ex2;
ExTraceGlobals.ELCTracer.TraceDebug(0L, "Transient error encountered, will attempt to retry, Exception: " + ex);
flag = true;
}
catch (WebException ex3)
{
ex = ex3;
ExTraceGlobals.ELCTracer.TraceDebug(0L, "Transient error encountered, will attempt to retry, Exception: " + ex);
flag = true;
}
catch (TimeoutException ex4)
{
ex = ex4;
flag = false;
}
catch (SoapException ex5)
{
ex = ex5;
flag = false;
}
catch (IOException ex6)
{
ex = ex6;
flag = false;
}
catch (InvalidOperationException ex7)
{
ex = ex7;
flag = false;
}
catch (LocalizedException ex8)
{
ex = ex8;
flag = false;
}
}
while (flag && t > ExDateTime.UtcNow);
if (ex != null)
{
ExTraceGlobals.ELCTracer.TraceError(0L, string.Format("Failed to access elc user configuration. Total attempts made {0}, Exception: {1} ", num, ex));
throw new ElcUserConfigurationException(Strings.ErrorElcUserConfigurationServiceCall, ex);
}
}
/// <summary>
/// Verify the ExportItemsResponseType related requirements when the ExportItems operation executes successfully.
/// </summary>
/// <param name="exportItemsResponse">The ExportItemsResponseType instance returned from the server.</param>
protected void VerifyExportItemsSuccessResponse(BaseResponseMessageType exportItemsResponse)
{
foreach (ResponseMessageType responseMessage in exportItemsResponse.ResponseMessages.Items)
{
ExportItemsResponseMessageType exportResponse = responseMessage as ExportItemsResponseMessageType;
Site.Assert.IsNotNull(exportResponse, "The response got from server should not be null.");
// Add the debug information.
Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXWSBTRF_R2107.");
// Verify requirement: MS-OXWSBTRF_R2107
Site.CaptureRequirementIfAreEqual <ResponseClassType>(
ResponseClassType.Success,
responseMessage.ResponseClass,
2107,
@"[In tns:ExportItemsSoapOut Message]If the request is successful, the ExportItems operation returns an ExportItemsResponse element
with the ResponseClass attribute of the ExportItemsResponseMessage element set to ""Success"".");
// Add the debug information.
Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXWSBTRF_R170.");
// If the ItemId in exportResponse is not null, then requirement MS-OXWSBTRF_R170 can be verified.
// Verify requirement: MS-OXWSBTRF_R170
Site.CaptureRequirementIfIsNotNull(
exportResponse.ItemId,
170,
@"[In m:ExportItemsResponseMessageType Complex Type]This element[ItemId] MUST be present if the export operation is successful.");
// Add the debug information.
Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXWSBTRF_R172.");
// If the data in exportResponse is not null, then requirement MS-OXWSBTRF_R172 and MS-OXWSBTRF_R173 can be verified.
// Verify requirement: MS-OXWSBTRF_R172
Site.CaptureRequirementIfIsNotNull(
exportResponse.Data,
172,
@"[In m:ExportItemsResponseMessageType Complex Type][Data] specifies the data of a single exported item.");
// Add the debug information.
Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXWSBTRF_R173.");
// Verify requirement: MS-OXWSBTRF_R173
Site.CaptureRequirementIfIsNotNull(
exportResponse.Data,
173,
@"[In m:ExportItemsResponseMessageType Complex Type]This element[Data] MUST be present if the export operation is successful.");
// Add the debug information.
Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXWSBTRF_R2108.");
// Verify requirement: MS-OXWSBTRF_R2108
Site.CaptureRequirementIfAreEqual <ResponseCodeType>(
ResponseCodeType.NoError,
responseMessage.ResponseCode,
2108,
@"[In tns:ExportItemsSoapOut Message][If the request is successful]The ResponseCode element of the ExportItemsResponseMessage element is set to ""NoError"".");
}
// If the length of items in ExportItems response is equal to this.ItemCount, and the exported items' id are same as created items' id then requirement MS-OXWSBTRF_R179 can be captured.
Site.Assert.AreEqual <int>(exportItemsResponse.ResponseMessages.Items.Length, this.ItemCount, "The exported items' count should be the same with created items' count");
bool isSameId = false;
for (int i = 0; i < this.ItemCount; i++)
{
Site.Log.Add(
LogEntryKind.Debug,
"The exported items' id: '{0}' should be same with the created items' id: {1}.",
(exportItemsResponse.ResponseMessages.Items[i] as ExportItemsResponseMessageType).ItemId.Id,
this.CreatedItemId[i].Id);
if ((exportItemsResponse.ResponseMessages.Items[i] as ExportItemsResponseMessageType).ItemId.Id == this.CreatedItemId[i].Id)
{
isSameId = true;
}
else
{
isSameId = false;
break;
}
}
Site.Assert.IsTrue(isSameId, "The exported items' id should be same to the created items' id. ");
// Add the debug information.
Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXWSBTRF_R179.");
// After verify the length of items in ExportItems response is equal to this.ItemCount, and the exported items' id are same as created items' id then requirement MS-OXWSBTRF_R179 can be captured.
Site.CaptureRequirement(
179,
@"[In ExportItemsType Complex Type][ItemIds] specifies the item identifier array of the items to export.");
}
