/// <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; }