/// <remarks/>
public void GetItemAsync(GetItemType GetItem1)
{
this.GetItemAsync(GetItem1, null);
}
/// <remarks/>
public void GetItemAsync(GetItemType GetItem1, object userState)
{
if ((this.GetItemOperationCompleted == null)) {
this.GetItemOperationCompleted = new System.Threading.SendOrPostCallback(this.OnGetItemOperationCompleted);
}
this.InvokeAsync("GetItem", new object[] {
GetItem1}, this.GetItemOperationCompleted, userState);
}
/// <remarks/>
public System.IAsyncResult BeginGetItem(GetItemType GetItem1, System.AsyncCallback callback, object asyncState)
{
return this.BeginInvoke("GetItem", new object[] {
GetItem1}, callback, asyncState);
}
/// <summary>
/// Copy items to a destination folder and return the new ids for these items (Listing 5-14)
/// </summary>
/// <param name="binding">Exchange binding to use for the call</param>
/// <param name="destinationFolderId">Destination for the items</param>
/// <param name="itemsToCopy">Items to copy</param>
/// <returns>List of new item ids</returns>
///
public List<ItemIdType> CopyItemEx(
BaseFolderIdType destinationFolderId,
List<BaseItemIdType> itemsToCopy)
{
// STEP 1: First, we need to retrieve some unique information about
// each item. Let's use the PR_SEARCH_KEY. Note that extended properties are
// discussed in Chapter 13, "Extended Properties"
//
GetItemType getSearchKeyRequest = new GetItemType();
PathToExtendedFieldType searchKeyPath = new PathToExtendedFieldType();
searchKeyPath.PropertyTag = "0x300B";
searchKeyPath.PropertyType = MapiPropertyTypeType.Binary;
// Use ItemResponseShapeType overload from chapter 3. We want the Id and the
// search key
//
ItemResponseShapeType idAndSearchKeyShape = new ItemResponseShapeType(
DefaultShapeNamesType.IdOnly,
searchKeyPath);
getSearchKeyRequest.ItemShape = idAndSearchKeyShape;
getSearchKeyRequest.ItemIds = itemsToCopy.ToArray();
// Get the items
//
GetItemResponseType getSearchKeyResponse =
this.GetItem(getSearchKeyRequest);
List<string> base64SearchKeys = new List<string>(
getSearchKeyResponse.ResponseMessages.Items.Length);
// For each item, add the search keys to our list
//
foreach (ItemInfoResponseMessageType searchKeyMessage in
getSearchKeyResponse.ResponseMessages.Items)
{
ExtendedPropertyType searchKeyProperty =
searchKeyMessage.Items.Items[0].ExtendedProperty[0];
base64SearchKeys.Add((string)searchKeyProperty.Item);
}
// Now we have a list of the search keys for the items that we want to
// copy.
// STEP 2: Perform the copy
CopyItemType copyItemRequest = new CopyItemType();
copyItemRequest.ToFolderId = new TargetFolderIdType();
copyItemRequest.ToFolderId.Item = destinationFolderId;
// just copy the array from our GetItem request rather than building a
// new one.
//
copyItemRequest.ItemIds = getSearchKeyRequest.ItemIds;
CopyItemResponseType copyResponse = this.CopyItem(copyItemRequest);
// Now, we know that we do not get new ids from the above request, but
// we (read: you) SHOULD check the response code for each of the copies
// operations.
//
// STEP 3: For each successful copy, we want to find the items by
// search key.
//
FindItemType findBySearchKey = new FindItemType();
findBySearchKey.ItemShape = idAndSearchKeyShape;
findBySearchKey.ParentFolderIds = new BaseFolderIdType[] {
destinationFolderId };
findBySearchKey.Traversal = ItemQueryTraversalType.Shallow;
findBySearchKey.Restriction = new RestrictionType();
// Here we need to build up our query. Rather than issuing several
// FindItem calls, let's build up a single OR restriction here with a
// bunch of items. Note that EWS restricts filter depths, so we
// might need to break this up depending on how many items we are
// copying...
//
if (base64SearchKeys.Count > 1)
{
OrType or = new OrType();
List<IsEqualToType> orChildren = new List<IsEqualToType>();
foreach (string searchKey in base64SearchKeys)
{
// Note that CreateIsEqualToSearchKey is implemented on the partial class
// extension of RestrictionType.
//
IsEqualToType isEqualTo = RestrictionType.CreateIsEqualToSearchKey(
searchKeyPath, searchKey);
orChildren.Add(isEqualTo);
}
or.Items = orChildren.ToArray();
findBySearchKey.Restriction.Item = or;
}
else
{
// we only have one item. No need for the OR clause
//
IsEqualToType isEqualTo = RestrictionType.CreateIsEqualToSearchKey(
searchKeyPath, base64SearchKeys[0]);
findBySearchKey.Restriction.Item = isEqualTo;
}
FindItemResponseType findResponse = this.FindItem(findBySearchKey);
// Since we searched in a single target folder, we will have a single
// response message
//
FindItemResponseMessageType findResponseMessage =
findResponse.ResponseMessages.Items[0] as FindItemResponseMessageType;
ItemType[] foundItems = (findResponseMessage.RootFolder.Item as
ArrayOfRealItemsType).Items;
List<ItemIdType> newIds = new List<ItemIdType>();
foreach (ItemType item in foundItems)
{
newIds.Add(item.ItemId);
}
return newIds;
}
/// <summary>
/// Gets a single item and uses the new EWSException class to report errors (Listing 18-19)
/// </summary>
/// <param name="responseShape">response shape to use</param>
/// <param name="itemId">Id of item to get</param>
/// <returns>Retrieved ItemType instance</returns>
///
public ItemType GetSingleItem(ItemResponseShapeType responseShape, ItemIdType itemId)
{
GetItemType getItemRequest = new GetItemType();
getItemRequest.ItemShape = responseShape;
getItemRequest.ItemIds = new BaseItemIdType[] { itemId };
GetItemResponseType response = null;
try
{
response = this.GetItem(getItemRequest);
}
catch (SoapException soapException)
{
throw new EWSException(soapException);
}
// if the call was an error, throw.
//
ItemInfoResponseMessageType itemResponseMessage = response.ResponseMessages.Items[0] as ItemInfoResponseMessageType;
EWSException.ThrowIfError(itemResponseMessage);
// return our single item
//
return itemResponseMessage.Items.Items[0];
}
/// <summary>
/// Returns an up to date Id and change key for the specified item
/// </summary>
/// <param name="oldId">The Id that you have and wish to update</param>
/// <returns>The shiny new, up to date id and changekey</returns>
///
public ItemIdType GetCurrentChangeKey(ItemIdType oldId)
{
// Create the request type itself and set the response shape. All we
// need is the Id.
//
GetItemType getItemRequest = new GetItemType();
getItemRequest.ItemShape = new ItemResponseShapeType();
getItemRequest.ItemShape.BaseShape = DefaultShapeNamesType.IdOnly;
// Set the single Id that we wish to look up
//
getItemRequest.ItemIds = new BaseItemIdType[] { oldId };
// Make the actual web request
//
GetItemResponseType response = this.GetItem(getItemRequest);
// Get the appropriate message.
//
ItemInfoResponseMessageType responseMessage =
response.ResponseMessages.Items[0] as ItemInfoResponseMessageType;
// If we succeeded, the response class will be success
//
if (responseMessage.ResponseClass == ResponseClassType.Success)
{
return responseMessage.Items.Items[0].ItemId;
}
else
{
throw new ArgumentException(
String.Format(
"Item not found in mailbox. Error Code: {0}",
responseMessage.ResponseCode.ToString()),
"oldId");
}
}
/// <summary>
/// Helper method for performing batched GetItem calls (Listing 18-20)
/// </summary>
/// <param name="responseShape">ResponseShape to return</param>
/// <param name="itemIds">params array of itemIds</param>
/// <returns>ItemInfoResponseMessageType array</returns>
///
public ItemInfoResponseMessageType[] GetBatchedItems(
ItemResponseShapeType responseShape,
params ItemIdType[] itemIds)
{
GetItemType getItemRequest = new GetItemType();
getItemRequest.ItemShape = responseShape;
getItemRequest.ItemIds = itemIds;
GetItemResponseType response = null;
try
{
response = this.GetItem(getItemRequest);
}
catch (SoapException soapException)
{
// if we encounter a soap exception, throw an EWS exception instead
//
throw new EWSException(soapException);
}
ItemInfoResponseMessageType[] results = new ItemInfoResponseMessageType[response.ResponseMessages.Items.Length];
int index = 0;
foreach (ItemInfoResponseMessageType responseMessage in response.ResponseMessages.Items)
{
results[index++] = responseMessage;
}
return results;
}
