added unread counter

Lyra1337 · Lyra1337 · commit af3f175854b1 · 2025-06-12T01:19:48.000+02:00
diff --git a/Services/MailboxService.cs b/Services/MailboxService.cs
@@ -199,10 +199,5 @@ public async Task<string> GenerateNewMailbox(string publicKey, string password)
 
             return mailAddress;
         }
-
-        public async Task SetMailReadMark(int mailId, bool isRead)
-        {
-            await this.mailRepository.SetReadMark(mailId, isRead);
-        }
     }
 }
diff --git a/Web/Pages/Mailbox.razor.cs b/Web/Pages/Mailbox.razor.cs
@@ -43,8 +43,8 @@ private void MailboxSessionService_MailReceived(object sender, EventArgs e)
         protected async Task ShowMail(MailPreviewDto mailPreview)
         {
             this.CurrentMail = await this.MailboxSessionService.GetMailByIdAsync(mailPreview.Id);
-            await this.MailboxService.SetMailReadMark(mailPreview.Id, true);
             mailPreview.IsRead = true;
+            await this.MailboxSessionService.SetMailReadMark(mailPreview.Id, true);
         }
 
         protected async Task DeleteCurrentMail()
diff --git a/Web/Services/MailboxSessionService.cs b/Web/Services/MailboxSessionService.cs
@@ -5,35 +5,20 @@
 
 namespace Lyralabs.TempMailServer.Web.Services
 {
-    public class MailboxSessionService : IRecipient<MailReceivedMessage>, IDisposable
+    public class MailboxSessionService(
+        UserState userState,
+        ILocalStorageService localStorage,
+        AsymmetricCryptoService cryptoService,
+        MailboxService mailboxService,
+        MailRepository mailRepository,
+        IMessenger messenger,
+        ILogger<MailboxSessionService> logger) : IRecipient<MailReceivedMessage>, IDisposable
     {
         public event EventHandler MailReceived;
-
-        private readonly UserState userState;
-        private readonly ILocalStorageService localStorage;
-        private readonly AsymmetricCryptoService cryptoService;
-        private readonly MailboxService mailboxService;
-        private readonly IMessenger messenger;
-        private readonly ILogger<MailboxSessionService> logger;
+        public event EventHandler MailRead;
 
         public List<MailPreviewDto> Mails { get; private set; } = [];
 
-        public MailboxSessionService(
-            UserState userState,
-            ILocalStorageService LocalStorage,
-            AsymmetricCryptoService cryptoService,
-            MailboxService mailboxService,
-            IMessenger messenger,
-            ILogger<MailboxSessionService> logger)
-        {
-            this.userState = userState;
-            this.localStorage = LocalStorage;
-            this.cryptoService = cryptoService;
-            this.mailboxService = mailboxService;
-            this.messenger = messenger;
-            this.logger = logger;
-        }
-
         public void TestEmail()
         {
             try
@@ -42,7 +27,7 @@ public void TestEmail()
                 client.Timeout = 1000;
 
                 var from = new MailAddress("steve@contoso.com", "Steve Ballmer");
-                var to = new MailAddress(this.userState.CurrentMailbox, "Steve Jobs");
+                var to = new MailAddress(userState.CurrentMailbox, "Steve Jobs");
                 var msg = new MailMessage(from, to);
                 msg.Subject = "Test Mail";
                 msg.Body = $"Test Mail issued at {DateTime.UtcNow} (UTC)\r\n{Guid.NewGuid()}";
@@ -51,74 +36,80 @@ public void TestEmail()
             }
             catch (Exception ex)
             {
-                this.logger.LogError(ex, "failed to send test-email");
+                logger.LogError(ex, "failed to send test-email");
             }
         }
 
         public async Task<UserSecret> GetOrCreateUserSecret()
         {
-            if (await this.localStorage.ContainKeyAsync("secret") == true)
+            if (await localStorage.ContainKeyAsync("secret") == true)
             {
-                var secretFromStorage = await this.localStorage.GetItemAsync<UserSecret>("secret");
+                var secretFromStorage = await localStorage.GetItemAsync<UserSecret>("secret");
 
                 if (secretFromStorage.PrivateKey != null && secretFromStorage.PublicKey != null && secretFromStorage.Password != null)
                 {
                     return secretFromStorage;
                 }
             }
 
-            var secret = this.cryptoService.GenerateUserSecret();
+            var secret = cryptoService.GenerateUserSecret();
 
-            await this.localStorage.SetItemAsync("secret", secret);
+            await localStorage.SetItemAsync("secret", secret);
 
             return secret;
         }
 
         public async Task Refresh()
         {
-            this.Mails = await this.mailboxService.GetDecryptedMailsAsync(this.userState.CurrentMailbox, this.userState.Secret.Value.PrivateKey);
+            this.Mails = await mailboxService.GetDecryptedMailsAsync(userState.CurrentMailbox, userState.Secret.Value.PrivateKey);
             this.MailReceived?.Invoke(this, EventArgs.Empty);
         }
 
         public void Receive(MailReceivedMessage message)
         {
-            this.Mails.Insert(0, this.mailboxService.ConvertToPreview(message.Mail));
+            this.Mails.Insert(0, mailboxService.ConvertToPreview(message.Mail));
             this.MailReceived?.Invoke(this, EventArgs.Empty);
         }
 
         public async Task DeleteMail(int mailid)
         {
-            await this.mailboxService.DeleteMail(mailid);
+            await mailboxService.DeleteMail(mailid);
             this.Mails.Remove(this.Mails.Single(m => m.Id == mailid));
         }
 
         public async Task GetMailbox(bool forceNew = false)
         {
-            var userSecret = this.userState.Secret.Value;
+            var userSecret = userState.Secret.Value;
 
             if (forceNew == true)
             {
-                this.userState.CurrentMailbox = await this.mailboxService.GenerateNewMailbox(userSecret.PublicKey, userSecret.Password);
+                userState.CurrentMailbox = await mailboxService.GenerateNewMailbox(userSecret.PublicKey, userSecret.Password);
             }
             else
             {
-                this.userState.CurrentMailbox = await this.mailboxService.GetOrCreateMailboxAsync(userSecret.PrivateKey, userSecret.Password);
+                userState.CurrentMailbox = await mailboxService.GetOrCreateMailboxAsync(userSecret.PrivateKey, userSecret.Password);
             }
 
-            this.messenger.Register(this, this.userState.CurrentMailbox);
+            messenger.Register(this, userState.CurrentMailbox);
 
             await this.Refresh();
         }
 
         internal async Task<MailModel> GetMailByIdAsync(int mailId)
         {
-            var mail = await this.mailboxService.GetDecryptedMailById(this.userState.CurrentMailbox, mailId, this.userState.Secret.Value.PrivateKey);
+            var mail = await mailboxService.GetDecryptedMailById(userState.CurrentMailbox, mailId, userState.Secret.Value.PrivateKey);
             return mail;
         }
 
+        public async Task SetMailReadMark(int mailId, bool isRead)
+        {
+            await mailRepository.SetReadMark(mailId, isRead);
+            this.MailRead?.Invoke(this, EventArgs.Empty);
+        }
+
         public void Dispose()
         {
-            this.messenger.UnregisterAll(this);
+            messenger.UnregisterAll(this);
             this.Mails.Clear();
         }
     }
diff --git a/Web/Shared/SideNavigationMenu.razor b/Web/Shared/SideNavigationMenu.razor
@@ -18,6 +18,10 @@
                 <NavLink class="nav-link" href="inbox" Match="NavLinkMatch.All">
                     <i class="fas fa-inbox"></i>
                     Mailbox
+                    @if (this.UnreadCount > 0)
+                    {
+                        <span class="badge bg-primary rounded-pill ms-2">@this.UnreadCount</span>
+                    }
                 </NavLink>
             </li>
         </ul>
diff --git a/Web/Shared/SideNavigationMenu.razor.cs b/Web/Shared/SideNavigationMenu.razor.cs
@@ -3,7 +3,7 @@
 
 namespace Lyralabs.TempMailServer.Web.Shared
 {
-    partial class SideNavigationMenu
+    partial class SideNavigationMenu : IDisposable
     {
         [Inject]
         protected IJSRuntime JsRuntime { get; set; }
@@ -19,17 +19,19 @@ partial class SideNavigationMenu
 
         public bool IsMailboxActive { get; private set; }
 
+        public int UnreadCount { get; private set; }
+
         protected override void OnParametersSet()
         {
             this.CheckMailboxUrl();
         }
 
-        protected override async Task OnAfterRenderAsync(bool firstRender)
+        protected override async Task OnInitializedAsync()
         {
-            if (firstRender == false)
-            {
-                return;
-            }
+            await base.OnInitializedAsync();
+
+            this.MailboxSessionService.MailReceived += this.MailboxSessionService_MailReceived;
+            this.MailboxSessionService.MailRead += this.MailboxSessionService_MailRead;
 
             if (this.UserState.Secret is null)
             {
@@ -44,11 +46,20 @@ protected override async Task OnAfterRenderAsync(bool firstRender)
             {
                 await this.Refresh();
             }
+
+            this.NavigationManager.LocationChanged += this.NavigationManager_LocationChanged;
         }
 
-        protected override void OnInitialized()
+        private void MailboxSessionService_MailRead(object sender, EventArgs e)
         {
-            this.NavigationManager.LocationChanged += this.NavigationManager_LocationChanged;
+            this.UnreadCount = this.MailboxSessionService.Mails.Count(mail => mail.IsRead == false);
+            this.InvokeAsync(this.StateHasChanged);
+        }
+
+        private void MailboxSessionService_MailReceived(object sender, EventArgs e)
+        {
+            this.UnreadCount = this.MailboxSessionService.Mails.Count(mail => mail.IsRead == false);
+            _ = this.InvokeAsync(this.StateHasChanged);
         }
 
         private void NavigationManager_LocationChanged(object sender, LocationChangedEventArgs e)
@@ -62,13 +73,12 @@ private void CheckMailboxUrl()
             this.IsMailboxActive = Uri.TryCreate(this.NavigationManager.Uri, UriKind.Absolute, out var uri) == true
                 && uri.LocalPath.Equals("/inbox", StringComparison.OrdinalIgnoreCase) == true;
 
-            this.StateHasChanged();
+            _ = this.InvokeAsync(this.StateHasChanged);
         }
 
         protected async Task Refresh()
         {
             await this.MailboxSessionService.Refresh();
-            this.StateHasChanged();
         }
 
         protected void TestEmail()
@@ -78,7 +88,18 @@ protected void TestEmail()
 
         protected async Task NewAddress()
         {
-            await this.MailboxSessionService.GetMailbox(forceNew: true);
+            var result = await this.JsRuntime.InvokeAsync<bool?>("confirm", "Are you sure you want to create a new mailbox? This will delete all your current emails.");
+
+            if (result == true)
+            {
+                await this.MailboxSessionService.GetMailbox(forceNew: true);
+            }
+        }
+
+        public void Dispose()
+        {
+            this.MailboxSessionService.MailReceived -= this.MailboxSessionService_MailReceived;
+            this.MailboxSessionService.MailRead -= this.MailboxSessionService_MailRead;
         }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -199,10 +199,5 @@ public async Task<string> GenerateNewMailbox(string publicKey, string password)`
`199`	`199`
`200`	`200`	`return mailAddress;`
`201`	`201`	`}`
`202`		`-`
`203`		`- public async Task SetMailReadMark(int mailId, bool isRead)`
`204`		`- {`
`205`		`- await this.mailRepository.SetReadMark(mailId, isRead);`
`206`		`- }`
`207`	`202`	`}`
`208`	`203`	`}`
Original file line number	Diff line number	Diff line change
`@@ -43,8 +43,8 @@ private void MailboxSessionService_MailReceived(object sender, EventArgs e)`
`43`	`43`	`protected async Task ShowMail(MailPreviewDto mailPreview)`
`44`	`44`	`{`
`45`	`45`	`this.CurrentMail = await this.MailboxSessionService.GetMailByIdAsync(mailPreview.Id);`
`46`		`- await this.MailboxService.SetMailReadMark(mailPreview.Id, true);`
`47`	`46`	`mailPreview.IsRead = true;`
	`47`	`+ await this.MailboxSessionService.SetMailReadMark(mailPreview.Id, true);`
`48`	`48`	`}`
`49`	`49`
`50`	`50`	`protected async Task DeleteCurrentMail()`
Original file line number	Diff line number	Diff line change
`@@ -5,35 +5,20 @@`
`5`	`5`
`6`	`6`	`namespace Lyralabs.TempMailServer.Web.Services`
`7`	`7`	`{`
`8`		`- public class MailboxSessionService : IRecipient<MailReceivedMessage>, IDisposable`
	`8`	`+ public class MailboxSessionService(`
	`9`	`+ UserState userState,`
	`10`	`+ ILocalStorageService localStorage,`
	`11`	`+ AsymmetricCryptoService cryptoService,`
	`12`	`+ MailboxService mailboxService,`
	`13`	`+ MailRepository mailRepository,`
	`14`	`+ IMessenger messenger,`
	`15`	`+ ILogger<MailboxSessionService> logger) : IRecipient<MailReceivedMessage>, IDisposable`
`9`	`16`	`{`
`10`	`17`	`public event EventHandler MailReceived;`
`11`		`-`
`12`		`- private readonly UserState userState;`
`13`		`- private readonly ILocalStorageService localStorage;`
`14`		`- private readonly AsymmetricCryptoService cryptoService;`
`15`		`- private readonly MailboxService mailboxService;`
`16`		`- private readonly IMessenger messenger;`
`17`		`- private readonly ILogger<MailboxSessionService> logger;`
	`18`	`+ public event EventHandler MailRead;`
`18`	`19`
`19`	`20`	`public List<MailPreviewDto> Mails { get; private set; } = [];`
`20`	`21`
`21`		`- public MailboxSessionService(`
`22`		`- UserState userState,`
`23`		`- ILocalStorageService LocalStorage,`
`24`		`- AsymmetricCryptoService cryptoService,`
`25`		`- MailboxService mailboxService,`
`26`		`- IMessenger messenger,`
`27`		`- ILogger<MailboxSessionService> logger)`
`28`		`- {`
`29`		`- this.userState = userState;`
`30`		`- this.localStorage = LocalStorage;`
`31`		`- this.cryptoService = cryptoService;`
`32`		`- this.mailboxService = mailboxService;`
`33`		`- this.messenger = messenger;`
`34`		`- this.logger = logger;`
`35`		`- }`
`36`		`-`
`37`	`22`	`public void TestEmail()`
`38`	`23`	`{`
`39`	`24`	`try`
`@@ -42,7 +27,7 @@ public void TestEmail()`
`42`	`27`	`client.Timeout = 1000;`
`43`	`28`
`44`	`29`	`var from = new MailAddress("steve@contoso.com", "Steve Ballmer");`
`45`		`- var to = new MailAddress(this.userState.CurrentMailbox, "Steve Jobs");`
	`30`	`+ var to = new MailAddress(userState.CurrentMailbox, "Steve Jobs");`
`46`	`31`	`var msg = new MailMessage(from, to);`
`47`	`32`	`msg.Subject = "Test Mail";`
`48`	`33`	`msg.Body = $"Test Mail issued at {DateTime.UtcNow} (UTC)\r\n{Guid.NewGuid()}";`
`@@ -51,74 +36,80 @@ public void TestEmail()`
`51`	`36`	`}`
`52`	`37`	`catch (Exception ex)`
`53`	`38`	`{`
`54`		`- this.logger.LogError(ex, "failed to send test-email");`
	`39`	`+ logger.LogError(ex, "failed to send test-email");`
`55`	`40`	`}`
`56`	`41`	`}`
`57`	`42`
`58`	`43`	`public async Task<UserSecret> GetOrCreateUserSecret()`
`59`	`44`	`{`
`60`		`- if (await this.localStorage.ContainKeyAsync("secret") == true)`
	`45`	`+ if (await localStorage.ContainKeyAsync("secret") == true)`
`61`	`46`	`{`
`62`		`- var secretFromStorage = await this.localStorage.GetItemAsync<UserSecret>("secret");`
	`47`	`+ var secretFromStorage = await localStorage.GetItemAsync<UserSecret>("secret");`
`63`	`48`
`64`	`49`	`if (secretFromStorage.PrivateKey != null && secretFromStorage.PublicKey != null && secretFromStorage.Password != null)`
`65`	`50`	`{`
`66`	`51`	`return secretFromStorage;`
`67`	`52`	`}`
`68`	`53`	`}`
`69`	`54`
`70`		`- var secret = this.cryptoService.GenerateUserSecret();`
	`55`	`+ var secret = cryptoService.GenerateUserSecret();`
`71`	`56`
`72`		`- await this.localStorage.SetItemAsync("secret", secret);`
	`57`	`+ await localStorage.SetItemAsync("secret", secret);`
`73`	`58`
`74`	`59`	`return secret;`
`75`	`60`	`}`
`76`	`61`
`77`	`62`	`public async Task Refresh()`
`78`	`63`	`{`
`79`		`- this.Mails = await this.mailboxService.GetDecryptedMailsAsync(this.userState.CurrentMailbox, this.userState.Secret.Value.PrivateKey);`
	`64`	`+ this.Mails = await mailboxService.GetDecryptedMailsAsync(userState.CurrentMailbox, userState.Secret.Value.PrivateKey);`
`80`	`65`	`this.MailReceived?.Invoke(this, EventArgs.Empty);`
`81`	`66`	`}`
`82`	`67`
`83`	`68`	`public void Receive(MailReceivedMessage message)`
`84`	`69`	`{`
`85`		`- this.Mails.Insert(0, this.mailboxService.ConvertToPreview(message.Mail));`
	`70`	`+ this.Mails.Insert(0, mailboxService.ConvertToPreview(message.Mail));`
`86`	`71`	`this.MailReceived?.Invoke(this, EventArgs.Empty);`
`87`	`72`	`}`
`88`	`73`
`89`	`74`	`public async Task DeleteMail(int mailid)`
`90`	`75`	`{`
`91`		`- await this.mailboxService.DeleteMail(mailid);`
	`76`	`+ await mailboxService.DeleteMail(mailid);`
`92`	`77`	`this.Mails.Remove(this.Mails.Single(m => m.Id == mailid));`
`93`	`78`	`}`
`94`	`79`
`95`	`80`	`public async Task GetMailbox(bool forceNew = false)`
`96`	`81`	`{`
`97`		`- var userSecret = this.userState.Secret.Value;`
	`82`	`+ var userSecret = userState.Secret.Value;`
`98`	`83`
`99`	`84`	`if (forceNew == true)`
`100`	`85`	`{`
`101`		`- this.userState.CurrentMailbox = await this.mailboxService.GenerateNewMailbox(userSecret.PublicKey, userSecret.Password);`
	`86`	`+ userState.CurrentMailbox = await mailboxService.GenerateNewMailbox(userSecret.PublicKey, userSecret.Password);`
`102`	`87`	`}`
`103`	`88`	`else`
`104`	`89`	`{`
`105`		`- this.userState.CurrentMailbox = await this.mailboxService.GetOrCreateMailboxAsync(userSecret.PrivateKey, userSecret.Password);`
	`90`	`+ userState.CurrentMailbox = await mailboxService.GetOrCreateMailboxAsync(userSecret.PrivateKey, userSecret.Password);`
`106`	`91`	`}`
`107`	`92`
`108`		`- this.messenger.Register(this, this.userState.CurrentMailbox);`
	`93`	`+ messenger.Register(this, userState.CurrentMailbox);`
`109`	`94`
`110`	`95`	`await this.Refresh();`
`111`	`96`	`}`
`112`	`97`
`113`	`98`	`internal async Task<MailModel> GetMailByIdAsync(int mailId)`
`114`	`99`	`{`
`115`		`- var mail = await this.mailboxService.GetDecryptedMailById(this.userState.CurrentMailbox, mailId, this.userState.Secret.Value.PrivateKey);`
	`100`	`+ var mail = await mailboxService.GetDecryptedMailById(userState.CurrentMailbox, mailId, userState.Secret.Value.PrivateKey);`
`116`	`101`	`return mail;`
`117`	`102`	`}`
`118`	`103`
	`104`	`+ public async Task SetMailReadMark(int mailId, bool isRead)`
	`105`	`+ {`
	`106`	`+ await mailRepository.SetReadMark(mailId, isRead);`
	`107`	`+ this.MailRead?.Invoke(this, EventArgs.Empty);`
	`108`	`+ }`
	`109`	`+`
`119`	`110`	`public void Dispose()`
`120`	`111`	`{`
`121`		`- this.messenger.UnregisterAll(this);`
	`112`	`+ messenger.UnregisterAll(this);`
`122`	`113`	`this.Mails.Clear();`
`123`	`114`	`}`
`124`	`115`	`}`
Original file line number	Diff line number	Diff line change
`@@ -3,7 +3,7 @@`
`3`	`3`
`4`	`4`	`namespace Lyralabs.TempMailServer.Web.Shared`
`5`	`5`	`{`
`6`		`- partial class SideNavigationMenu`
	`6`	`+ partial class SideNavigationMenu : IDisposable`
`7`	`7`	`{`
`8`	`8`	`[Inject]`
`9`	`9`	`protected IJSRuntime JsRuntime { get; set; }`
`@@ -19,17 +19,19 @@ partial class SideNavigationMenu`
`19`	`19`
`20`	`20`	`public bool IsMailboxActive { get; private set; }`
`21`	`21`
	`22`	`+ public int UnreadCount { get; private set; }`
	`23`	`+`
`22`	`24`	`protected override void OnParametersSet()`
`23`	`25`	`{`
`24`	`26`	`this.CheckMailboxUrl();`
`25`	`27`	`}`
`26`	`28`
`27`		`- protected override async Task OnAfterRenderAsync(bool firstRender)`
	`29`	`+ protected override async Task OnInitializedAsync()`
`28`	`30`	`{`
`29`		`- if (firstRender == false)`
`30`		`- {`
`31`		`- return;`
`32`		`- }`
	`31`	`+ await base.OnInitializedAsync();`
	`32`	`+`
	`33`	`+ this.MailboxSessionService.MailReceived += this.MailboxSessionService_MailReceived;`
	`34`	`+ this.MailboxSessionService.MailRead += this.MailboxSessionService_MailRead;`
`33`	`35`
`34`	`36`	`if (this.UserState.Secret is null)`
`35`	`37`	`{`
`@@ -44,11 +46,20 @@ protected override async Task OnAfterRenderAsync(bool firstRender)`
`44`	`46`	`{`
`45`	`47`	`await this.Refresh();`
`46`	`48`	`}`
	`49`	`+`
	`50`	`+ this.NavigationManager.LocationChanged += this.NavigationManager_LocationChanged;`
`47`	`51`	`}`
`48`	`52`
`49`		`- protected override void OnInitialized()`
	`53`	`+ private void MailboxSessionService_MailRead(object sender, EventArgs e)`
`50`	`54`	`{`
`51`		`- this.NavigationManager.LocationChanged += this.NavigationManager_LocationChanged;`
	`55`	`+ this.UnreadCount = this.MailboxSessionService.Mails.Count(mail => mail.IsRead == false);`
	`56`	`+ this.InvokeAsync(this.StateHasChanged);`
	`57`	`+ }`
	`58`	`+`
	`59`	`+ private void MailboxSessionService_MailReceived(object sender, EventArgs e)`
	`60`	`+ {`
	`61`	`+ this.UnreadCount = this.MailboxSessionService.Mails.Count(mail => mail.IsRead == false);`
	`62`	`+ _ = this.InvokeAsync(this.StateHasChanged);`
`52`	`63`	`}`
`53`	`64`
`54`	`65`	`private void NavigationManager_LocationChanged(object sender, LocationChangedEventArgs e)`
`@@ -62,13 +73,12 @@ private void CheckMailboxUrl()`
`62`	`73`	`this.IsMailboxActive = Uri.TryCreate(this.NavigationManager.Uri, UriKind.Absolute, out var uri) == true`
`63`	`74`	`&& uri.LocalPath.Equals("/inbox", StringComparison.OrdinalIgnoreCase) == true;`
`64`	`75`
`65`		`- this.StateHasChanged();`
	`76`	`+ _ = this.InvokeAsync(this.StateHasChanged);`
`66`	`77`	`}`
`67`	`78`
`68`	`79`	`protected async Task Refresh()`
`69`	`80`	`{`
`70`	`81`	`await this.MailboxSessionService.Refresh();`
`71`		`- this.StateHasChanged();`
`72`	`82`	`}`
`73`	`83`
`74`	`84`	`protected void TestEmail()`
`@@ -78,7 +88,18 @@ protected void TestEmail()`
`78`	`88`
`79`	`89`	`protected async Task NewAddress()`
`80`	`90`	`{`
`81`		`- await this.MailboxSessionService.GetMailbox(forceNew: true);`
	`91`	`+ var result = await this.JsRuntime.InvokeAsync<bool?>("confirm", "Are you sure you want to create a new mailbox? This will delete all your current emails.");`
	`92`	`+`
	`93`	`+ if (result == true)`
	`94`	`+ {`
	`95`	`+ await this.MailboxSessionService.GetMailbox(forceNew: true);`
	`96`	`+ }`
	`97`	`+ }`
	`98`	`+`
	`99`	`+ public void Dispose()`
	`100`	`+ {`
	`101`	`+ this.MailboxSessionService.MailReceived -= this.MailboxSessionService_MailReceived;`
	`102`	`+ this.MailboxSessionService.MailRead -= this.MailboxSessionService_MailRead;`
`82`	`103`	`}`
`83`	`104`	`}`
`84`	`105`	`}`