public async Task <bool> ConnectExchange(string authToken)
{
bool success = true;
try
{
ThisExchangeService = new ExchangeService
{
Url = new Uri("https://outlook.office365.com/EWS/Exchange.asmx"),
Credentials = new OAuthCredentials(authToken)
};
Folder Inbox = Folder.Bind(ThisExchangeService, WellKnownFolderName.Inbox);
AlternateId aiAlternateid = new AlternateId(IdFormat.EwsId, Inbox.Id.UniqueId, "*****@*****.**");
AlternateIdBase aiResponse = ThisExchangeService.ConvertId(aiAlternateid, IdFormat.EwsId);
ThisMailbox = ((AlternateId)aiResponse).Mailbox;
}
catch (Exception ex)
{
success = false;
Logger.FireWindowsLog(WinLogger.ApplicationEventType.Error, "Exchange Operation Failed - " + ex);
}
//success = await EnumerateFoldersAsync();
return(success);
}
private bool SubscribeForNotifications()
{
try
{
AlternateId outlookFolderId = new AlternateId(IdFormat.HexEntryId, _folder.EntryID, _primarySmtpAddress, false);
AlternateId ewsFolderId = _exchangeService.ConvertId(outlookFolderId, IdFormat.EwsId) as AlternateId;
_folderId = new FolderId(ewsFolderId.UniqueId);
}
catch (Exception ex)
{
AddLog(String.Format("Failed to obtain EWS Folder Id: {0}", ex.Message));
if (ex.Message.Contains("Unauthorized") || ex.Message.Contains("401"))
{
AddLog("Currently only Windows auth will work (on-prem only)");
}
return(false);
}
try
{
_streamingSubscription = _exchangeService.SubscribeToStreamingNotifications(new FolderId[] { _folderId }, EventType.Created, EventType.Moved, EventType.Copied, EventType.Modified, EventType.NewMail, EventType.Deleted);
// If we have a watermark, we set this so that we don't miss any events
}
catch (Exception ex)
{
AddLog(String.Format("Error creating subscription: {0}", ex.Message));
return(false);
}
try
{
_streamingSubscriptionConnection = new StreamingSubscriptionConnection(_exchangeService, 30);
_streamingSubscriptionConnection.AddSubscription(_streamingSubscription);
}
catch (Exception ex)
{
AddLog(String.Format("Error creating subscription connection: {0}", ex.Message));
return(false);
}
_streamingSubscriptionConnection.OnNotificationEvent += _streamingSubscriptionConnection_OnNotificationEvent;
_streamingSubscriptionConnection.OnDisconnect += _streamingSubscriptionConnection_OnDisconnect;
_streamingSubscriptionConnection.OnSubscriptionError += _streamingSubscriptionConnection_OnSubscriptionError;
try
{
_streamingSubscriptionConnection.Open();
}
catch (Exception ex)
{
AddLog(String.Format("Error opening subscription connection: {0}", ex.Message));
return(false);
}
AddLog("Successfully subscribed for notifications");
return(true);
}
/// <summary>
/// Authenticates using the credentials provided to the credential manager. It also
/// populates the ExchangeService object used by the application.
/// </summary>
/// <param name="userprincipalname">The user's name for accessing Exchange</param>
/// <param name="password">The user's password.</param>
/// <param name="service">The ExchangeService object for this application.</param>
/// <returns>A value of true indicates that the client successfully authenticated with EWS.</returns>
private static bool Authenticate(string userprincipalname, SecureString password, ref ExchangeService service)
{
bool authenticated = false;
try
{
service.Credentials = new NetworkCredential(userprincipalname, password);
// Check if we have the service URL.
if (service.Url == null)
{
Console.WriteLine("Using Autodiscover to find EWS URL for {0}. Please wait... ", userprincipalname);
service.AutodiscoverUrl(userprincipalname, Service.RedirectionUrlValidationCallback);
Console.WriteLine("Autodiscover complete.");
}
// Once we have the URL, try a ConvertId operation to check if we can access the service. We expect that
// the user will be authenticated and that we will get an error code due to the invalid format. Expect a
// ServiceResponseException.
Console.WriteLine("Attempting to connect to EWS...");
AlternateIdBase response = service.ConvertId(new AlternateId(IdFormat.EwsId, "Placeholder", userprincipalname), IdFormat.EwsId);
}
// The user principal name is in a bad format.
catch (FormatException fe)
{
Console.WriteLine("Error: {0} Please enter your credentials in UPN format.", fe.Message);
//service = null;
}
catch (AutodiscoverLocalException ale)
{
Console.WriteLine("Error: {0}", ale.Message);
//service = null;
}
// The credentials were authenticated. We expect this exception since we are providing intentional bad data for ConvertId
catch (ServiceResponseException)
{
Console.WriteLine("Successfully connected to EWS.");
authenticated = true;
}
// The credentials were not authenticated.
catch (ServiceRequestException)
{
throw new ApplicationException("The credentials were not authenticated.");
//service = null;
}
return(authenticated);
}
/// <summary>
/// Authenticates using the credentials provided to the credential manager. It also
/// populates the ExchangeService object used by the application.
/// </summary>
/// <param name="userprincipalname">The user's name for accessing Exchange</param>
/// <param name="password">The user's password.</param>
/// <param name="service">The ExchangeService object for this application.</param>
/// <returns>A value of true indicates that the client successfully authenticated with EWS.</returns>
private static bool Authenticate(string userprincipalname, SecureString password, ref ExchangeService service)
{
bool authenticated = false;
try
{
service.Credentials = new NetworkCredential(userprincipalname, password);
// Check if we have the service URL.
if (service.Url == null)
{
Console.WriteLine("Wyszukiwanie EWS URL dla konta {0}. Czekaj... ", userprincipalname);
service.AutodiscoverUrl(userprincipalname, Service.RedirectionUrlValidationCallback);
Console.WriteLine("Wyszukiwanie zakończone.");
}
// Once we have the URL, try a ConvertId operation to check if we can access the service. We expect that
// the user will be authenticated and that we will get an error code due to the invalid format. Expect a
// ServiceResponseException.
Console.WriteLine("Łączenie z EWS...");
AlternateIdBase response = service.ConvertId(new AlternateId(IdFormat.EwsId, "Placeholder", userprincipalname), IdFormat.EwsId);
}
// The user principal name is in a bad format.
catch (FormatException fe)
{
Console.WriteLine("Błąd: {0} Wprowadź dane dostępowe w formacie UPN.", fe.Message);
//service = null;
}
catch (AutodiscoverLocalException ale)
{
Console.WriteLine("Błąd: {0}", ale.Message);
//service = null;
}
// The credentials were authenticated. We expect this exception since we are providing intentional bad data for ConvertId
catch (ServiceResponseException)
{
Console.WriteLine("Połączono z EWS.");
authenticated = true;
}
// The credentials were not authenticated.
catch (ServiceRequestException)
{
throw new ApplicationException("Dane dostępowe są nieważne.");
//service = null;
}
return(authenticated);
}
private void Button_Click(object sender, RoutedEventArgs e)
{
var service = new ExchangeService();
if (this.DefaultCredentials.IsChecked == true)
{
service.UseDefaultCredentials = true;
}
else
{
service.Credentials = new WebCredentials(this.Email.Text, this.Password.Password);
}
service.AutodiscoverUrl(this.Email.Text);
int counter = 0;
using (SDK.Database database = new SDK.Database())
{
database.Connect();
foreach (var checkinStyle in CheckinStyles)
{
if (checkinStyle.Link)
{
Folder folder = new Folder(service);
folder.DisplayName = checkinStyle.Name;
folder.Save(WellKnownFolderName.Inbox);
SDK.CheckinStyle sourceStyle = new SDK.CheckinStyle(database, checkinStyle.GetUri());
AlternateId alternateId = new AlternateId();
alternateId.Format = IdFormat.EwsId;
alternateId.Mailbox = this.Email.Text;
alternateId.UniqueId = folder.Id.UniqueId;
string id = ((AlternateId)service.ConvertId(alternateId, IdFormat.HexEntryId)).UniqueId; // convert the folder ID we get from EWS to the Id Outlook expects
var place = sourceStyle.FindOrCreatePlace(SDK.CheckinPlaceTypes.MailForClientProcessing, id);
// the Checkin Place name must include the name of the Outlook profile to cater for environments that use multiple Outlook Profiles
place.Name = $"{place.Name}:{this.ProfileName.Text}";
place.Save();
counter++;
}
}
}
MessageBox.Show($"Created {counter} folders.");
}
/// <summary>
/// Authenticates using the credentials provided to the credential manager. It also
/// populates the ExchangeService object used by the application.
/// </summary>
/// <param name="data">users data : name, password, email, domain</param>
/// <param name="service">The ExchangeService object for this application.</param>
/// <returns>A value of true indicates that the client successfully authenticated with EWS.</returns>
private static bool Authenticate(IUserData data, ref ExchangeService service)
{
bool authenticated = false;
try
{
service.Credentials = new WebCredentials(data.UserName, data.Password, data.Domain);
// Check if we have the service URL.
if (service.Url == null ||
string.IsNullOrWhiteSpace(service.Url.OriginalString))
{
Logger.Message(
LocalizibleStrings.StartAutodiscover, data.EmailAddress);
service.AutodiscoverUrl(
data.EmailAddress, Service.RedirectionUrlValidationCallback);
Logger.Message(LocalizibleStrings.AutodiscoverComplete);
}
// Once we have the URL, try a ConvertId operation to check if we can access the service. We expect that
// the user will be authenticated and that we will get an error code due to the invalid format. Expect a
// ServiceResponseException.
Logger.Message(LocalizibleStrings.AttemptingConnectEws);
service.ConvertId(new AlternateId(IdFormat.EwsId, @"Placeholder", data.UserName), IdFormat.EwsId);
}
// The user principal name is in a bad format.
catch (FormatException fe)
{
Logger.Error(LocalizibleStrings.AuthInvalidUpn, fe);
}
catch (AutodiscoverLocalException ale)
{
Logger.Error(LocalizibleStrings.Auth, ale);
}
// The credentials were authenticated. We expect this exception since we are providing intentional bad data for ConvertId
catch (ServiceResponseException)
{
Logger.Message(LocalizibleStrings.SuccConnection);
authenticated = true;
}
// The credentials were not authenticated.
catch (ServiceRequestException exc)
{
Logger.Error(LocalizibleStrings.CredNotAuth, exc);
}
return(authenticated);
}
public String Get_EwsIdFromEntryID(ExchangeService oExchangeService, String sSmtp, String sEntryID)
{
// https://blogs.msdn.microsoft.com/brijs/2010/09/09/how-to-convert-exchange-items-entryid-to-ews-unique-itemid-via-ews-managed-api-convertid-call/
// Create a request to convert identifiers.
AlternateId objAltID = new AlternateId();
objAltID.Format = IdFormat.EntryId;
objAltID.Mailbox = sSmtp;
objAltID.UniqueId = sEntryID;
//Convert PR_ENTRYID identifier format to an EWS identifier.
AlternateIdBase objAltIDBase = oExchangeService.ConvertId(objAltID, IdFormat.EwsId);
AlternateId objAltIDResp = (AlternateId)objAltIDBase;
return(objAltIDResp.UniqueId);
}
public static DialogResult ShowDialog(out ItemId itemId, ExchangeService _CurrentService)
{
itemId = null;
ItemIdDialog diag = new ItemIdDialog();
diag.Text = "Enter a Item's Id...";
DialogResult res = diag.ShowDialog();
if (res == DialogResult.OK)
{
if (diag.cmboIdType.Text == "UniqueId")
{
itemId = new ItemId(diag.txtUniqueId.Text);
}
if (diag.cmboIdType.Text == "StoreId")
{
string sUniqueId = string.Empty;
AlternateId FromId = new AlternateId(
IdFormat.StoreId,
diag.txtUniqueId.Text.Trim(),
diag.txtSmtpAddress.Text.Trim()
);
//FromId.Format = IdFormat.StoreId;
//FromId.Mailbox = diag.txtSmtpAddress.Text.Trim();
//FromId.UniqueId = diag.txtUniqueId.Text.Trim();
AlternateId ToId =
(AlternateId)_CurrentService.ConvertId(FromId, IdFormat.EwsId);
sUniqueId = ToId.UniqueId;
itemId = new ItemId(diag.txtUniqueId.Text);
}
}
return(res);
}
/// <summary>
/// Authenticates using the credentials provided to the credential manager. It also
/// populates the ExchangeService object used by the application.
/// </summary>
/// <param name="userprincipalname">The user's name for accessing Exchange</param>
/// <param name="password">The user's password.</param>
/// <param name="service">The ExchangeService object for this application.</param>
/// <returns>A value of true indicates that the client successfully authenticated with EWS.</returns>
private static bool Authenticate(string userprincipalname, SecureString password, ref ExchangeService service)
{
bool authenticated = false;
try
{
service.Credentials = new NetworkCredential(userprincipalname, password);
// Check if we have the service URL.
if (service.Url == null)
{
Console.WriteLine("Wyszukiwanie EWS URL dla konta {0}. Czekaj... ", userprincipalname);
service.AutodiscoverUrl(userprincipalname, Service.RedirectionUrlValidationCallback);
Console.WriteLine("Wyszukiwanie zakończone.");
}
// Once we have the URL, try a ConvertId operation to check if we can access the service. We expect that
// the user will be authenticated and that we will get an error code due to the invalid format. Expect a
// ServiceResponseException.
Console.WriteLine("Łączenie z EWS...");
AlternateIdBase response = service.ConvertId(new AlternateId(IdFormat.EwsId, "Placeholder", userprincipalname), IdFormat.EwsId);
}
// The user principal name is in a bad format.
catch (FormatException fe)
{
Console.WriteLine("Błąd: {0} Wprowadź dane dostępowe w formacie UPN.", fe.Message);
//service = null;
}
catch (AutodiscoverLocalException ale)
{
Console.WriteLine("Błąd: {0}", ale.Message);
//service = null;
}
// The credentials were authenticated. We expect this exception since we are providing intentional bad data for ConvertId
catch (ServiceResponseException)
{
Console.WriteLine("Połączono z EWS.");
authenticated = true;
}
// The credentials were not authenticated.
catch (ServiceRequestException)
{
throw new ApplicationException("Dane dostępowe są nieważne.");
//service = null;
}
return authenticated;
}
/// <summary>
/// Authenticates using the credentials provided to the credential manager. It also
/// populates the ExchangeService object used by the application.
/// </summary>
/// <param name="data">users data : name, password, email, domain</param>
/// <param name="service">The ExchangeService object for this application.</param>
/// <returns>A value of true indicates that the client successfully authenticated with EWS.</returns>
private static bool Authenticate(IUserData data, ref ExchangeService service)
{
bool authenticated = false;
try
{
service.Credentials = new WebCredentials(data.UserName, data.Password, data.Domain);
// Check if we have the service URL.
if (service.Url == null
|| string.IsNullOrWhiteSpace(service.Url.OriginalString))
{
Logger.Message(
LocalizibleStrings.StartAutodiscover, data.EmailAddress);
service.AutodiscoverUrl(
data.EmailAddress, Service.RedirectionUrlValidationCallback);
Logger.Message(LocalizibleStrings.AutodiscoverComplete);
}
// Once we have the URL, try a ConvertId operation to check if we can access the service. We expect that
// the user will be authenticated and that we will get an error code due to the invalid format. Expect a
// ServiceResponseException.
Logger.Message(LocalizibleStrings.AttemptingConnectEws);
service.ConvertId(new AlternateId(IdFormat.EwsId, @"Placeholder", data.UserName), IdFormat.EwsId);
}
// The user principal name is in a bad format.
catch (FormatException fe)
{
Logger.Error(LocalizibleStrings.AuthInvalidUpn, fe);
}
catch (AutodiscoverLocalException ale)
{
Logger.Error(LocalizibleStrings.Auth, ale);
}
// The credentials were authenticated. We expect this exception since we are providing intentional bad data for ConvertId
catch (ServiceResponseException)
{
Logger.Message(LocalizibleStrings.SuccConnection);
authenticated = true;
}
// The credentials were not authenticated.
catch (ServiceRequestException exc)
{
Logger.Error(LocalizibleStrings.CredNotAuth, exc);
}
return authenticated;
}
