static void SetStreamingNotifications(ExchangeService service, IUserData ud) { // Subscribe to streaming notifications on the Inbox folder, and listen // for "NewMail", "Created", and "Deleted" events. try { StreamingSubscription streamingsubscription = service.SubscribeToStreamingNotifications( new FolderId[] { WellKnownFolderName.Inbox }, EventType.NewMail, EventType.Created, EventType.Deleted); StreamingSubscriptionConnection connection = new StreamingSubscriptionConnection(service, 1); connection.AddSubscription(streamingsubscription); // Delegate event handlers. connection.OnNotificationEvent += new StreamingSubscriptionConnection.NotificationEventDelegate(OnEvent); connection.OnSubscriptionError += new StreamingSubscriptionConnection.SubscriptionErrorDelegate(OnError); connection.OnDisconnect += new StreamingSubscriptionConnection.SubscriptionErrorDelegate(OnDisconnect); connection.Open(); Log(string.Format("Zasubskrybowano konto: {0}", ud.EmailAddress)); } catch (Exception e) { Log("Błąd w trakcie próby podłączenia subskrypcji." + e.InnerException.ToString()); } }
// Subscribe to streaming notifications for all folder and item events in the root folder. static StreamingSubscription SetStreamingNotifications(ExchangeService service, string cSyncState, FolderId rootSyncFolder) { // Subscribe to streaming notifications on the rootSyncFolder and listen // for events. StreamingSubscription = service.SubscribeToStreamingNotifications( new FolderId[] { rootSyncFolder }, EventType.NewMail, EventType.Created, EventType.Deleted, EventType.Modified, EventType.Moved, EventType.Copied ); StreamingSubscriptionConnection connection = new StreamingSubscriptionConnection(service, WaitTime); connection.AddSubscription(StreamingSubscription); connection.OnNotificationEvent += OnNotificationEvent; connection.OnDisconnect += OnDisconnect; connection.Open(); Console.WriteLine("Now waiting for notifications on the following folder"); Console.WriteLine("FolderId: {0}", rootSyncFolder); Console.WriteLine("--------"); return(StreamingSubscription); }
private void SubscribeNotifications(ExchangeService service, ExchangeTraceListener trace) { subconn = new StreamingSubscriptionConnection(service, 30); do { try { StreamingSubscription streamingSubscription = service.SubscribeToStreamingNotificationsOnAllFolders(EventType.NewMail); subconn.AddSubscription(streamingSubscription); subconn.OnNotificationEvent += Connection_OnNotificationEvent; subconn.OnSubscriptionError += Connection_OnSubscriptionError; subconn.OnDisconnect += Connection_OnDisconnect; subconn.Open(); } catch (Exception ex) { if (trace.Result == ETraceResult.LoginError) { Status = EProviderStatus.LoginError; return; } else { Wait(ApplicationSettings.General.WaitForNextConnectionRetry); } } } while ((subconn == null || !subconn.IsOpen) && !exitToken.IsCancellationRequested); }
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> /// create notification connection for subcribing new email from server /// </summary> /// <param name="folders">folders</param> /// <param name="eventTypes">eventTypes</param> /// <returns>StreamingSubscriptionConnection</returns> public StreamingSubscriptionConnection CreateNotificationConnection(FolderId[] folders, params EventType[] eventTypes) { StreamingSubscription streamingsubscription = _exchangeService.SubscribeToStreamingNotifications(folders, eventTypes); StreamingSubscriptionConnection connection = new StreamingSubscriptionConnection(_exchangeService, lifeTime); connection.AddSubscription(streamingsubscription); connections.Add(connection); return(connection); }
/// <summary> /// Initializes a new instance of the <see cref="ExchangeServiceSubscription" /> class. /// </summary> /// <param name="service">The <see cref="ExchangeService" />.</param> /// <param name="folder">The folder to monitor.</param> internal ExchangeServiceSubscription(ExchangeService service, WellKnownFolderName folder) { _service = service; _subscriptionConnection = new StreamingSubscriptionConnection(_service, 30); // 30 minutes is the max StreamingSubscription subscription = _service.SubscribeToStreamingNotifications(new FolderId[] { folder }, EventType.NewMail); _subscriptionConnection.AddSubscription(subscription); _subscriptionConnection.OnNotificationEvent += (s, e) => SubscriptionNotification?.Invoke(this, EventArgs.Empty); }
public void ConnectExchange(string userId, string password) { try { ExchangeService sv = null; StreamingSubscriptionConnection subcon = null; // Exchange Online に接続 (今回はデモなので、Address は決めうち !) //ExchangeVersion ver = new ExchangeVersion(); //ver = ExchangeVersion.Exchange2010_SP1; //sv = new ExchangeService(ver, TimeZoneInfo.FindSystemTimeZoneById("Tokyo Standard Time")); sv = new ExchangeService(TimeZoneInfo.FindSystemTimeZoneById("Tokyo Standard Time")); //sv.TraceEnabled = true; // デバッグ用 sv.Credentials = new System.Net.NetworkCredential( userId, password); sv.EnableScpLookup = false; sv.AutodiscoverUrl(userId, exchange_AutodiscoverCallback); // Streaming Notification の開始 (Windows Azure の制約から 1 分ごとに貼り直し) StreamingSubscription sub = sv.SubscribeToStreamingNotifications( new FolderId[] { new FolderId(WellKnownFolderName.Calendar) }, EventType.Created, EventType.Modified, EventType.Deleted); subcon = new StreamingSubscriptionConnection(sv, 1); // only 1 minute ! subcon.AddSubscription(sub); subcon.OnNotificationEvent += new StreamingSubscriptionConnection.NotificationEventDelegate(exchange_OnNotificationEvent); subcon.OnDisconnect += new StreamingSubscriptionConnection.SubscriptionErrorDelegate(exchange_OnDisconnect); subcon.OnSubscriptionError += new StreamingSubscriptionConnection.SubscriptionErrorDelegate(exchange_OnSubscriptionError); subcon.Open(); // set client data (Sorry, this is not scalable !) CleanUpExchangeClients(); exchangeClients.TryAdd( Context.ConnectionId, new ExchangeData() { StreamingSubscription = sub, LastUpdate = DateTime.Now }); // 準備完了の送信 ! JObject jsonObj = new JObject(); jsonObj["MailAddress"] = new JValue(userId); jsonObj["Password"] = new JValue(password); jsonObj["ServerUrl"] = new JValue(sv.Url.ToString()); //this.SendMessage(jsonObj.ToString()); this.Clients.Caller.notifyEvent("Ready", jsonObj.ToString()); } catch (Exception exp) { JObject jsonObj = new JObject(); jsonObj["Message"] = new JValue(exp.Message); this.Clients.Caller.notifyEvent("Exception", jsonObj.ToString()); } }
static void OnEvent(object sender, NotificationEventArgs args) { StreamingSubscription subscription = args.Subscription; // Loop through all item-related events. foreach (NotificationEvent notification in args.Events) { switch (notification.EventType) { case EventType.NewMail: Console.WriteLine("\n{0}: Mail created:", DateTime.Now.ToString()); break; case EventType.Created: Console.WriteLine("\n{0} Item or folder created:", DateTime.Now.ToString()); break; case EventType.Deleted: Console.WriteLine("\n{0} Item or folder deleted:", DateTime.Now.ToString()); break; case EventType.Moved: Console.WriteLine("\n{0} Item moved:", DateTime.Now.ToString()); break; } // Display the notification identifier. if (notification is ItemEvent) { // The NotificationEvent for an e-mail message is an ItemEvent. ItemEvent itemEvent = (ItemEvent)notification; //Console.WriteLine("\nItemId: " + itemEvent.ItemId.UniqueId); // Get the details of the item EmailMessage email = EmailMessage.Bind(service, new ItemId(itemEvent.ItemId.UniqueId)); Console.WriteLine("Subject: '{0}', Received: {1}, Sender '{2}'", email.Subject, email.DateTimeReceived.ToString(), email.Sender.Address); //old parent folder Folder oldParentFolder = Folder.Bind(service, new FolderId(itemEvent.OldParentFolderId.UniqueId)); Console.WriteLine("Source: {0}", oldParentFolder.DisplayName); //new parent folder Folder newParentFolder = Folder.Bind(service, new FolderId(itemEvent.ParentFolderId.UniqueId)); Console.WriteLine("Destination: {0}", newParentFolder.DisplayName); } else { // The NotificationEvent for a folder is an FolderEvent. FolderEvent folderEvent = (FolderEvent)notification; Console.WriteLine("\nFolderId: " + folderEvent.FolderId.UniqueId); } } }
private static StreamingSubscriptionConnection CreateStreamingSubscription(ExchangeService service, StreamingSubscription subscription) { var connection = new StreamingSubscriptionConnection(service, 30); connection.AddSubscription(subscription); connection.OnNotificationEvent += OnNotificationEvent; connection.OnSubscriptionError += OnSubscriptionError; connection.OnDisconnect += OnDisconnect; connection.Open(); return(connection); }
public void Watch() { service = new ExchangeService(); service.Credentials = new WebCredentials(EmailID, Password, Domain); service.Url = new Uri(ExchangeURL); StreamingSubscription streamingsubscription = service.SubscribeToStreamingNotifications(new FolderId[] { WellKnownFolderName.Inbox }, EventType.NewMail); connection = new StreamingSubscriptionConnection(service, 5); connection.AddSubscription(streamingsubscription); connection.OnNotificationEvent += OnNotificationEvent; connection.OnSubscriptionError += OnSubscriptionError; connection.OnDisconnect += OnDisconnect; connection.Open(); }
static void Main(string[] args) { // Retrieve the initial contents of the rootSyncFolder. ContentsSyncState = SyncContents(service, null, RootSyncFolder); // Retrieve the initial folder hierarchy, using rootSyncFolder as the root folder. FolderSyncState = SyncFolders(service, null, RootSyncFolder); // After the initial sync, wait for notifications of new or changed items. StreamingSubscription = SetStreamingNotifications(service, ContentsSyncState, RootSyncFolder); Signal = new AutoResetEvent(false); // Wait for the application to exit. Signal.WaitOne(); }
protected void SetStreamingNotifications() { // Subscribe to streaming notifications on the Inbox folder, and listen // for "NewMail", "Created", and "Deleted" events. StreamingSubscription streamingsubscription = _service.SubscribeToStreamingNotifications( new FolderId[] { WellKnownFolderName.Inbox }, EventType.NewMail); StreamingSubscriptionConnection connection = new StreamingSubscriptionConnection(_service, 5); connection.AddSubscription(streamingsubscription); // Delegate event handlers. connection.OnNotificationEvent += OnNewItemEvent; connection.Open(); }
public void OnEvent(object sender, NotificationEventArgs args) { StreamingSubscription subscription = args.Subscription; index++; blockCol.Add(index); //// Loop through all item-related events. foreach (NotificationEvent notification in args.Events) { switch (notification.EventType) { case EventType.NewMail: LoggerHelper.Logger.Info("\n-------------Mail created:-------------"); break; case EventType.Created: LoggerHelper.Logger.Info("\n-------------Item or folder created:-------------"); break; case EventType.Deleted: LoggerHelper.Logger.Info("\n-------------Item or folder deleted:-------------"); break; } // Display the notification identifier. if (notification is ItemEvent) { // The NotificationEvent for an email message is an ItemEvent. ItemEvent itemEvent = (ItemEvent)notification; LoggerHelper.Logger.Info("\nItemId: " + itemEvent.ItemId.UniqueId); } else { // The NotificationEvent for a folder is a FolderEvent. FolderEvent folderEvent = (FolderEvent)notification; LoggerHelper.Logger.Info("\nFolderId: " + folderEvent.FolderId.UniqueId); } } //System.Timers.Timer timer = new System.Timers.Timer(5 * 1000 * new Random().Next(1, 10)); //timer.Elapsed += delegate (object send, System.Timers.ElapsedEventArgs e) //{ // ReceiveEmailFromServer(exchangeService); //}; //timer.Enabled = true; //ReceiveEmailFromServer(exchangeService); // AsyncReceiveEmailFromServer(); }
private void SubscribeNotification(ExchangeService exchangeService, StreamingSubscriptionConnection connection) { StreamingSubscription streamingsubscription = exchangeService.SubscribeToStreamingNotifications( new FolderId[] { WellKnownFolderName.Inbox }, EventType.NewMail, EventType.Created, EventType.Deleted); connection.AddSubscription(streamingsubscription); // Delegate event handlers. connection.OnNotificationEvent += new StreamingSubscriptionConnection.NotificationEventDelegate(OnEvent); connection.OnSubscriptionError += new StreamingSubscriptionConnection.SubscriptionErrorDelegate(OnError); connection.OnDisconnect += new StreamingSubscriptionConnection.SubscriptionErrorDelegate(OnDisconnect); }
private void SubscribeNotificationsThread() { ExchangeTraceListener trace = new ExchangeTraceListener(); ExchangeService service = new ExchangeService { TraceListener = trace, TraceFlags = TraceFlags.AutodiscoverConfiguration, TraceEnabled = true, Url = exServiceUri }; if (!UserSettings.Email.UseDefaultCredentials) { service.Credentials = new WebCredentials(UserSettings.Email.EmailAddress, UserSettings.Email.EmailPassword); } subconn = new StreamingSubscriptionConnection(service, 30); do { try { StreamingSubscription streamingSubscription = service.SubscribeToStreamingNotificationsOnAllFolders(EventType.NewMail); subconn.AddSubscription(streamingSubscription); subconn.OnNotificationEvent += Connection_OnNotificationEvent; subconn.OnSubscriptionError += Connection_OnSubscriptionError; subconn.OnDisconnect += Connection_OnDisconnect; subconn.Open(); } catch { if (trace.Result == ETraceResult.LoginError) { Status = EProviderStatus.LoginError; return; } else { Wait(ApplicationSettings.General.WaitForNextConnectionRetry); } } } while ((subconn == null || !subconn.IsOpen) && !exitToken.IsCancellationRequested); }
static void SetStreamingNotifications(ExchangeService service) { // Subscribe to streaming notifications on the Inbox folder, and listen // for "NewMail", "Created", and "Deleted" events. StreamingSubscription streamingsubscription = service.SubscribeToStreamingNotifications( new FolderId[] { WellKnownFolderName.Inbox }, EventType.NewMail, EventType.Created, EventType.Deleted, EventType.Moved); StreamingSubscriptionConnection connection = new StreamingSubscriptionConnection(service, intervalMin); connection.AddSubscription(streamingsubscription); // Delegate event handlers. connection.OnNotificationEvent += new StreamingSubscriptionConnection.NotificationEventDelegate(OnEvent); connection.OnSubscriptionError += new StreamingSubscriptionConnection.SubscriptionErrorDelegate(OnError); connection.OnDisconnect += new StreamingSubscriptionConnection.SubscriptionErrorDelegate(OnDisconnect); connection.Open(); }
protected void OnNewItemEvent(object sender, NotificationEventArgs args) { StreamingSubscription subscription = args.Subscription; // Loop through all item-related events. foreach (NotificationEvent notification in args.Events) { object[] emptyArgs = new object[0]; switch (notification.EventType) { case EventType.NewMail: _collectCount++; Dispatcher.BeginInvoke(new Action(UpdateCollectCount)); ProcessMailItems(); break; } } }
private void btnStreamSubscribe_Click(object sender, RoutedEventArgs e) { ExchangeService service = _context.GetService(); _streamSubscription = service.SubscribeToStreamingNotifications(new FolderId[] { WellKnownFolderName.Inbox }, EventType.NewMail); StreamingSubscriptionConnection connection = new StreamingSubscriptionConnection(service, 10); connection.AddSubscription(_streamSubscription); connection.OnNotificationEvent += connection_OnNotificationEvent; connection.Open(); txtSubscriptionActivity.Text += "Stream Subscription Created" + Environment.NewLine; btnStreamSubscribe.IsEnabled = false; btnStreamUnsubscribe.IsEnabled = true; }
/// <summary> /// Adds streamingsubscription to the GroupInfo /// </summary> /// <param name="context">Database context</param> /// <param name="Group"></param> /// <param name="smtpAddress"></param> /// <returns></returns> private StreamingSubscription AddSubscription(EWSDbContext context, GroupInfo Group, string smtpAddress) { StreamingSubscription subscription = null; if (_subscriptions.Any(email => email.SmtpAddress.Equals(smtpAddress))) { var email = _subscriptions.FirstOrDefault(s => s.SmtpAddress.Equals(smtpAddress)); _subscriptions.Remove(email); } try { ExchangeService exchange = Group.ExchangeService; exchange.Credentials = ServiceCredentials; exchange.ImpersonatedUserId = new ImpersonatedUserId(ConnectingIdType.SmtpAddress, smtpAddress); subscription = exchange.SubscribeToStreamingNotifications(new FolderId[] { WellKnownFolderName.Calendar }, EventType.Created, EventType.Deleted, EventType.Modified, EventType.Moved, EventType.Copied); _traceListener.Trace("SyncProgram", $"CreateStreamingSubscriptionGrouping to room {smtpAddress} with SubscriptionId {subscription.Id}"); var subscriptions = context.SaveChanges(); _traceListener.Trace("SyncProgram", $"Streaming subscription persisted {subscriptions} persisted."); _subscriptions.Add(new SubscriptionCollection() { SmtpAddress = smtpAddress, Streaming = subscription }); } catch (Microsoft.Exchange.WebServices.Data.ServiceRequestException srex) { _traceListener.Trace("SyncProgram", $"Failed to provision subscription {srex.Message}"); throw new Exception($"Subscription could not be created for {smtpAddress} with MSG:{srex.Message}"); } return(subscription); }
private void InitializeComponent() { this.ServiceName = MyServiceName; this.eventLog = new EventLog(); this.eventLog.Source = this.ServiceName; ((System.ComponentModel.ISupportInitialize)(this.eventLog)).BeginInit(); emailSubscription = EmailHelper.InstanceOf.GetEmailService.SubscribeToStreamingNotifications( new FolderId[] { EmailHelper.InstanceOf.RfiInboxFolder }, EventType.NewMail); // GroundUpRfiBoxSubscription = EmailHelper.InstanceOf.GetEmailService.SubscribeToStreamingNotifications( // new FolderId[] { // EmailHelper.InstanceOf.NewStoresInboxFolder // }, // EventType.NewMail, // EventType.Created, // EventType.Deleted, // EventType.Moved, // EventType.Copied); // // ExistingRfiBoxSubscription = EmailHelper.InstanceOf.GetEmailService.SubscribeToStreamingNotifications( // new FolderId[] { // EmailHelper.InstanceOf.ExistingStoresInboxFolder // }, // EventType.NewMail, // EventType.Created, // EventType.Deleted, // EventType.Moved, // EventType.Copied); emailSubscriptionConnection = new StreamingSubscriptionConnection( EmailHelper.InstanceOf.GetEmailService, 30); ((System.ComponentModel.ISupportInitialize)(this.eventLog)).EndInit(); }
public static void OnEvent(object sender, NotificationEventArgs args) { StreamingSubscription subscription = args.Subscription; foreach (NotificationEvent notification in args.Events) { switch (notification.EventType) { case EventType.NewMail: break; } if (notification is ItemEvent) { ItemEvent itemEvent = (ItemEvent)notification; EmailMessage message = EmailMessage.Bind(args.Subscription.Service, itemEvent.ItemId.UniqueId).Result; StreamingSubscriptionConnection connection = (StreamingSubscriptionConnection)sender; if (_parameters.GeracaoArquivoEmail.EnviadoPor != null) { if (message.Sender.Address.Contains(_parameters.GeracaoArquivoEmail.EnviadoPor)) { receivedEmail = true; connection.Close(); resetEvent.Set(); } return; } receivedEmail = true; connection.Close(); resetEvent.Set(); } else { FolderEvent folderEvent = (FolderEvent)notification; } } }
static void OnEvent(object sender, NotificationEventArgs args) { StreamingSubscription subscription = args.Subscription; // Loop through all item-related events. foreach (NotificationEvent notification in args.Events) { switch (notification.EventType) { case EventType.NewMail: Console.WriteLine("\n-------------Mail created:-------------"); break; case EventType.Created: Console.WriteLine("\n-------------Item or folder created:-------------"); break; case EventType.Deleted: Console.WriteLine("\n-------------Item or folder deleted:-------------"); break; } // Display the notification identifier. if (notification is ItemEvent) { // The NotificationEvent for an email message is an ItemEvent. ItemEvent itemEvent = (ItemEvent)notification; Console.WriteLine("\nItemId: " + itemEvent.ItemId.UniqueId); } else { // The NotificationEvent for a folder is a FolderEvent. FolderEvent folderEvent = (FolderEvent)notification; Console.WriteLine("\nFolderId: " + folderEvent.FolderId.UniqueId); } } }
private void UnsubscribeAll() { // Unsubscribe all if (_subscriptions == null) { return; } for (int i = _subscriptions.Keys.Count - 1; i >= 0; i--) { string sMailbox = _subscriptions.Keys.ElementAt <string>(i); StreamingSubscription subscription = _subscriptions[sMailbox]; try { subscription.Unsubscribe(); _logger.Log(String.Format("Unsubscribed from {0}", sMailbox)); } catch (Exception ex) { _logger.Log(String.Format("Error when unsubscribing {0}: {1}", sMailbox, ex.Message)); } _subscriptions.Remove(sMailbox); } }
private void AddGroupSubscriptions(string sGroup) { if (!_groups.ContainsKey(sGroup)) { return; } if (_connections.ContainsKey(sGroup)) { foreach (StreamingSubscription subscription in _connections[sGroup].CurrentSubscriptions) { try { subscription.Unsubscribe(); } catch { } } try { _connections[sGroup].Close(); } catch { } } try { // Create the connection for this group, and the primary mailbox subscription GroupInfo group = _groups[sGroup]; StreamingSubscription subscription = AddSubscription(group.PrimaryMailbox, group); if (_connections.ContainsKey(sGroup)) { _connections[sGroup] = new StreamingSubscriptionConnection(subscription.Service, (int)numericUpDownTimeout.Value); } else { _connections.Add(sGroup, new StreamingSubscriptionConnection(subscription.Service, (int)numericUpDownTimeout.Value)); } SubscribeConnectionEvents(_connections[sGroup]); _connections[sGroup].AddSubscription(subscription); _logger.Log(String.Format("{0} (primary mailbox) subscription created in group {1}", group.PrimaryMailbox, sGroup)); // Now add any further subscriptions in this group foreach (string sMailbox in group.Mailboxes) { if (!sMailbox.Equals(group.PrimaryMailbox)) { try { subscription = AddSubscription(sMailbox, group); _connections[sGroup].AddSubscription(subscription); _logger.Log(String.Format("{0} subscription created in group {1}", sMailbox, sGroup)); } catch (Exception ex) { _logger.Log(String.Format("ERROR when subscribing {0} in group {1}: {2}", sMailbox, sGroup, ex.Message)); } } } } catch (Exception ex) { _logger.Log(String.Format("ERROR when creating subscription connection group {0}: {1}", sGroup, ex.Message)); } }
void ProcessNotification(object e, StreamingSubscription Subscription) { // We have received a notification string sMailbox = Subscription.Service.ImpersonatedUserId.Id; if (String.IsNullOrEmpty(sMailbox)) { sMailbox = "Unknown mailbox"; } string sEvent = sMailbox + ": "; if (e is ItemEvent) { if (!checkBoxShowItemEvents.Checked) { return; // We're ignoring item events } sEvent += "Item " + (e as ItemEvent).EventType.ToString() + ": "; } else if (e is FolderEvent) { if (!checkBoxShowFolderEvents.Checked) { return; // We're ignoring folder events } sEvent += "Folder " + (e as FolderEvent).EventType.ToString() + ": "; } try { if (checkBoxQueryMore.Checked) { // We want more information, we'll get this on a new thread NotificationInfo info; info.Mailbox = sMailbox; info.Event = e; info.Service = Subscription.Service; ThreadPool.QueueUserWorkItem(new WaitCallback(ShowMoreInfo), info); } else { // Just log event and ID if (e is ItemEvent) { sEvent += "ItemId = " + (e as ItemEvent).ItemId.UniqueId; } else if (e is FolderEvent) { sEvent += "FolderId = " + (e as FolderEvent).FolderId.UniqueId; } } } catch { } if (checkBoxQueryMore.Checked) { return; } ShowEvent(sEvent); }
// Catch and display notification events. static void OnNotificationEvent(object sender, NotificationEventArgs args) { bool callSyncContents = false; bool callSyncFolders = false; StreamingSubscription subscription = args.Subscription; // Loop through all item-related events. foreach (NotificationEvent notification in args.Events) { switch (notification.EventType) { case EventType.NewMail: Console.WriteLine("Notification: New mail created"); break; case EventType.Created: Console.WriteLine("Notification: Item or folder created"); break; case EventType.Deleted: Console.WriteLine("Notification: Item or folder deleted"); break; case EventType.Modified: Console.WriteLine("Notification: Item or folder modified"); break; case EventType.Moved: Console.WriteLine("Notification: Item or folder moved"); break; case EventType.Copied: Console.WriteLine("Notification: Item or folder copied"); break; } // Display the notification identifier. if (notification is ItemEvent) { ItemEvent itemEvent = (ItemEvent)notification; Console.WriteLine("Notification ItemId: " + itemEvent.ItemId.UniqueId); Console.WriteLine("--------"); callSyncContents = true; } else { FolderEvent folderEvent = (FolderEvent)notification; Console.WriteLine("Notification FolderId: " + folderEvent.FolderId.UniqueId); Console.WriteLine("--------"); callSyncFolders = true; } } // Delay calling SyncContents and SyncFolders until all notifications have been processed. // This will reduce the number of calls to the Exchange database by batching more changes // into a single sync call. if (callSyncContents == true) { ContentsSyncState = SyncContents(service, ContentsSyncState, RootSyncFolder); } if (callSyncFolders == true) { FolderSyncState = SyncFolders(service, FolderSyncState, RootSyncFolder); } }
public StreamingSubscriptionConnection AddGroupSubscriptions( ref Dictionary <string, StreamingSubscriptionConnection> Connections, ref Dictionary <string, StreamingSubscription> SubscriptionList, EventType[] SubscribeEvents, FolderId[] SubscribeFolders, ClassLogger Logger, int TimeOut = 30) { if (Connections.ContainsKey(_name)) { foreach (StreamingSubscription subscription in Connections[_name].CurrentSubscriptions) { try { subscription.Unsubscribe(); } catch { } } try { if (Connections[_name].IsOpen) { Connections[_name].Close(); } } catch { } Connections.Remove(_name); } StreamingSubscriptionConnection groupConnection = null; try { // Create the subscription to the primary mailbox, then create the subscription connection if (SubscriptionList.ContainsKey(_primaryMailbox)) { SubscriptionList.Remove(_primaryMailbox); } StreamingSubscription subscription = AddSubscription(_primaryMailbox, ref SubscriptionList, SubscribeEvents, SubscribeFolders); groupConnection = new StreamingSubscriptionConnection(subscription.Service, TimeOut); Connections.Add(_name, groupConnection); //SubscribeConnectionEvents(groupConnection); groupConnection.AddSubscription(subscription); Logger.Log($"{_primaryMailbox} (primary mailbox) subscription created in group {_name}"); // Now add any further subscriptions in this group foreach (string sMailbox in _mailboxes) { if (!sMailbox.Equals(_primaryMailbox)) { try { if (SubscriptionList.ContainsKey(sMailbox)) { SubscriptionList.Remove(sMailbox); } subscription = AddSubscription(sMailbox, ref SubscriptionList, SubscribeEvents, SubscribeFolders); groupConnection.AddSubscription(subscription); Logger.Log($"{sMailbox} subscription created in group {_name}"); } catch (Exception ex) { Logger.Log(String.Format("ERROR when subscribing {0} in group {1}: {2}", sMailbox, _name, ex.Message)); } } } } catch (Exception ex) { Logger.Log($"ERROR when creating subscription connection group {_name}: {ex.Message}"); } return(groupConnection); }
/// <summary> /// Process the GroupInfo and create subscriptions based on AnchorMailbox /// </summary> /// <param name="context">Database context for subscription update</param> /// <param name="groupName">EWS GroupInfo or Dynamic Groupname if Mailboxes > 200</param> /// <returns></returns> public bool AddGroupSubscriptions(EWSDbContext context, string groupName) { if (!_groups.ContainsKey(groupName)) { return(false); } if (_connections == null) { _connections = new Dictionary <string, StreamingSubscriptionConnection>(); } if (_connections.ContainsKey(groupName)) { var _connection = _connections[groupName]; foreach (StreamingSubscription subscription in _connection.CurrentSubscriptions) { try { subscription.Unsubscribe(); } catch { } } try { _connection.Close(); _groups[groupName].IsConnectionOpen = false; } catch { } } try { // Create the connection for this group, and the primary mailbox subscription var groupInfo = _groups[groupName]; var PrimaryMailbox = groupInfo.PrimaryMailbox; // Return the subscription, or create a new one if we don't already have one StreamingSubscription mailboxSubscription = AddSubscription(context, groupInfo, PrimaryMailbox); if (_connections.ContainsKey(groupName)) { _connections[groupName] = new StreamingSubscriptionConnection(mailboxSubscription.Service, pollingTimeout); } else { _connections.Add(groupName, new StreamingSubscriptionConnection(mailboxSubscription.Service, pollingTimeout)); } SubscribeConnectionEvents(_connections[groupName]); _connections[groupName].AddSubscription(mailboxSubscription); _traceListener.Trace("SyncProgram", $"{PrimaryMailbox} (primary mailbox) subscription created in group {groupName}"); // Now add any further subscriptions in this group foreach (string sMailbox in groupInfo.Mailboxes.Where(w => !w.Equals(PrimaryMailbox))) { try { var localSubscription = AddSubscription(context, groupInfo, sMailbox); _connections[groupName].AddSubscription(localSubscription); _traceListener.Trace("Add secondary subscription", $"{sMailbox} subscription created in group {groupName}"); } catch (Exception ex) { _traceListener.Trace("Exception", $"ERROR when subscribing {sMailbox} in group {groupName}: {ex.Message}"); } } } catch (Exception ex) { _traceListener.Trace("Exception", $"ERROR when creating subscription connection group {groupName}: {ex.Message}"); } return(true); }
////DJB //private void GetGroupingInfo(ExchangeService oExchangeService, string DiscoverMailbox) //{ // //oExchangeService.get // string UseVersion = oExchangeService.RequestedServerVersion.ToString(); // string UseUrl = oExchangeService.Url.ToString(); // djb - need to fix it to the autodiscover url. // string EwsRequest = EwsRequests.GroupingInformationTemplateRequest; // EwsRequest = EwsRequest.Replace("XXXExchangeVersionXXX", UseVersion); // EwsRequest = EwsRequest.Replace("XXXAutoDiscoverServiceServerXXX", UseUrl); // EwsRequest = EwsRequest.Replace("XXXMailboxSmtpXXX", DiscoverMailbox); // // DO raw post // // string sResponse // // if (DoRawPost(UseUrl, oExchangeService.ServerCredentials, EwsRequest, ref sResponse)); // // { // // Extract GroupingInformation and external url from sResponse); // // } // // else // // { // // return error; // // } //} private void StreamingSubscribeWork() { // djb // get a list of maiboxes, thier external ews urls and grouping info // list of items = GetGroupingInfo(ExchangeService oExchangeService, string DiscoverMailbox); // Sort list of items by url + GroupingInformaiton // try { lock (WorkThreads) { WorkThreads.Add(Thread.CurrentThread); SetControlText(ThreadCount, WorkThreads.Count.ToString()); } if (chkSerialize.Checked) { mutConnection.WaitOne(); } string TID = Thread.CurrentThread.ManagedThreadId.ToString("[0]"); ListViewItem item = new ListViewItem(); item.Tag = "[local]ThreadStart"; item.Text = "[local]ThreadStart"; item.SubItems.Add(TID); item.SubItems.Add(DateTime.Now.ToString()); AddToDisplay(lstEvents, item); // Note that EWS Managed API objects should not beshared accross threads - So, each thread should have its own service object. //EWSEditor.Common.EwsEditorServiceInstanceSettings.EwsEditorAppSettings oSettings = new EWSEditor.Common.EwsEditorServiceInstanceSettings.EwsEditorAppSettings(); EWSEditor.Common.EwsEditorAppSettings oCurrentAppSettings = null; ExchangeService ThreadLocalService = EwsProxyFactory.CreateExchangeService( ); // Todo: Flush out oCurrentAppSettings CurrentAppSettings = oCurrentAppSettings; List <StreamingSubscription> ThreadLocalSubscriptions = new List <StreamingSubscription>(); // Create the subscriptions based on the form settings for (int i = 0; i < numSubs.Value; i++) { try { StreamingSubscription CurrentSubscription = null; if (chkAllFoldes.Checked == false) { CurrentSubscription = ThreadLocalService.SubscribeToStreamingNotifications( new FolderId[] { this.CurrentFolderId }, EventTypes.ToArray()); //System.Diagnostics.Debug.WriteLine("-"); //System.Diagnostics.Debug.WriteLine("Subscribe - ID: " + CurrentSubscription.Id + " Watermark: " + CurrentSubscription.Watermark); //System.Diagnostics.Debug.WriteLine("-"); } else { CurrentSubscription = ThreadLocalService.SubscribeToStreamingNotificationsOnAllFolders( EventTypes.ToArray()); //System.Diagnostics.Debug.WriteLine("-"); //System.Diagnostics.Debug.WriteLine("Subscribe - ID: " + CurrentSubscription.Id + " Watermark: " + CurrentSubscription.Watermark); //System.Diagnostics.Debug.WriteLine("-"); } ThreadLocalSubscriptions.Add(CurrentSubscription); lock (ActiveSubscriptions) { ActiveSubscriptions.Add(CurrentSubscription); SetControlText(SubscriptionCount, ActiveSubscriptions.Count.ToString()); } } catch (Exception ex) { DebugLog.WriteException("Error Subscribe or Add [TID:" + TID + "]", ex); item = new ListViewItem(); item.Tag = "[local]SubscribeError"; item.Text = "[local]SubscribeError"; item.ToolTipText = ex.ToString(); item.SubItems.Add(TID); item.SubItems.Add(DateTime.Now.ToString()); AddToDisplay(lstEvents, item); } } // Create a new StreamingSubscriptionConnection StreamingSubscriptionConnection CurrentConnection = new StreamingSubscriptionConnection(ThreadLocalService, (int)SubscriptionLifetime.Value); lock (ActiveConnections) { ActiveConnections.Add(CurrentConnection); SetControlText(ConnectionCount, ActiveConnections.Count.ToString()); } // Add Handlers CurrentConnection.OnDisconnect += OnDisconnect; CurrentConnection.OnSubscriptionError += OnSubscriptionError; CurrentConnection.OnNotificationEvent += OnStreamingEvent; // Add the Subscriptions to the Connection foreach (StreamingSubscription CurrentSubscription in ThreadLocalSubscriptions) { CurrentConnection.AddSubscription(CurrentSubscription); } if (chkSerialize.Checked) { mutConnection.ReleaseMutex(); } // Open the Connection try { if (ThreadLocalService.CookieContainer.Count > 0) { System.Net.CookieCollection MyCookies = ThreadLocalService.CookieContainer.GetCookies(ThreadLocalService.Url); } CurrentConnection.Open(); ShutdownThreads.WaitOne(); } catch (Exception ex) { DebugLog.WriteException("Error Opening StreamingSubscriptionConnection [TID:" + Thread.CurrentThread.ManagedThreadId.ToString() + "]", ex); item = new ListViewItem(); item.Tag = "[local]OpenError"; item.Text = "[local]OpenError"; item.ToolTipText = ex.ToString(); item.SubItems.Add(TID); item.SubItems.Add(DateTime.Now.ToString()); AddToDisplay(lstEvents, item); //System.Diagnostics.Debug.WriteLine("-"); //System.Diagnostics.Debug.WriteLine("Error Opening StreamingSubscriptionConnection [TID:" + Thread.CurrentThread.ManagedThreadId.ToString() + "]", ex); //System.Diagnostics.Debug.WriteLine("-"); } try { // Close Connection if (CurrentConnection.IsOpen) { CurrentConnection.Close(); // Thread.Sleep(500); } } catch (Exception ex) { DebugLog.WriteException("Error Closing Streaming Connection [TID:" + Thread.CurrentThread.ManagedThreadId.ToString() + "]", ex); item = new ListViewItem(); item.Tag = "[local]CloseError"; item.Text = "[local]CloseError"; item.ToolTipText = ex.ToString(); item.SubItems.Add(TID); item.SubItems.Add(DateTime.Now.ToString()); AddToDisplay(lstEvents, item); //System.Diagnostics.Debug.WriteLine("-"); //System.Diagnostics.Debug.WriteLine("Error Closing Streaming Connection [TID:" + Thread.CurrentThread.ManagedThreadId.ToString() + "]", ex); //System.Diagnostics.Debug.WriteLine("-"); } finally { lock (ActiveConnections) { ActiveConnections.Remove(CurrentConnection); SetControlText(ConnectionCount, ActiveConnections.Count.ToString()); } } // Remove Handlers CurrentConnection.OnDisconnect -= OnDisconnect; CurrentConnection.OnSubscriptionError -= OnSubscriptionError; CurrentConnection.OnNotificationEvent -= OnStreamingEvent; foreach (StreamingSubscription CurrentSubscription in ThreadLocalSubscriptions) { try { CurrentConnection.RemoveSubscription(CurrentSubscription); CurrentSubscription.Unsubscribe(); //System.Diagnostics.Debug.WriteLine("-"); //System.Diagnostics.Debug.WriteLine("Unsubscribed - ID: " + CurrentSubscription.Id + " Watermark: " + CurrentSubscription.Watermark); //System.Diagnostics.Debug.WriteLine("-"); } catch (Exception ex) { DebugLog.WriteException("Error Removing/Unsubscribing StreamingSubscription Elements [TID:" + Thread.CurrentThread.ManagedThreadId.ToString() + "]", ex); item = new ListViewItem(); item.Tag = "[local]UnsubscribeError"; item.Text = "[local]UnsubscribeError"; item.ToolTipText = ex.ToString(); item.SubItems.Add(TID); item.SubItems.Add(DateTime.Now.ToString()); AddToDisplay(lstEvents, item); //System.Diagnostics.Debug.WriteLine("-"); //System.Diagnostics.Debug.WriteLine("Error Removing/Unsubscribing StreamingSubscription Elements [TID:" + Thread.CurrentThread.ManagedThreadId.ToString() + "]", ex); //System.Diagnostics.Debug.WriteLine(" ID: " + CurrentSubscription.Id + " Watermark: " + CurrentSubscription.Watermark); //System.Diagnostics.Debug.WriteLine("-"); } finally { lock (ActiveSubscriptions) { //System.Diagnostics.Debug.WriteLine("-"); //System.Diagnostics.Debug.WriteLine("Removing subscription - ID: " + CurrentSubscription.Id + " Watermark: " + CurrentSubscription.Watermark); //System.Diagnostics.Debug.WriteLine("-"); ActiveSubscriptions.Remove(CurrentSubscription); SetControlText(SubscriptionCount, ActiveSubscriptions.Count.ToString()); } } } lock (WorkThreads) { WorkThreads.Remove(Thread.CurrentThread); } SetControlText(ThreadCount, WorkThreads.Count.ToString()); } catch (Exception ex) { DebugLog.WriteException("Unexpected Exception in WorkerThread", ex); } finally { } }