/// <summary>
/// Constructor that takes the ItemId of a private DL
/// </summary>
/// <param name="privateDLItemId">Id of a private DL</param>
///
public EmailAddressType(ItemIdType privateDLItemId)
{
this.itemIdField = privateDLItemId;
}
/// <summary>
/// Emails with Attachments. Content of Email in Email Details
/// </summary>
/// <param name="emailDetails"></param>
/// <returns></returns>
public bool DetailsWithAttachment(ModelEmailDetails emailDetails)
{
bool isSuccessful = true;
try
{
ExchangeServiceBinding esb = new ExchangeServiceBinding();
esb.Credentials = new NetworkCredential(_loginDetails.UserName, _loginDetails.Password, _loginDetails.Domain);
esb.Url = _loginDetails.ExchangeServerAddress;
//Text for Just sending Email Only
//MessageType emailMessage = new MessageType();
////Add the sender/recipient to the email message
//emailMessage.ToRecipients = new EmailAddressType[1];
//emailMessage.ToRecipients[0] = new EmailAddressType();
//emailMessage.ToRecipients[0].EmailAddress = to; //Currently there is only one recipient
//emailMessage.From = new SingleRecipientType(); //set up a single sender
//emailMessage.From.Item = new EmailAddressType();
//emailMessage.From.Item.EmailAddress = from;
//emailMessage.Subject = subject;
//emailMessage.Body = new BodyType();
//emailMessage.Body.BodyType1 = BodyTypeType.HTML; //specify HTML or plain Text
//emailMessage.Body.Value = body;
//CreateItemType emailToSave = new CreateItemType();
//emailToSave.Items = new NonEmptyArrayOfAllItemsType();
//emailToSave.Items.Items = new ItemType[1];
//emailToSave.Items.Items[0] = emailMessage;
//emailToSave.MessageDisposition = MessageDispositionType.SendAndSaveCopy;
//emailToSave.MessageDispositionSpecified = true;
//CreateItemResponseType response = esb.CreateItem(emailToSave);
//// Get the response messages.
//ResponseMessageType[] rmta = response.ResponseMessages.Items;
//Create an email message and initialize it with the from address, to address, subject and the body of the email.
MessageType email = new MessageType();
email.ToRecipients = new EmailAddressType[1];
email.ToRecipients[0] = new EmailAddressType();
email.ToRecipients[0].EmailAddress = emailDetails.SenderEmail;
email.From = new SingleRecipientType();
email.From.Item = new EmailAddressType();
email.From.Item.EmailAddress = emailDetails.RecepientEmail;
email.Subject = emailDetails.SubjectOfEmail;
email.Body = emailDetails.BodyType;
//email.Body = new BodyType();
//email.Body.BodyType1 = BodyTypeType.Text;
email.Body.BodyType1 = emailDetails.BodyType.BodyType1;
email.Body.Value = emailDetails.BodyOfEmail;
//Save the created email to the drafts folder so that we can attach a file to it.
CreateItemType emailToSave = new CreateItemType();
emailToSave.Items = new NonEmptyArrayOfAllItemsType();
emailToSave.Items.Items = new ItemType[1];
emailToSave.Items.Items[0] = email;
emailToSave.MessageDisposition = MessageDispositionType.SaveOnly;
emailToSave.MessageDispositionSpecified = true;
CreateItemResponseType response = esb.CreateItem(emailToSave);
ResponseMessageType[] rmta = response.ResponseMessages.Items;
ItemInfoResponseMessageType emailResponseMessage = (ItemInfoResponseMessageType)rmta[0];
//Create the file attachment.
FileAttachmentType fileAttachment = new FileAttachmentType();
fileAttachment.Content = System.IO.File.ReadAllBytes(emailDetails.AttachmentLocation); ;
fileAttachment.Name = Path.GetFileName(emailDetails.AttachmentLocation);
//fileAttachment.ContentType = "application/ms-excel";
fileAttachment.ContentType = emailDetails.ContentType;
CreateAttachmentType attachmentRequest = new CreateAttachmentType();
attachmentRequest.Attachments = new AttachmentType[1];
attachmentRequest.Attachments[0] = fileAttachment;
attachmentRequest.ParentItemId = emailResponseMessage.Items.Items[0].ItemId;
//Attach the file to the message.
CreateAttachmentResponseType attachmentResponse = (CreateAttachmentResponseType)esb.CreateAttachment(attachmentRequest);
AttachmentInfoResponseMessageType attachmentResponseMessage = (AttachmentInfoResponseMessageType)attachmentResponse.ResponseMessages.Items[0];
//Create a new item id type using the change key and item id of the email message so that we know what email to send.
ItemIdType attachmentItemId = new ItemIdType();
attachmentItemId.ChangeKey = attachmentResponseMessage.Attachments[0].AttachmentId.RootItemChangeKey;
attachmentItemId.Id = attachmentResponseMessage.Attachments[0].AttachmentId.RootItemId;
string test = attachmentResponseMessage.Attachments[0].Name;
//Send the email.
SendItemType si = new SendItemType();
si.ItemIds = new BaseItemIdType[1];
si.SavedItemFolderId = new TargetFolderIdType();
si.ItemIds[0] = attachmentItemId;
DistinguishedFolderIdType siSentItemsFolder = new DistinguishedFolderIdType();
siSentItemsFolder.Id = DistinguishedFolderIdNameType.sentitems;
si.SavedItemFolderId.Item = siSentItemsFolder;
si.SaveItemToFolder = true;
SendItemResponseType siSendItemResponse = esb.SendItem(si);
//Log Email Response if Tracing is on
CreateItemResponseType responseToEmail = esb.CreateItem(emailToSave);
this._responseMessage = responseToEmail.ResponseMessages.Items[0].ResponseCode.ToString();
}
catch (Exception err)
{
isSuccessful = false;
string errorMessage = string.Format("Error in sending Emails to Server {0} - {1}", err.Message,
err.StackTrace);
_responseMessage = errorMessage;
Logger.LogWriter.Instance.WriteToLog(errorMessage);
Debug.WriteLine(errorMessage);
return isSuccessful;
}
return isSuccessful;
}
/// <summary>
/// Helper method for setting the underlying fields represented by the CompleteName property
/// </summary>
/// <param name="binding">ExchangeServiceBinding to use for the call</param>
/// <param name="contactId">Id and change key of the contact to update</param>
/// <param name="completeName">The complete name to set on the contact</param>
/// <returns>ItemInfoResponse message due to UpdateItem call</returns>
///
public static ItemInfoResponseMessageType SetCompleteName(
ExchangeServiceBinding binding,
ItemIdType contactId,
CompleteNameType completeName)
{
// Create our request. We will do a single UpdateItem call with a bunch of change descriptions.
//
UpdateItemType updateRequest = new UpdateItemType();
// We are updating a single item
//
ItemChangeType itemChange = new ItemChangeType();
itemChange.Item = contactId;
updateRequest.ItemChanges = new ItemChangeType[] { itemChange };
// We will only set those props that are not null in the complete name. So right now, we
// don't know how many that will be, so let's create a list to hold the change descriptions.
//
List<ItemChangeDescriptionType> changeList = new List<ItemChangeDescriptionType>();
// Now, for each possible property, let's check to make sure it is not null, then we will set the
// value on a ContactItem instance needed for our change description and add it to our change list.
//
// Title
if (completeName.Title != null)
{
ContactItemType titleContact = new ContactItemType();
ExtendedPropertyType titleProp = new ExtendedPropertyType(
TitlePath,
completeName.Title);
titleContact.ExtendedProperty = new ExtendedPropertyType[] { titleProp };
changeList.Add(new SetItemFieldType(TitlePath, titleContact));
}
// GivenName
if (completeName.FirstName != null)
{
ContactItemType givenNameContact = new ContactItemType();
givenNameContact.GivenName = completeName.FirstName;
changeList.Add(new SetItemFieldType(GivenNamePath, givenNameContact));
}
// MiddleName
if (completeName.MiddleName != null)
{
ContactItemType middleNameContact = new ContactItemType();
middleNameContact.MiddleName = completeName.MiddleName;
changeList.Add(new SetItemFieldType(MiddleNamePath, middleNameContact));
}
// Surname
if (completeName.LastName != null)
{
ContactItemType surnameContact = new ContactItemType();
surnameContact.Surname = completeName.LastName;
changeList.Add(new SetItemFieldType(SurnamePath, surnameContact));
}
// Generation
if (completeName.Suffix != null)
{
ContactItemType generationContact = new ContactItemType();
generationContact.Generation = completeName.Suffix;
changeList.Add(new SetItemFieldType(GenerationPath, generationContact));
}
// Initials
if (completeName.Initials != null)
{
ContactItemType initialsContact = new ContactItemType();
initialsContact.Initials = completeName.Initials;
changeList.Add(new SetItemFieldType(InitialsPath, initialsContact));
}
// DisplayName
if (completeName.FullName != null)
{
ContactItemType displayNameContact = new ContactItemType();
displayNameContact.DisplayName = completeName.FullName;
changeList.Add(new SetItemFieldType(DisplayNamePath, displayNameContact));
}
// Nickname
if (completeName.Nickname != null)
{
ContactItemType nicknameContact = new ContactItemType();
nicknameContact.Nickname = completeName.Nickname;
changeList.Add(new SetItemFieldType(NicknamePath, nicknameContact));
}
// YomiFirstName
if (completeName.YomiFirstName != null)
{
ContactItemType yomiFirstContact = new ContactItemType();
ExtendedPropertyType yomiFirstProp = new ExtendedPropertyType(
YomiFirstNamePath,
completeName.YomiFirstName);
yomiFirstContact.ExtendedProperty = new ExtendedPropertyType[] { yomiFirstProp };
changeList.Add(new SetItemFieldType(YomiFirstNamePath, yomiFirstContact));
}
// YomiLastName
if (completeName.YomiLastName != null)
{
ContactItemType yomiLastContact = new ContactItemType();
ExtendedPropertyType yomiLastProp = new ExtendedPropertyType(
YomiLastNamePath,
completeName.YomiLastName);
yomiLastContact.ExtendedProperty = new ExtendedPropertyType[] { yomiLastProp };
changeList.Add(new SetItemFieldType(YomiLastNamePath, yomiLastContact));
}
// If they passed in a CompleteName with all NULL props, we should fail.
//
if (changeList.Count == 0)
{
throw new ArgumentException("No parts of CompleteName were set", "completeName");
}
itemChange.Updates = changeList.ToArray();
updateRequest.ConflictResolution = ConflictResolutionType.AlwaysOverwrite;
// Make the call and return the response message
//
return binding.UpdateItem(updateRequest).ResponseMessages.Items[0] as ItemInfoResponseMessageType;
}
/// <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>
/// Creates the batch of items passed in
/// </summary>
/// <param name="itemsToCreate">Items to create</param>
/// <returns>Array of created ids</returns>
///
public ItemIdType[] CreateBatchedItems(
ItemType[] itemsToCreate)
{
CreateItemType request = new CreateItemType();
request.MessageDisposition = MessageDispositionType.SaveOnly;
request.MessageDispositionSpecified = true;
request.Items = new NonEmptyArrayOfAllItemsType();
request.Items.Items = itemsToCreate;
CreateItemResponseType response = this.CreateItem(
request);
ItemIdType[] result = new ItemIdType[itemsToCreate.Length];
int index = 0;
foreach (ItemInfoResponseMessageType responseMessage in
response.ResponseMessages.Items)
{
if (responseMessage.ResponseCode == ResponseCodeType.NoError)
{
result[index++] = responseMessage.Items.Items[0].ItemId;
}
else
{
result[index++] = null;
}
}
return result;
}