/// <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>
/// 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)));
}
/// <summary>
/// Find all the items in the specified folder.
/// </summary>
/// <param name="folderName">Name of the specified folder.</param>
/// <returns>An array of found items.</returns>
private ItemType[] FindAllItems(DistinguishedFolderIdNameType folderName)
{
// Create an array of ItemType.
ItemType[] items = null;
// Create an instance of FindItemType.
FindItemType findItemRequest = new FindItemType();
findItemRequest.ParentFolderIds = new BaseFolderIdType[1];
DistinguishedFolderIdType parentFolder = new DistinguishedFolderIdType();
parentFolder.Id = folderName;
findItemRequest.ParentFolderIds[0] = parentFolder;
// Get properties that are defined as the default for the items.
findItemRequest.ItemShape = new ItemResponseShapeType();
findItemRequest.ItemShape.BaseShape = DefaultShapeNamesType.Default;
// Invoke the FindItem operation.
FindItemResponseType findItemResponse = this.exchangeServiceBinding.FindItem(findItemRequest);
if (findItemResponse != null && findItemResponse.ResponseMessages.Items[0].ResponseClass == ResponseClassType.Success)
{
// Get the found items from the response.
FindItemResponseMessageType findItemMessage = findItemResponse.ResponseMessages.Items[0] as FindItemResponseMessageType;
ArrayOfRealItemsType findItems = findItemMessage.RootFolder.Item as ArrayOfRealItemsType;
items = findItems.Items;
}
return(items);
}
/// <summary>
/// Search specified items.
/// </summary>
/// <param name="findRequest">A request to the FindItem operation.</param>
/// <returns>The response message returned by FindItem operation.</returns>
public FindItemResponseType FindItem(FindItemType findRequest)
{
FindItemResponseType findResponse = this.exchangeServiceBinding.FindItem(findRequest);
ArrayOfRealItemsType items = ((FindItemResponseMessageType)findResponse.ResponseMessages.Items[0]).RootFolder.Item as ArrayOfRealItemsType;
this.VerifyAbchPersonItemTypeComplexType((AbchPersonItemType)items.Items[0], this.exchangeServiceBinding.IsSchemaValidated);
return(findResponse);
}
/// <summary>
/// The operation searches the specified user's mailbox and returns the result whether the valid items are found after the MoveItem or DeleteItem operation completed.
/// </summary>
/// <param name="userName">Name of the user.</param>
/// <param name="password">Password of the user.</param>
/// <param name="domain">Domain of the user.</param>
/// <param name="folderName">A string that specifies the folder to search.</param>
/// <param name="value">A string that specifies the value for a search restriction.</param>
/// <param name="field">A string that specifies the type of referenced field URI.</param>
/// <returns>If the item existed in the specific folder, return true; otherwise, return false.</returns>
protected bool IsItemAvailableAfterMoveOrDelete(string userName, string password, string domain, string folderName, string value, string field)
{
this.SRCHAdapter.SwitchUser(userName, password, domain);
// Construct a request for FindItem operation.
FindItemType findRequest = this.ConstructFindItemRequest(folderName, value, field);
#region Invoke FindItem operation
int counter = 0;
int upperBound = int.Parse(Common.GetConfigurationPropertyValue("RetryCount", this.Site));
int waitTime = int.Parse(Common.GetConfigurationPropertyValue("WaitTime", this.Site));
FindItemResponseType findResponse = new FindItemResponseType();
while (counter < upperBound)
{
Thread.Sleep(waitTime);
findResponse = this.SRCHAdapter.FindItem(findRequest);
if (findResponse != null &&
findResponse.ResponseMessages != null &&
findResponse.ResponseMessages.Items != null &&
findResponse.ResponseMessages.Items.Length > 0)
{
foreach (ResponseMessageType item in findResponse.ResponseMessages.Items)
{
if (item.ResponseClass == ResponseClassType.Success)
{
FindItemResponseMessageType findItem = item as FindItemResponseMessageType;
if (findItem.RootFolder.Item != null)
{
ArrayOfRealItemsType realItems = findItem.RootFolder.Item as ArrayOfRealItemsType;
if (realItems.Items != null && realItems.Items.Length > 0)
{
counter++;
}
else
{
return(false);
}
}
else
{
return(false);
}
}
}
}
}
Site.Log.Add(LogEntryKind.Debug, "Even after retrying {0} times, Message with specified subject is still available, this means previous call to MoveItem or DeleteItem has not worked yet.", counter);
return(true);
#endregion
}
/// <summary>
/// The operation searches the mailbox and returns the result whether one or more valid items are found.
/// </summary>
/// <param name="userName">The userName of the user used to communicate with server</param>
/// <param name="password">The password of the user used to communicate with server</param>
/// <param name="domain">The domain of the user used to communicate with server</param>
/// <param name="folderName">A string that specifies the folder to search.</param>
/// <param name="value">A string that specifies the value for a search restriction.</param>
/// <param name="field">A string that specifies the type of referenced field URI.</param>
/// <returns>If the operation succeeds, return the specific item; otherwise, return null.</returns>
protected ItemType FindSpecificItem(string userName, string password, string domain, string folderName, string value, string field)
{
this.SRCHAdapter.SwitchUser(userName, password, domain);
// Construct a request for FindItem operation.
FindItemType findRequest = this.ConstructFindItemRequest(folderName, value, field);
#region Invoke FindItem operation
int counter = 0;
int upperBound = int.Parse(Common.GetConfigurationPropertyValue("RetryCount", this.Site));
int waitTime = int.Parse(Common.GetConfigurationPropertyValue("WaitTime", this.Site));
FindItemResponseType findResponse = new FindItemResponseType();
while (counter < upperBound)
{
Thread.Sleep(waitTime);
findResponse = this.SRCHAdapter.FindItem(findRequest);
if (findResponse != null &&
findResponse.ResponseMessages != null &&
findResponse.ResponseMessages.Items != null &&
findResponse.ResponseMessages.Items.Length > 0)
{
foreach (ResponseMessageType item in findResponse.ResponseMessages.Items)
{
if (item.ResponseClass == ResponseClassType.Success)
{
FindItemResponseMessageType findItem = item as FindItemResponseMessageType;
if (findItem.RootFolder.Item != null)
{
ArrayOfRealItemsType realItems = findItem.RootFolder.Item as ArrayOfRealItemsType;
if (realItems.Items != null && realItems.Items.Length > 0)
{
return(realItems.Items[0]);
}
}
}
}
}
counter++;
}
Site.Log.Add(LogEntryKind.Debug, "Even after retrying {0} times, operation FindItem could not find any message.", counter);
return(null);
#endregion
}
private IEnumerable <BaseItemIdType> InternalFindItemIds(FindItemType findItemType)
{
IndexedPageViewType pageView = new IndexedPageViewType
{
Offset = 0,
BasePoint = IndexBasePointType.Beginning,
MaxEntriesReturnedSpecified = true,
MaxEntriesReturned = 512
};
findItemType.ItemShape = EwsAuditClient.IdOnlyItemShape;
findItemType.Item = pageView;
bool haveMore;
do
{
ArrayOfRealItemsType localItemsList = null;
haveMore = false;
this.CallEwsWithRetries((LID)53436U, () => this.binding.FindItem(findItemType), delegate(ResponseMessageType responseMessage, int messageIndex)
{
FindItemResponseMessageType findItemResponseMessageType = responseMessage as FindItemResponseMessageType;
if (findItemResponseMessageType != null && findItemResponseMessageType.ResponseClass == ResponseClassType.Success && findItemResponseMessageType.RootFolder != null && findItemResponseMessageType.RootFolder.Item != null)
{
localItemsList = (findItemResponseMessageType.RootFolder.Item as ArrayOfRealItemsType);
haveMore = !findItemResponseMessageType.RootFolder.IncludesLastItemInRange;
if (haveMore)
{
pageView.Offset = findItemResponseMessageType.RootFolder.IndexedPagingOffset;
}
return(true);
}
return(false);
}, null);
if (localItemsList != null && localItemsList.Items != null && localItemsList.Items.Length > 0)
{
new List <BaseItemIdType>(localItemsList.Items.Length);
foreach (ItemType item in localItemsList.Items)
{
if (item != null && item.ItemId != null && !string.IsNullOrEmpty(item.ItemId.Id))
{
yield return(item.ItemId);
}
}
}
}while (haveMore);
yield break;
}
/// <summary>
/// Gets a list of all the items in the mailbox with all their properties.
/// </summary>
/// <returns></returns>
public IEnumerable <MessageType> GetHeaders(ChannelFolder folder)
{
var binding = ChannelHelper.BuildChannel(hostname, username, password);
var findItemRequest = new FindItemType {
Traversal = ItemQueryTraversalType.Shallow
};
var itemProperties = new ItemResponseShapeType {
BaseShape = DefaultShapeNamesType.AllProperties
};
findItemRequest.ItemShape = itemProperties;
findItemRequest.ParentFolderIds = new BaseFolderIdType[] { new FolderIdType {
Id = folder.FolderId
} };
FindItemResponseType findItemResponse = binding.FindItem(findItemRequest);
foreach (FindItemResponseMessageType responseMessage in findItemResponse.ResponseMessages.Items)
{
if (responseMessage.ResponseClass == ResponseClassType.Success)
{
ArrayOfRealItemsType mailboxItems = (ArrayOfRealItemsType)responseMessage.RootFolder.Item;
if (mailboxItems.Items == null)
{
yield break;
}
foreach (MessageType inboxItem in mailboxItems.Items)
{
yield return(inboxItem);
}
}
}
}
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);
}
/// <summary>
/// The method searches the mailbox and returns the items that meet a specified search restriction.
/// </summary>
/// <param name="folder">A string that specifies the folder to search.</param>
/// <param name="value">A string that specifies the value for a search restriction.</param>
/// <returns>If the method succeeds, return an array of item; otherwise, return null.</returns>
private ItemIdType[] GetItemIds(string folder, string value)
{
#region Construct FindItem request
FindItemType findRequest = new FindItemType();
if (string.IsNullOrEmpty(folder) || string.IsNullOrEmpty(value))
{
Site.Assert.Fail("Invalid argument: one or more invalid arguments passed to GetItemIds method.");
}
findRequest.ItemShape = new ItemResponseShapeType();
findRequest.ItemShape.BaseShape = DefaultShapeNamesType.AllProperties;
DistinguishedFolderIdType folderId = new DistinguishedFolderIdType();
DistinguishedFolderIdNameType folderIdName;
if (Enum.TryParse <DistinguishedFolderIdNameType>(folder, out folderIdName))
{
folderId.Id = folderIdName;
}
else
{
Site.Assert.Fail("The value of the first argument (foldIdNameType) of FindItem operation is invalid.");
}
findRequest.ParentFolderIds = new BaseFolderIdType[1];
findRequest.ParentFolderIds[0] = folderId;
PathToUnindexedFieldType itemClass = new PathToUnindexedFieldType();
itemClass.FieldURI = UnindexedFieldURIType.itemSubject;
ContainsExpressionType expressionType = new ContainsExpressionType();
expressionType.Item = itemClass;
expressionType.ContainmentMode = ContainmentModeType.Substring;
expressionType.ContainmentModeSpecified = true;
expressionType.ContainmentComparison = ContainmentComparisonType.IgnoreCaseAndNonSpacingCharacters;
expressionType.ContainmentComparisonSpecified = true;
expressionType.Constant = new ConstantValueType();
expressionType.Constant.Value = value;
RestrictionType restriction = new RestrictionType();
restriction.Item = expressionType;
findRequest.Restriction = restriction;
#endregion
#region Get the ids of all ItemId instances
int counter = 0;
int upperBound = int.Parse(Common.GetConfigurationPropertyValue("RetryCount", this.Site));
int waitTime = int.Parse(Common.GetConfigurationPropertyValue("WaitTime", this.Site));
FindItemResponseType findResponse = new FindItemResponseType();
while (counter < upperBound)
{
Thread.Sleep(waitTime);
findResponse = this.exchangeServiceBinding.FindItem(findRequest);
if (findResponse != null &&
findResponse.ResponseMessages != null &&
findResponse.ResponseMessages.Items != null &&
findResponse.ResponseMessages.Items.Length > 0)
{
ArrayOfRealItemsType items = ((FindItemResponseMessageType)findResponse.ResponseMessages.Items[0]).RootFolder.Item as ArrayOfRealItemsType;
if (items.Items != null && items.Items.Length > 0)
{
List <ItemIdType> itemIds = new List <ItemIdType>();
foreach (ItemType item in items.Items)
{
if (item.ItemId != null)
{
itemIds.Add(item.ItemId);
}
}
if (itemIds.Count > 0)
{
return(itemIds.ToArray());
}
}
}
counter++;
}
Site.Log.Add(LogEntryKind.Debug, "When there is not any message found by FindItem operation, the retry count is {0}", counter);
return(null);
#endregion
}
private void MigrateItens(ref DataGridViewRow row, ExchangeServiceBinding srcService, ExchangeServiceBinding tgtService, DistinguishedFolderIdNameType folder, string srcUserMail, string tgtUserMail)
{
ResponseMessageType[] itemsResponse = this.GetFolderItems(srcService, folder);
ExportItemsType exExportItems = new ExportItemsType();
foreach (ResponseMessageType responseMessage in itemsResponse)
{
FindItemResponseMessageType firmt = responseMessage as FindItemResponseMessageType;
FindItemParentType fipt = firmt.RootFolder;
object obj = fipt.Item;
int count = 0;
// FindItem contains an array of items.
if (obj is ArrayOfRealItemsType)
{
ArrayOfRealItemsType items = (obj as ArrayOfRealItemsType);
exExportItems.ItemIds = new ItemIdType[(items.Items.Count() + 1)];
foreach (ItemType it in items.Items)
{
exExportItems.ItemIds[count] = new ItemIdType();
exExportItems.ItemIds[count].Id = it.ItemId.Id;
count++;
}
}
}
ExportItemsResponseType exResponse = srcService.ExportItems(exExportItems);
ResponseMessageType[] rmResponses = exResponse.ResponseMessages.Items;
UploadItemsType upUploadItems = new UploadItemsType();
upUploadItems.Items = new UploadItemType[(rmResponses.Length + 1)];
Int32 icItemCount = 0;
foreach (ResponseMessageType rmReponse in rmResponses)
{
if (rmReponse.ResponseClass == ResponseClassType.Success)
{
ExportItemsResponseMessageType exExportedItem = (ExportItemsResponseMessageType)rmReponse;
Byte[] messageBytes = exExportedItem.Data;
UploadItemType upUploadItem = new UploadItemType();
upUploadItem.CreateAction = CreateActionType.UpdateOrCreate;
upUploadItem.Data = messageBytes;
upUploadItem.IsAssociatedSpecified = true;
upUploadItem.IsAssociated = false;
upUploadItems.Items[icItemCount] = upUploadItem;
FolderIdManager folderIdMgr = new FolderIdManager();
FolderIdType folderId = new FolderIdType();
folderId.Id = folderIdMgr.GetFolderId(tgtUserMail, Microsoft.Exchange.WebServices.Data.WellKnownFolderName.Contacts, Microsoft.Exchange.WebServices.Data.ExchangeVersion.Exchange2010_SP2);
upUploadItem.ParentFolderId = folderId;
icItemCount += 1;
}
}
//Erro de Internal Server Error nessa etapa
UploadItemsResponseType upLoadResponse = tgtService.UploadItems(upUploadItems);
Int32 Success = 0;
Int32 Failure = 0;
foreach (ResponseMessageType upResponse in upLoadResponse.ResponseMessages.Items)
{
if (upResponse.ResponseClass == ResponseClassType.Success)
{
Success++;
}
if (upResponse.ResponseClass == ResponseClassType.Error)
{
Failure++;
}
}
string resTask = string.Format("Items Copied Sucessfull : {0} - Failure: {1}", Success, Failure);
Tools.SetRowValue(ref row, EColumns.results, resTask);
//iv.Offset += fiItems.Items.Count;
}
/// <summary>
/// Finds all Calendar Items for the current User's Mailbox.
/// </summary>
/// <returns></returns>
//protected internal CalendarItemType[] FindCalendarItems()
//{
// // Identify which folders to search.
// DistinguishedFolderIdType[] parentFolderIds = new DistinguishedFolderIdType[1];
// parentFolderIds[0] = new DistinguishedFolderIdType();
// parentFolderIds[0].Id = DistinguishedFolderIdNameType.calendar;
// return FindCalendarItems(parentFolderIds);
//}
protected internal CalendarItemType[] FindCalendarItems(DistinguishedFolderIdType[] parentFolderIds)
{
// Form the FindItem request.
FindItemType findItemRequest = new FindItemType();
// Define the item properties that are returned in the response.
ItemResponseShapeType itemProperties = new ItemResponseShapeType();
itemProperties.BaseShape = DefaultShapeNamesType.IdOnly;
PathToUnindexedFieldType calendarIsRecurringFieldPath = new PathToUnindexedFieldType();
calendarIsRecurringFieldPath.FieldURI = UnindexedFieldURIType.calendarIsRecurring;
PathToUnindexedFieldType calendarItemTypeFieldPath = new PathToUnindexedFieldType();
calendarIsRecurringFieldPath.FieldURI = UnindexedFieldURIType.calendarCalendarItemType;
PathToUnindexedFieldType calendarStartFieldPath = new PathToUnindexedFieldType();
calendarStartFieldPath.FieldURI = UnindexedFieldURIType.calendarStart;
PathToUnindexedFieldType calendarEndFieldPath = new PathToUnindexedFieldType();
calendarEndFieldPath.FieldURI = UnindexedFieldURIType.calendarEnd;
//location
//PathToUnindexedFieldType calendarLocation = new PathToUnindexedFieldType();
//calendarLocation.FieldURI = UnindexedFieldURIType.calendarLocation;
//// body
//PathToUnindexedFieldType itemBody = new PathToUnindexedFieldType();
//itemBody.FieldURI = UnindexedFieldURIType.itemBody;
itemProperties.AdditionalProperties = new PathToUnindexedFieldType[]
{
calendarIsRecurringFieldPath,
calendarItemTypeFieldPath,
calendarStartFieldPath,
calendarEndFieldPath
};
findItemRequest.ItemShape = itemProperties;
findItemRequest.ParentFolderIds = parentFolderIds;
// Define the sort order of items.
FieldOrderType[] fieldsOrder = new FieldOrderType[1];
fieldsOrder[0] = new FieldOrderType();
PathToUnindexedFieldType subjectOrder = new PathToUnindexedFieldType();
subjectOrder.FieldURI = UnindexedFieldURIType.calendarStart;
fieldsOrder[0].Item = subjectOrder;
fieldsOrder[0].Order = SortDirectionType.Ascending;
findItemRequest.SortOrder = fieldsOrder;
// Define the traversal type.
findItemRequest.Traversal = ItemQueryTraversalType.Shallow;
// Send the FindItem request and get the response.
FindItemResponseType findItemResponse = Service.FindItem(findItemRequest);
// Access the response message.
ArrayOfResponseMessagesType responseMessages = findItemResponse.ResponseMessages;
ResponseMessageType responseMessage = responseMessages.Items[0];
if (responseMessage is FindItemResponseMessageType)
{
FindItemResponseMessageType firmt = (responseMessage as FindItemResponseMessageType);
FindItemParentType fipt = firmt.RootFolder;
object obj = fipt.Item;
if (obj is ArrayOfRealItemsType)
{
ArrayOfRealItemsType items = (obj as ArrayOfRealItemsType);
if (items.Items != null)
{
List <CalendarItemType> calendarItems = new List <CalendarItemType>(items.Items.Length);
foreach (ItemType item in items.Items)
{
CalendarItemType calendarItem = item as CalendarItemType;
if (calendarItem != null)
{
calendarItems.Add(calendarItem);
}
}
return(calendarItems.ToArray());
}
return(new CalendarItemType[0]);
}
}
return(null);
}
