Fixed issue #41

PurpleExplorer/Helpers/ITopicHelper.cs

@@ -9,15 +9,15 @@ namespace PurpleExplorer.Helpers
     public interface ITopicHelper
     {
         public Task<NamespaceInfo> GetNamespaceInfo(string connectionString);
-        public Task<IList<ServiceBusTopic>> GetTopics(string connectionString);
+        public Task<IList<ServiceBusTopic>> GetTopicsAndSubscriptions(string connectionString);
+        public Task<ServiceBusTopic> GetTopic(string connectionString, string topicPath, bool retrieveSubscriptions);
         public Task<IList<ServiceBusSubscription>> GetSubscriptions(string connectionString, string topicPath);
+        public Task<ServiceBusSubscription> GetSubscription(string connectionString, string topicPath, string subscriptionName);
         public Task<IList<Message>> GetDlqMessages(string connectionString, string topic, string subscription);
         public Task<IList<Models.Message>> GetMessagesBySubscription(string connectionString, string topicName, string subscriptionName);
         public Task SendMessage(string connectionString, string topicPath, string content);
         public Task SendMessage(string connectionString, string topicPath, AzureMessage message);
         public Task DeleteMessage(string connectionString, string topicPath, string subscriptionPath, Message message, bool isDlq);
-        public Task<SubscriptionRuntimeInfo> GetSubscriptionRuntimeInfo(string connectionString, string topicPath,
-            string subscriptionName);
         public Task<long> PurgeMessages(string connectionString, string topicPath, string subscriptionPath, bool isDlq);
         public Task<long> TransferDlqMessages(string connectionString, string topicPath, string subscriptionPath);
         public Task ResubmitDlqMessage(string connectionString, string topicPath, string subscriptionPath,

PurpleExplorer/Helpers/TopicHelper.cs

@@ -16,38 +16,49 @@ public class TopicHelper : ITopicHelper
     {
         private int _maxMessageCount = 100;
 
-        public async Task<IList<ServiceBusTopic>> GetTopics(string connectionString)
+        public async Task<IList<ServiceBusTopic>> GetTopicsAndSubscriptions(string connectionString)
         {
             IList<ServiceBusTopic> topics = new List<ServiceBusTopic>();
             var client = new ManagementClient(connectionString);
             var busTopics = await client.GetTopicsAsync();
             await client.CloseAsync();
 
-            await Task.WhenAll(busTopics.Select(async t =>
+            await Task.WhenAll(busTopics.Select(async topic =>
             {
-                var topicName = t.Path;
-                var subscriptions = await GetSubscriptions(connectionString, topicName);
-
-                var newTopic = new ServiceBusTopic
-                {
-                    Name = topicName
-                };
+                var newTopic = new ServiceBusTopic(topic);
 
+                var subscriptions = await GetSubscriptions(connectionString, newTopic.Name);
                 newTopic.AddSubscriptions(subscriptions.ToArray());
                 topics.Add(newTopic);
             }));
 
             return topics;
         }
 
-        public async Task<SubscriptionRuntimeInfo> GetSubscriptionRuntimeInfo(string connectionString,
-            string topicPath, string subscriptionName)
+        public async Task<ServiceBusTopic> GetTopic(string connectionString, string topicPath, bool retrieveSubscriptions)
         {
-            ManagementClient client = new ManagementClient(connectionString);
+            var client = new ManagementClient(connectionString);
+            var busTopics = await client.GetTopicAsync(topicPath);
+            await client.CloseAsync();
+
+            var newTopic = new ServiceBusTopic(busTopics);
+
+            if (retrieveSubscriptions)
+            {
+                var subscriptions = await GetSubscriptions(connectionString, newTopic.Name);
+                newTopic.AddSubscriptions(subscriptions.ToArray());
+            }
+
+            return newTopic;
+        }
+
+        public async Task<ServiceBusSubscription> GetSubscription(string connectionString, string topicPath, string subscriptionName)
+        {
+            var client = new ManagementClient(connectionString);
             var runtimeInfo = await client.GetSubscriptionRuntimeInfoAsync(topicPath, subscriptionName);
             await client.CloseAsync();
 
-            return runtimeInfo;
+            return new ServiceBusSubscription(runtimeInfo);
         }
 
         public async Task<IList<ServiceBusSubscription>> GetSubscriptions(string connectionString, string topicPath)

PurpleExplorer/Models/MessageCollection.cs

@@ -1,5 +1,6 @@
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
+using System.Linq;
 using DynamicData;
 using ReactiveUI;
 
@@ -10,6 +11,7 @@ namespace PurpleExplorer.Models
     /// </summary>
     public abstract class MessageCollection : ReactiveObject
     {
+        // These are needed to be set before fetching messages, in the second constructor
         private long _messageCount;
         private long _dlqCount;
 
@@ -19,13 +21,13 @@ public abstract class MessageCollection : ReactiveObject
         public long MessageCount
         {
             get => _messageCount;
-            set => this.RaiseAndSetIfChanged(ref _messageCount, value);
+            private set => this.RaiseAndSetIfChanged(ref _messageCount, value);
         }
 
         public long DlqCount
         {
             get => _dlqCount;
-            set => this.RaiseAndSetIfChanged(ref _dlqCount, value);
+            private set => this.RaiseAndSetIfChanged(ref _dlqCount, value);
         }
 
         protected MessageCollection()
@@ -43,25 +45,37 @@ protected MessageCollection(long messageCount, long dlqCount) : this()
         public void AddMessages(IEnumerable<Message> messages)
         {
             Messages.AddRange(messages);
-            _messageCount = Messages.Count;
+            MessageCount = Messages.Count;
         }
 
+        public void RemoveMessage(string messageId)
+        {
+            Messages.Remove(Messages.Single(msg => msg.MessageId.Equals(messageId)));
+            MessageCount = Messages.Count;
+        }
+
         public void ClearMessages()
         {
             Messages.Clear();
-            _messageCount = 0;
+            MessageCount = Messages.Count;
         }
 
         public void AddDlqMessages(IEnumerable<Message> dlqMessages)
         {
             DlqMessages.AddRange(dlqMessages);
-            _dlqCount = DlqMessages.Count;
+            DlqCount = DlqMessages.Count;
+        }
+
+        public void RemoveDlqMessage(string messageId)
+        {
+            DlqMessages.Remove(DlqMessages.Single(msg => msg.MessageId.Equals(messageId)));
+            DlqCount = DlqMessages.Count;
         }
 
         public void ClearDlqMessages()
         {
             DlqMessages.Clear();
-            _dlqCount = 0;
+            DlqCount = DlqMessages.Count;
         }
     }
 }

PurpleExplorer/Models/ServiceBusResource.cs

@@ -1,10 +1,12 @@
+using System;
 using System.Collections.ObjectModel;
 
 namespace PurpleExplorer.Models
 {
     public class ServiceBusResource 
     {
         public string Name { get; set; }
+        public DateTime CreatedTime { get; set; }
         public string ConnectionString { get; set; }
         public ObservableCollection<ServiceBusQueue> Queues { get; private set; }
         public ObservableCollection<ServiceBusTopic> Topics { get; private set; }
@@ -30,5 +32,11 @@ public void AddQueues(params ServiceBusQueue[] queues)
                 Queues.Add(queue);
             }
         }
+
+        public override bool Equals(object? obj)
+        {
+            var comparingResource = obj as ServiceBusResource;
+            return Name.Equals(comparingResource.Name) && CreatedTime.Equals(comparingResource.CreatedTime);
+        }
     }
 }

PurpleExplorer/Models/ServiceBusTopic.cs

@@ -1,4 +1,5 @@
 using System.Collections.ObjectModel;
+using Microsoft.Azure.ServiceBus.Management;
 
 namespace PurpleExplorer.Models
 {
@@ -8,6 +9,16 @@ public class ServiceBusTopic
         public ObservableCollection<ServiceBusSubscription> Subscriptions { get; private set; }
         public ServiceBusResource ServiceBus { get; set; }
 
+        public ServiceBusTopic()
+        {
+        }
+
+        public ServiceBusTopic(TopicDescription topicDescription)
+        {
+            Name = topicDescription.Path;
+        }
+
+
         public void AddSubscriptions(params ServiceBusSubscription[] subscriptions)
         {
             Subscriptions ??= new ObservableCollection<ServiceBusSubscription>();

PurpleExplorer/ViewModels/MainWindowViewModel.cs

@@ -183,18 +183,19 @@ await ModalWindowHelper.ShowModalWindow<ConnectionStringWindow, ConnectionString
                 LoggingService.Log("Connecting...");
 
                 var namespaceInfo = await _topicHelper.GetNamespaceInfo(ConnectionString);
-                var topics = await _topicHelper.GetTopics(ConnectionString);
+                var topics = await _topicHelper.GetTopicsAndSubscriptions(ConnectionString);
                 var queues = await _queueHelper.GetQueues(ConnectionString);
 
-                var newResource = new ServiceBusResource
+                var serviceBusResource = new ServiceBusResource
                 {
                     Name = namespaceInfo.Name,
-                    ConnectionString = this.ConnectionString
+                    CreatedTime = namespaceInfo.CreatedTime,
+                    ConnectionString = ConnectionString
                 };
 
-                newResource.AddQueues(queues.ToArray());
-                newResource.AddTopics(topics.ToArray());
-                ConnectedServiceBuses.Add(newResource);
+                serviceBusResource.AddQueues(queues.ToArray());
+                serviceBusResource.AddTopics(topics.ToArray());
+                ConnectedServiceBuses.Add(serviceBusResource);
                 LoggingService.Log("Connected to Service Bus: " + namespaceInfo.Name);
             }
             catch (ArgumentException)
@@ -306,6 +307,20 @@ public void RefreshTabHeaders()
             }
         }
 
+        public async Task RefreshConnectedServiceBuses()
+        {
+            foreach (var serviceBusResource in ConnectedServiceBuses)
+            {
+                var topicsAndSubscriptions = await _topicHelper.GetTopicsAndSubscriptions(serviceBusResource.ConnectionString);
+                var serviceBusQueues = await _queueHelper.GetQueues(serviceBusResource.ConnectionString);
+
+                serviceBusResource.Topics.Clear();
+                serviceBusResource.Queues.Clear();
+                serviceBusResource.AddTopics(topicsAndSubscriptions.ToArray());
+                serviceBusResource.AddQueues(serviceBusQueues.ToArray());
+            }
+        }
+
         public async void AddMessage()
         {
             var viewModal = new AddMessageWindowViewModal();
@@ -419,21 +434,34 @@ public async void PurgeMessages(string isDlqText)
                 var connectionString = CurrentSubscription.Topic.ServiceBus.ConnectionString;
                 purgedCount = await _topicHelper.PurgeMessages(connectionString, _currentTopic.Name,
                     _currentSubscription.Name, isDlq);
+
+                if (!isDlq)
+                    CurrentSubscription.ClearMessages();
+                else
+                    CurrentSubscription.ClearDlqMessages();
             }
 
             if (CurrentQueue != null)
             {
                 var connectionString = CurrentQueue.ServiceBus.ConnectionString;
                 purgedCount = await _queueHelper.PurgeMessages(connectionString, _currentQueue.Name, isDlq);
+
+                if (!isDlq)
+                    CurrentQueue.ClearMessages();
+                else
+                    CurrentQueue.ClearDlqMessages();
             }
-
             LoggingService.Log($"Purged {purgedCount} messages in {purgingPath}");
+
+            // Refreshing messages
+            await FetchMessages();
         }
 
         public async Task Refresh()
         {
-            await FetchMessages();
+            await RefreshConnectedServiceBuses();
             RefreshTabHeaders();
+            await FetchMessages();
         }
 
         public async Task FetchMessages()

PurpleExplorer/ViewModels/MessageDetailsWindowViewModel.cs

@@ -67,12 +67,22 @@ public async void DeleteMessage(Window window)
                 var connectionString = Subscription.Topic.ServiceBus.ConnectionString;
                 await _topicHelper.DeleteMessage(connectionString, Subscription.Topic.Name, Subscription.Name,
                     Message, Message.IsDlq);
+
+                if(!Message.IsDlq) 
+                    Subscription.RemoveMessage(Message.MessageId);
+                else
+                    Subscription.RemoveDlqMessage(Message.MessageId);
             }
 
             if (Queue != null)
             {
                 var connectionString = Queue.ServiceBus.ConnectionString;
                 await _queueHelper.DeleteMessage(connectionString, Queue.Name, Message, Message.IsDlq);
+
+                if(!Message.IsDlq) 
+                    Queue.RemoveMessage(Message.MessageId);
+                else
+                    Queue.RemoveDlqMessage(Message.MessageId);
             }
 
             _loggingService.Log($"Message deleted, MessageId: {Message.MessageId}");