identity: set default mfa method to email for new users

Notesnook.API/Accessors/SyncItemsRepositoryAccessor.cs

@@ -42,7 +42,6 @@ namespace Notesnook.API.Accessors
         public SyncItemsRepository Colors { get; }
         public SyncItemsRepository Vaults { get; }
         public SyncItemsRepository Tags { get; }
-        public SyncItemsRepository InboxItemsHistory { get; }
         public Repository<UserSettings> UsersSettings { get; }
         public Repository<Monograph> Monographs { get; }
         public Repository<InboxApiKey> InboxApiKey { get; }
@@ -76,8 +75,6 @@ namespace Notesnook.API.Accessors
         IMongoCollection<SyncItem> vaults,
         [FromKeyedServices(Collections.TagsKey)]
         IMongoCollection<SyncItem> tags,
-        [FromKeyedServices(Collections.InboxItemsHistoryKey)]
-        IMongoCollection<SyncItem> inboxItemsHistory,
 
         Repository<UserSettings> usersSettings,
         Repository<Monograph> monographs,
@@ -105,7 +102,6 @@ namespace Notesnook.API.Accessors
             Colors = new SyncItemsRepository(dbContext, colors, logger);
             Vaults = new SyncItemsRepository(dbContext, vaults, logger);
             Tags = new SyncItemsRepository(dbContext, tags, logger);
-            InboxItemsHistory = new SyncItemsRepository(dbContext, inboxItemsHistory, logger);
         }
     }
 }

Notesnook.API/Constants.cs

@@ -18,6 +18,5 @@ namespace Notesnook.API
         public const string InboxApiKeysKey = "inbox_api_keys";
         public const string SyncDevicesKey = "sync_devices";
         public const string DeviceIdsChunksKey = "device_ids_chunks";
-        public const string InboxItemsHistoryKey = "inbox_items_history";
     }
 }

Notesnook.API/Controllers/InboxController.cs

@@ -18,7 +18,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 using System;
-using System.Collections.Generic;
 using System.Security.Claims;
 using System.Text.Json;
 using System.Threading.Tasks;
@@ -73,9 +72,9 @@ namespace Notesnook.API.Controllers
                 {
                     return BadRequest(new { error = "Api key name is required." });
                 }
-                if (request.ExpiryDate == null)
+                if (request.ExpiryDate <= -1)
                 {
-                    return BadRequest(new { error = "Expiry date is required." });
+                    return BadRequest(new { error = "Valid expiry date is required." });
                 }
 
                 var count = await inboxApiKeysRepository.CountAsync(t => t.UserId == userId);
@@ -134,7 +133,7 @@ namespace Notesnook.API.Controllers
                 var userSetting = await userSettingsRepository.FindOneAsync(u => u.UserId == userId);
                 if (string.IsNullOrWhiteSpace(userSetting?.InboxKeys?.Public))
                 {
-                    return NotFound(new { error = "Inbox public key is not configured." });
+                    return BadRequest(new { error = "Inbox public key is not configured." });
                 }
                 return Ok(new { key = userSetting.InboxKeys.Public });
             }

Notesnook.API/Controllers/S3Controller.cs

@@ -183,8 +183,8 @@ namespace Notesnook.API.Controllers
             try
             {
                 var userId = this.User.GetUserId();
-                var size = await s3Service.GetObjectSizeAsync(userId, name); Response.Headers.ContentLength = size;
+                var size = await s3Service.GetObjectSizeAsync(userId, name);
-                Response.Headers["X-Object-Size"] = size.ToString();
+                HttpContext.Response.Headers.ContentLength = size;
                 return Ok();
             }
             catch (Exception ex)

Notesnook.API/Controllers/UsersController.cs

@@ -93,39 +93,38 @@ namespace Notesnook.API.Controllers
         [HttpPatch("password/{type}")]
         public async Task<IActionResult> ChangePassword([FromRoute] string type, [FromBody] ChangePasswordForm form)
         {
-            return BadRequest(new { error = "Password change is currently disabled." });
+            var userId = User.GetUserId();
-            // var userId = User.GetUserId();
+            var clientId = User.FindFirstValue("client_id");
-            // var clientId = User.FindFirstValue("client_id");
+            var jti = User.FindFirstValue("jti");
-            // var jti = User.FindFirstValue("jti");
+            var isPasswordReset = type == "reset";
-            // var isPasswordReset = type == "reset";
+            try
-            // try
+            {
-            // {
+                var result = isPasswordReset ? await serviceAccessor.UserAccountService.ResetPasswordAsync(userId, form.NewPassword) : await serviceAccessor.UserAccountService.ChangePasswordAsync(userId, form.OldPassword, form.NewPassword);
-            //     var result = isPasswordReset ? await serviceAccessor.UserAccountService.ResetPasswordAsync(userId, form.NewPassword) : await serviceAccessor.UserAccountService.ChangePasswordAsync(userId, form.OldPassword, form.NewPassword);
+                if (!result)
-            //     if (!result)
+                    return BadRequest("Failed to change password.");
-            //         return BadRequest("Failed to change password.");
 
-            //     await UserService.SetUserKeysAsync(userId, form.UserKeys);
+                await UserService.SetUserKeysAsync(userId, form.UserKeys);
 
-            //     await serviceAccessor.UserAccountService.ClearSessionsAsync(userId, clientId, all: false, jti, null);
+                await serviceAccessor.UserAccountService.ClearSessionsAsync(userId, clientId, all: false, jti, null);
 
-            //     await WampServers.MessengerServer.PublishMessageAsync(MessengerServerTopics.SendSSETopic, new SendSSEMessage
+                await WampServers.MessengerServer.PublishMessageAsync(MessengerServerTopics.SendSSETopic, new SendSSEMessage
-            //     {
+                {
-            //         UserId = userId,
+                    UserId = userId,
-            //         OriginTokenId = jti,
+                    OriginTokenId = jti,
-            //         Message = new Message
+                    Message = new Message
-            //         {
+                    {
-            //             Type = "logout",
+                        Type = "logout",
-            //             Data = JsonSerializer.Serialize(new { reason = "Password changed." })
+                        Data = JsonSerializer.Serialize(new { reason = "Password changed." })
-            //         }
+                    }
-            //     });
+                });
 
-            //     return Ok();
+                return Ok();
-            // }
+            }
-            // catch (Exception ex)
+            catch (Exception ex)
-            // {
+            {
-            //     logger.LogError(ex, "Failed to change password");
+                logger.LogError(ex, "Failed to change password");
-            //     return BadRequest(new { error = ex.Message });
+                return BadRequest(new { error = ex.Message });
-            // }
+            }
         }
 
         [HttpPost("reset")]

Notesnook.API/Hubs/SyncV2Hub.cs

@@ -57,9 +57,21 @@ namespace Notesnook.API.Hubs
         private ISyncItemsRepositoryAccessor Repositories { get; }
         private SyncDeviceService SyncDeviceService { get; }
         private readonly IUnitOfWork unit;
+        private static readonly string[] CollectionKeys = [
+            "settingitem",
+            "attachment",
+            "note",
+            "notebook",
+            "content",
+            "shortcut",
+            "reminder",
+            "color",
+            "tag",
+            "vault",
+            "relation", // relations must sync at the end to prevent invalid state
+        ];
         private readonly FrozenDictionary<string, Action<IEnumerable<SyncItem>, string, long>> UpsertActionsMap;
-        private readonly CollectionDef[] BaseCollectionDefs;
+        private readonly Func<string, IEnumerable<string>, bool, int, Task<IAsyncCursor<SyncItem>>>[] Collections;
-        private readonly CollectionDef[] V4CollectionDefs;
         ILogger<SyncV2Hub> Logger { get; }
 
         public SyncV2Hub(ISyncItemsRepositoryAccessor syncItemsRepositoryAccessor, IUnitOfWork unitOfWork, SyncDeviceService syncDeviceService, ILogger<SyncV2Hub> logger)
@@ -69,32 +81,18 @@ namespace Notesnook.API.Hubs
             unit = unitOfWork;
             SyncDeviceService = syncDeviceService;
 
-            BaseCollectionDefs = [
+            Collections = [
-                new("settingitem", Repositories.Settings.FindItemsById),
+                Repositories.Settings.FindItemsById,
-                new("attachment", Repositories.Attachments.FindItemsById),
+                Repositories.Attachments.FindItemsById,
-                new("note", Repositories.Notes.FindItemsById),
+                Repositories.Notes.FindItemsById,
-                new("notebook", Repositories.Notebooks.FindItemsById),
+                Repositories.Notebooks.FindItemsById,
-                new("content", Repositories.Contents.FindItemsById),
+                Repositories.Contents.FindItemsById,
-                new("shortcut", Repositories.Shortcuts.FindItemsById),
+                Repositories.Shortcuts.FindItemsById,
-                new("reminder", Repositories.Reminders.FindItemsById),
+                Repositories.Reminders.FindItemsById,
-                new("color", Repositories.Colors.FindItemsById),
+                Repositories.Colors.FindItemsById,
-                new("tag", Repositories.Tags.FindItemsById),
+                Repositories.Tags.FindItemsById,
-                new("vault", Repositories.Vaults.FindItemsById),
+                Repositories.Vaults.FindItemsById,
-                new("relation", Repositories.Relations.FindItemsById), // relations must sync at the end to prevent invalid state
+                Repositories.Relations.FindItemsById,
-            ];
-            V4CollectionDefs = [
-                new("settingitem", Repositories.Settings.FindItemsById),
-                new("attachment", Repositories.Attachments.FindItemsById),
-                new("note", Repositories.Notes.FindItemsById),
-                new("notebook", Repositories.Notebooks.FindItemsById),
-                new("content", Repositories.Contents.FindItemsById),
-                new("shortcut", Repositories.Shortcuts.FindItemsById),
-                new("reminder", Repositories.Reminders.FindItemsById),
-                new("color", Repositories.Colors.FindItemsById),
-                new("tag", Repositories.Tags.FindItemsById),
-                new("vault", Repositories.Vaults.FindItemsById),
-                new("inboxitemhistory", Repositories.InboxItemsHistory.FindItemsById),
-                new("relation", Repositories.Relations.FindItemsById), // relations must sync at the end to prevent invalid state
             ];
             UpsertActionsMap = new Dictionary<string, Action<IEnumerable<SyncItem>, string, long>> {
                 { "settingitem", Repositories.Settings.UpsertMany },
@@ -108,7 +106,6 @@ namespace Notesnook.API.Hubs
                 { "color", Repositories.Colors.UpsertMany },
                 { "vault", Repositories.Vaults.UpsertMany },
                 { "tag", Repositories.Tags.UpsertMany },
-                { "inboxitemhistory", Repositories.InboxItemsHistory.UpsertMany },
             }.ToFrozenDictionary();
         }
 
@@ -125,19 +122,6 @@ namespace Notesnook.API.Hubs
             await base.OnConnectedAsync();
         }
 
-        public override async Task OnDisconnectedAsync(Exception? exception)
-        {
-            if (exception != null)
-            {
-                Logger.LogWarning(exception, "Connection {ConnectionId} disconnected with error (server-side drop)", Context.ConnectionId);
-            }
-            else
-            {
-                Logger.LogInformation("Connection {ConnectionId} disconnected cleanly (client-initiated)", Context.ConnectionId);
-            }
-            await base.OnDisconnectedAsync(exception);
-        }
-
 
         public async Task<int> PushItems(string deviceId, SyncTransferItemV2 pushItem)
         {
@@ -184,17 +168,17 @@ namespace Notesnook.API.Hubs
             return true;
         }
 
-        private async IAsyncEnumerable<SyncTransferItemV2> PrepareChunks(string userId, HashSet<ItemKey> ids, int size, bool resetSync, long maxBytes, CollectionDef[] collectionDefs)
+        private async IAsyncEnumerable<SyncTransferItemV2> PrepareChunks(string userId, HashSet<ItemKey> ids, int size, bool resetSync, long maxBytes)
         {
             var itemsProcessed = 0;
-            foreach (var def in collectionDefs)
+            for (int i = 0; i < Collections.Length; i++)
             {
-                var type = def.Key;
+                var type = CollectionKeys[i];
 
                 var filteredIds = ids.Where((id) => id.Type == type).Select((id) => id.ItemId).ToArray();
                 if (!resetSync && filteredIds.Length == 0) continue;
 
-                using var cursor = await def.FindItems(userId, filteredIds, resetSync, size);
+                using var cursor = await Collections[i](userId, filteredIds, resetSync, size);
 
                 var chunk = new List<SyncItem>();
                 long totalBytes = 0;
@@ -236,25 +220,20 @@ namespace Notesnook.API.Hubs
 
         public async Task<SyncV2Metadata> RequestFetch(string deviceId)
         {
-            return await HandleRequestFetch(deviceId, false, false, BaseCollectionDefs);
+            return await HandleRequestFetch(deviceId, false, false);
         }
 
         public async Task<SyncV2Metadata> RequestFetchV2(string deviceId)
         {
-            return await HandleRequestFetch(deviceId, true, false, BaseCollectionDefs);
+            return await HandleRequestFetch(deviceId, true, false);
         }
 
         public async Task<SyncV2Metadata> RequestFetchV3(string deviceId)
         {
-            return await HandleRequestFetch(deviceId, true, true, BaseCollectionDefs);
+            return await HandleRequestFetch(deviceId, true, true);
         }
 
-        public async Task<SyncV2Metadata> RequestFetchV4(string deviceId)
+        private async Task<SyncV2Metadata> HandleRequestFetch(string deviceId, bool includeMonographs, bool includeInboxItems)
-        {
-            return await HandleRequestFetch(deviceId, true, true, V4CollectionDefs);
-        }
-
-        private async Task<SyncV2Metadata> HandleRequestFetch(string deviceId, bool includeMonographs, bool includeInboxItems, CollectionDef[] collectionDefs)
         {
             var userId = Context.User?.FindFirstValue("sub") ?? throw new HubException("Please login to sync.");
 
@@ -278,8 +257,7 @@ namespace Notesnook.API.Hubs
                     ids,
                     size: 100,
                     resetSync: device.IsSyncReset,
-                    maxBytes: 3 * 1024 * 1024,
+                    maxBytes: 3 * 1024 * 1024
-                    collectionDefs
                 );
 
                 await foreach (var chunk in chunks)
@@ -334,7 +312,7 @@ namespace Notesnook.API.Hubs
                     var unsyncedInboxItemIds = ids.Where(k => k.Type == "inbox_item").Select(k => k.ItemId);
                     var userInboxItems = device.IsSyncReset
                         ? await Repositories.InboxItems.FindAsync(m => m.UserId == userId)
-                        : await Repositories.InboxItems.FindAsync(m => m.UserId == userId && unsyncedInboxItemIds.Contains(m.ItemId));
+                        : await Repositories.InboxItems.FindAsync(m => m.UserId == userId && unsyncedInboxItemIds.Contains(m.ItemId ?? m.Id.ToString()));
                     if (userInboxItems.Any() && !await Clients.Caller.SendInboxItems(userInboxItems).WaitAsync(TimeSpan.FromMinutes(10)))
                     {
                         throw new HubException("Client rejected inbox items.");
@@ -353,11 +331,6 @@ namespace Notesnook.API.Hubs
                 SyncEventCounterSource.Log.RecordFetchDuration(stopwatch.ElapsedMilliseconds);
             }
         }
-
-        private record CollectionDef(
-            string Key,
-            Func<string, IEnumerable<string>, bool, int, Task<IAsyncCursor<SyncItem>>> FindItems
-        );
     }
 
     [MessagePack.MessagePackObject]

Notesnook.API/Interfaces/ISyncItemsRepositoryAccessor.cs

@@ -38,7 +38,6 @@ namespace Notesnook.API.Interfaces
         SyncItemsRepository Colors { get; }
         SyncItemsRepository Vaults { get; }
         SyncItemsRepository Tags { get; }
-        SyncItemsRepository InboxItemsHistory { get; }
         Repository<UserSettings> UsersSettings { get; }
         Repository<Monograph> Monographs { get; }
         Repository<InboxApiKey> InboxApiKey { get; }

Notesnook.API/Notesnook.API.csproj

@@ -9,7 +9,6 @@
   <ItemGroup>
     <PackageReference Include="AngleSharp" Version="1.3.0" />
     <PackageReference Include="AspNetCore.HealthChecks.Aws.S3" Version="9.0.0" />
-    <PackageReference Include="AspNetCore.HealthChecks.Redis" Version="9.0.0" />
     <PackageReference Include="AWSSDK.Core" Version="3.7.304.31" />
     <PackageReference Include="DotNetEnv" Version="2.3.0" />
     <PackageReference Include="IdentityModel.AspNetCore.OAuth2Introspection" Version="6.2.0" />

Notesnook.API/Services/UserService.cs

@@ -174,19 +174,18 @@ namespace Notesnook.API.Services
                 else
                 {
                     userSettings.InboxKeys = keys.InboxKeys;
+                    var defaultInboxKey = new InboxApiKey
+                    {
+                        UserId = userId,
+                        Name = "Default",
+                        DateCreated = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds(),
+                        ExpiryDate = DateTimeOffset.UtcNow.AddYears(1).ToUnixTimeMilliseconds(),
+                        LastUsedAt = 0
+                    };
+                    await Repositories.InboxApiKey.InsertAsync(defaultInboxKey);
                 }
 
                 await Repositories.InboxItems.DeleteManyAsync(t => t.UserId == userId);
-                await WampServers.MessengerServer.PublishMessageAsync(MessengerServerTopics.SendSSETopic, new SendSSEMessage
-                {
-                    OriginTokenId = null,
-                    UserId = userId,
-                    Message = new Message
-                    {
-                        Type = "inboxUpdated",
-                        Data = JsonSerializer.Serialize(new { reason = "Inbox PGP keys added, updated, or removed." })
-                    }
-                });
             }
 
             await Repositories.UsersSettings.UpdateAsync(userSettings.Id, userSettings);
@@ -209,7 +208,6 @@ namespace Notesnook.API.Services
             Repositories.Colors.DeleteByUserId(userId);
             Repositories.Tags.DeleteByUserId(userId);
             Repositories.Vaults.DeleteByUserId(userId);
-            Repositories.InboxItemsHistory.DeleteByUserId(userId);
             Repositories.UsersSettings.Delete((u) => u.UserId == userId);
             Repositories.Monographs.DeleteMany((m) => m.UserId == userId);
             Repositories.InboxApiKey.DeleteMany((t) => t.UserId == userId);
@@ -271,7 +269,6 @@ namespace Notesnook.API.Services
             Repositories.Colors.DeleteByUserId(userId);
             Repositories.Tags.DeleteByUserId(userId);
             Repositories.Vaults.DeleteByUserId(userId);
-            Repositories.InboxItemsHistory.DeleteByUserId(userId);
             Repositories.Monographs.DeleteMany((m) => m.UserId == userId);
             Repositories.InboxApiKey.DeleteMany((t) => t.UserId == userId);
             if (!await unit.Commit()) return false;

Notesnook.API/Startup.cs

@@ -25,7 +25,6 @@ using System.Text;
 using System.Text.Encodings.Web;
 using System.Threading.Tasks;
 using Amazon.Runtime;
-using StackExchange.Redis;
 using IdentityModel.AspNetCore.OAuth2Introspection;
 using Microsoft.AspNetCore.Authentication;
 using Microsoft.AspNetCore.Authentication.JwtBearer;
@@ -197,8 +196,7 @@ namespace Notesnook.API
                     .AddMongoCollection(Collections.ColorsKey)
                     .AddMongoCollection(Collections.VaultsKey)
                     .AddMongoCollection(Collections.InboxItemsKey)
-                    .AddMongoCollection(Collections.InboxApiKeysKey)
+                    .AddMongoCollection(Collections.InboxApiKeysKey);
-                    .AddMongoCollection(Collections.InboxItemsHistoryKey);
 
             services.AddScoped<ISyncItemsRepositoryAccessor, SyncItemsRepositoryAccessor>();
             services.AddScoped<SyncDeviceService>();
@@ -221,20 +219,7 @@ namespace Notesnook.API
             }).AddMessagePackProtocol().AddJsonProtocol();
 
             if (!string.IsNullOrEmpty(Constants.SIGNALR_REDIS_CONNECTION_STRING))
-            {
+                signalR.AddStackExchangeRedis(Constants.SIGNALR_REDIS_CONNECTION_STRING);
-                services.AddHealthChecks()
-                        .AddRedis(Constants.SIGNALR_REDIS_CONNECTION_STRING, tags: ["ready"]);
-                signalR.AddStackExchangeRedis(options =>
-                {
-                    options.Configuration = ConfigurationOptions.Parse(Constants.SIGNALR_REDIS_CONNECTION_STRING);
-                    options.Configuration.AbortOnConnectFail = false;
-                    options.Configuration.ConnectRetry = 5;
-                    options.Configuration.ReconnectRetryPolicy = new ExponentialRetry(5000, 30000);
-                    options.Configuration.KeepAlive = 60;
-                    options.Configuration.ConnectTimeout = 5000;
-                    options.Configuration.SyncTimeout = 5000;
-                });
-            }
 
             services.AddResponseCompression(options =>
             {

Notesnook.Inbox.API/src/index.ts

@@ -17,7 +17,7 @@ const RawInboxItemSchema = z.object({
   notebookIds: z.array(z.string()).optional(),
   tagIds: z.array(z.string()).optional(),
   type: z.enum(["note"]),
-  source: z.string().min(1, "Source is required"),
+  source: z.string(),
   version: z.literal(1),
   content: z
     .object({
@@ -56,9 +56,7 @@ async function encrypt(
   };
 }
 
-async function getInboxPublicEncryptionKey(
+async function getInboxPublicEncryptionKey(apiKey: string) {
-  apiKey: string,
-): Promise<{ status: "unauthorized" } | { status: "ok"; key: string | null }> {
   const response = await fetch(
     `${NOTESNOOK_API_SERVER_URL}/inbox/public-encryption-key`,
     {
@@ -67,9 +65,6 @@ async function getInboxPublicEncryptionKey(
       },
     },
   );
-  if (response.status === 401) {
-    return { status: "unauthorized" };
-  }
   if (!response.ok) {
     throw new Error(
       `failed to fetch inbox public encryption key: ${await response.text()}`,
@@ -77,7 +72,7 @@ async function getInboxPublicEncryptionKey(
   }
 
   const data = (await response.json()) as unknown as any;
-  return { status: "ok", key: (data?.key as string) || null };
+  return (data?.key as string) || null;
 }
 
 async function postEncryptedInboxItem(
@@ -115,14 +110,10 @@ app.post("/", async (req, res) => {
       return res.status(401).json({ error: "unauthorized" });
     }
 
-    const encryptionKeyResult = await getInboxPublicEncryptionKey(apiKey);
+    const inboxPublicKey = await getInboxPublicEncryptionKey(apiKey);
-    if (encryptionKeyResult.status === "unauthorized") {
+    if (!inboxPublicKey) {
-      return res.status(401).json({ error: "unauthorized" });
+      return res.status(403).json({ error: "inbox public key not found" });
     }
-    if (!encryptionKeyResult.key) {
-      return res.status(404).json({ error: "inbox public key not found" });
-    }
-    const inboxPublicKey = encryptionKeyResult.key;
     console.log("[info] fetched inbox public key");
 
     const validationResult = RawInboxItemSchema.safeParse(req.body);

Streetwriters.Common/Extensions/ServiceCollectionServiceExtensions.cs

@@ -52,8 +52,7 @@ namespace Streetwriters.Common.Extensions
                         b.WithOrigins(Constants.NOTESNOOK_CORS_ORIGINS);
 
                     b.AllowAnyMethod()
-                    .AllowAnyHeader()
+                    .AllowAnyHeader();
-                    .WithExposedHeaders(["X-Object-Size", "Content-Length"]);
                 });
             });
             return services;

Streetwriters.Common/Interfaces/IEmailSender.cs

@@ -1,5 +1,4 @@
 using System.Collections.Generic;
-using System.Net.Mail;
 using System.Threading.Tasks;
 using MimeKit;
 using MimeKit.Cryptography;
@@ -12,7 +11,7 @@ namespace Streetwriters.Common.Interfaces
         Task SendEmailAsync(
             string email,
             EmailTemplate template,
-            MailAddress from,
+            IClient client,
             GnuPGContext? gpgContext = null,
             Dictionary<string, byte[]>? attachments = null
         );

Streetwriters.Common/Models/GetCustomerResponse.cs

@@ -0,0 +1,21 @@
+namespace Streetwriters.Common.Models
+{
+    using System;
+    using System.Collections.Generic;
+
+    using System.Text.Json;
+    using System.Text.Json.Serialization;
+    using System.Globalization;
+
+    public partial class GetCustomerResponse : PaddleResponse
+    {
+        [JsonPropertyName("data")]
+        public PaddleCustomer? Customer { get; set; }
+    }
+
+    public class PaddleCustomer
+    {
+        [JsonPropertyName("email")]
+        public string? Email { get; set; }
+    }
+}

Streetwriters.Common/Models/GetSubscriptionResponse.cs

@@ -0,0 +1,214 @@
+namespace Streetwriters.Common.Models
+{
+    using System;
+    using System.Collections.Generic;
+
+    using System.Text.Json;
+    using System.Text.Json.Serialization;
+    using System.Globalization;
+
+    public partial class GetSubscriptionResponse : PaddleResponse
+    {
+        [JsonPropertyName("data")]
+        public Data? Data { get; set; }
+    }
+
+    public partial class Data
+    {
+        // [JsonPropertyName("id")]
+        // public string Id { get; set; }
+
+        // [JsonPropertyName("status")]
+        // public string Status { get; set; }
+
+        [JsonPropertyName("customer_id")]
+        public string? CustomerId { get; set; }
+
+        // [JsonPropertyName("address_id")]
+        // public string AddressId { get; set; }
+
+        // [JsonPropertyName("business_id")]
+        // public object BusinessId { get; set; }
+
+        // [JsonPropertyName("currency_code")]
+        // public string CurrencyCode { get; set; }
+
+        // [JsonPropertyName("created_at")]
+        // public DateTimeOffset CreatedAt { get; set; }
+
+        // [JsonPropertyName("updated_at")]
+        // public DateTimeOffset UpdatedAt { get; set; }
+
+        // [JsonPropertyName("started_at")]
+        // public DateTimeOffset StartedAt { get; set; }
+
+        [JsonPropertyName("first_billed_at")]
+        public DateTimeOffset? FirstBilledAt { get; set; }
+
+        // [JsonPropertyName("next_billed_at")]
+        // public DateTimeOffset NextBilledAt { get; set; }
+
+        // [JsonPropertyName("paused_at")]
+        // public object PausedAt { get; set; }
+
+        // [JsonPropertyName("canceled_at")]
+        // public object CanceledAt { get; set; }
+
+        // [JsonPropertyName("collection_mode")]
+        // public string CollectionMode { get; set; }
+
+        // [JsonPropertyName("billing_details")]
+        // public object BillingDetails { get; set; }
+
+        // [JsonPropertyName("current_billing_period")]
+        // public CurrentBillingPeriod CurrentBillingPeriod { get; set; }
+
+        [JsonPropertyName("billing_cycle")]
+        public BillingCycle? BillingCycle { get; set; }
+
+        // [JsonPropertyName("scheduled_change")]
+        // public object ScheduledChange { get; set; }
+
+        // [JsonPropertyName("items")]
+        // public Item[] Items { get; set; }
+
+        // [JsonPropertyName("custom_data")]
+        // public object CustomData { get; set; }
+
+        [JsonPropertyName("management_urls")]
+        public ManagementUrls? ManagementUrls { get; set; }
+
+        // [JsonPropertyName("discount")]
+        // public object Discount { get; set; }
+
+        // [JsonPropertyName("import_meta")]
+        // public object ImportMeta { get; set; }
+    }
+
+    public partial class BillingCycle
+    {
+        [JsonPropertyName("frequency")]
+        public long Frequency { get; set; }
+
+        [JsonPropertyName("interval")]
+        public string? Interval { get; set; }
+    }
+
+    // public partial class CurrentBillingPeriod
+    // {
+    //     [JsonPropertyName("starts_at")]
+    //     public DateTimeOffset StartsAt { get; set; }
+
+    //     [JsonPropertyName("ends_at")]
+    //     public DateTimeOffset EndsAt { get; set; }
+    // }
+
+    // public partial class Item
+    // {
+    //     [JsonPropertyName("status")]
+    //     public string Status { get; set; }
+
+    //     [JsonPropertyName("quantity")]
+    //     public long Quantity { get; set; }
+
+    //     [JsonPropertyName("recurring")]
+    //     public bool Recurring { get; set; }
+
+    //     [JsonPropertyName("created_at")]
+    //     public DateTimeOffset CreatedAt { get; set; }
+
+    //     [JsonPropertyName("updated_at")]
+    //     public DateTimeOffset UpdatedAt { get; set; }
+
+    //     [JsonPropertyName("previously_billed_at")]
+    //     public DateTimeOffset PreviouslyBilledAt { get; set; }
+
+    //     [JsonPropertyName("next_billed_at")]
+    //     public DateTimeOffset NextBilledAt { get; set; }
+
+    //     [JsonPropertyName("trial_dates")]
+    //     public object TrialDates { get; set; }
+
+    //     [JsonPropertyName("price")]
+    //     public Price Price { get; set; }
+    // }
+
+    // public partial class Price
+    // {
+    //     [JsonPropertyName("id")]
+    //     public string Id { get; set; }
+
+    //     [JsonPropertyName("product_id")]
+    //     public string ProductId { get; set; }
+
+    //     [JsonPropertyName("type")]
+    //     public string Type { get; set; }
+
+    //     [JsonPropertyName("description")]
+    //     public string Description { get; set; }
+
+    //     [JsonPropertyName("name")]
+    //     public string Name { get; set; }
+
+    //     [JsonPropertyName("tax_mode")]
+    //     public string TaxMode { get; set; }
+
+    //     [JsonPropertyName("billing_cycle")]
+    //     public BillingCycle BillingCycle { get; set; }
+
+    //     [JsonPropertyName("trial_period")]
+    //     public object TrialPeriod { get; set; }
+
+    //     [JsonPropertyName("unit_price")]
+    //     public UnitPrice UnitPrice { get; set; }
+
+    //     [JsonPropertyName("unit_price_overrides")]
+    //     public object[] UnitPriceOverrides { get; set; }
+
+    //     [JsonPropertyName("custom_data")]
+    //     public object CustomData { get; set; }
+
+    //     [JsonPropertyName("status")]
+    //     public string Status { get; set; }
+
+    //     [JsonPropertyName("quantity")]
+    //     public Quantity Quantity { get; set; }
+
+    //     [JsonPropertyName("import_meta")]
+    //     public object ImportMeta { get; set; }
+
+    //     [JsonPropertyName("created_at")]
+    //     public DateTimeOffset CreatedAt { get; set; }
+
+    //     [JsonPropertyName("updated_at")]
+    //     public DateTimeOffset UpdatedAt { get; set; }
+    // }
+
+    // public partial class Quantity
+    // {
+    //     [JsonPropertyName("minimum")]
+    //     public long Minimum { get; set; }
+
+    //     [JsonPropertyName("maximum")]
+    //     public long Maximum { get; set; }
+    // }
+
+    // public partial class UnitPrice
+    // {
+    //     [JsonPropertyName("amount")]
+    //     [JsonConverter(typeof(ParseStringConverter))]
+    //     public long Amount { get; set; }
+
+    //     [JsonPropertyName("currency_code")]
+    //     public string CurrencyCode { get; set; }
+    // }
+
+    public partial class ManagementUrls
+    {
+        [JsonPropertyName("update_payment_method")]
+        public Uri? UpdatePaymentMethod { get; set; }
+
+        [JsonPropertyName("cancel")]
+        public Uri? Cancel { get; set; }
+    }
+}

Streetwriters.Common/Models/GetTransactionInvoiceResponse.cs

@@ -0,0 +1,21 @@
+namespace Streetwriters.Common.Models
+{
+    using System;
+    using System.Collections.Generic;
+
+    using System.Text.Json;
+    using System.Text.Json.Serialization;
+    using System.Globalization;
+
+    public class GetTransactionInvoiceResponse : PaddleResponse
+    {
+        [JsonPropertyName("data")]
+        public Invoice? Invoice { get; set; }
+    }
+
+    public partial class Invoice
+    {
+        [JsonPropertyName("url")]
+        public string? Url { get; set; }
+    }
+}

Streetwriters.Common/Models/GetTransactionResponse.cs

@@ -0,0 +1,15 @@
+namespace Streetwriters.Common.Models
+{
+    using System;
+    using System.Collections.Generic;
+
+    using System.Text.Json;
+    using System.Text.Json.Serialization;
+    using System.Globalization;
+
+    public partial class GetTransactionResponse : PaddleResponse
+    {
+        [JsonPropertyName("data")]
+        public TransactionV2? Transaction { get; set; }
+    }
+}

Streetwriters.Common/Models/ListPaymentsResponse.cs

@@ -0,0 +1,41 @@
+using System;
+using System.Text.Json.Serialization;
+
+namespace Streetwriters.Common.Models
+{
+    public partial class ListPaymentsResponse
+    {
+        [JsonPropertyName("success")]
+        public bool Success { get; set; }
+
+        [JsonPropertyName("response")]
+        public Payment[]? Payments { get; set; }
+    }
+
+    public partial class Payment
+    {
+        [JsonPropertyName("id")]
+        public long Id { get; set; }
+
+        [JsonPropertyName("subscription_id")]
+        public long SubscriptionId { get; set; }
+
+        [JsonPropertyName("amount")]
+        public double Amount { get; set; }
+
+        [JsonPropertyName("currency")]
+        public string? Currency { get; set; }
+
+        [JsonPropertyName("payout_date")]
+        public string? PayoutDate { get; set; }
+
+        [JsonPropertyName("is_paid")]
+        public short IsPaid { get; set; }
+
+        [JsonPropertyName("is_one_off_charge")]
+        public bool IsOneOffCharge { get; set; }
+
+        [JsonPropertyName("receipt_url")]
+        public string? ReceiptUrl { get; set; }
+    }
+}

Streetwriters.Common/Models/ListTransactionsResponse.cs

@@ -0,0 +1,77 @@
+namespace Streetwriters.Common.Models
+{
+    using System;
+    using System.Text.Json.Serialization;
+
+    public partial class ListTransactionsResponse
+    {
+        [JsonPropertyName("success")]
+        public bool Success { get; set; }
+
+        [JsonPropertyName("response")]
+        public Transaction[]? Transactions { get; set; }
+    }
+
+    public partial class Transaction
+    {
+        [JsonPropertyName("order_id")]
+        public string? OrderId { get; set; }
+
+        [JsonPropertyName("checkout_id")]
+        public string? CheckoutId { get; set; }
+
+        [JsonPropertyName("amount")]
+        public string? Amount { get; set; }
+
+        [JsonPropertyName("currency")]
+        public string? Currency { get; set; }
+
+        [JsonPropertyName("status")]
+        public string? Status { get; set; }
+
+        [JsonPropertyName("created_at")]
+        public string? CreatedAt { get; set; }
+
+        [JsonPropertyName("passthrough")]
+        public object? Passthrough { get; set; }
+
+        [JsonPropertyName("product_id")]
+        public long ProductId { get; set; }
+
+        [JsonPropertyName("is_subscription")]
+        public bool IsSubscription { get; set; }
+
+        [JsonPropertyName("is_one_off")]
+        public bool IsOneOff { get; set; }
+
+        [JsonPropertyName("subscription")]
+        public PaddleSubscription? Subscription { get; set; }
+
+        [JsonPropertyName("user")]
+        public PaddleTransactionUser? User { get; set; }
+
+        [JsonPropertyName("receipt_url")]
+        public string? ReceiptUrl { get; set; }
+    }
+
+    public partial class PaddleSubscription
+    {
+        [JsonPropertyName("subscription_id")]
+        public long SubscriptionId { get; set; }
+
+        [JsonPropertyName("status")]
+        public string? Status { get; set; }
+    }
+
+    public partial class PaddleTransactionUser
+    {
+        [JsonPropertyName("user_id")]
+        public long UserId { get; set; }
+
+        [JsonPropertyName("email")]
+        public string? Email { get; set; }
+
+        [JsonPropertyName("marketing_consent")]
+        public bool MarketingConsent { get; set; }
+    }
+}

Streetwriters.Common/Models/ListTransactionsResponseV2.cs

@@ -0,0 +1,511 @@
+namespace Streetwriters.Common.Models
+{
+    using System;
+    using System.Collections.Generic;
+
+    using System.Text.Json;
+    using System.Text.Json.Serialization;
+    using System.Globalization;
+
+    public partial class ListTransactionsResponseV2 : PaddleResponse
+    {
+        [JsonPropertyName("data")]
+        public TransactionV2[]? Transactions { get; set; }
+    }
+
+    public partial class TransactionV2
+    {
+        [JsonPropertyName("id")]
+        public string? Id { get; set; }
+
+        [JsonPropertyName("status")]
+        public string? Status { get; set; }
+
+        [JsonPropertyName("customer_id")]
+        public string? CustomerId { get; set; }
+
+        // [JsonPropertyName("address_id")]
+        // public string AddressId { get; set; }
+
+        // [JsonPropertyName("business_id")]
+        // public object BusinessId { get; set; }
+
+        [JsonPropertyName("custom_data")]
+        public Dictionary<string, string>? CustomData { get; set; }
+
+        [JsonPropertyName("origin")]
+        public string? Origin { get; set; }
+
+        // [JsonPropertyName("collection_mode")]
+        // public string CollectionMode { get; set; }
+
+        // [JsonPropertyName("subscription_id")]
+        // public string SubscriptionId { get; set; }
+
+        // [JsonPropertyName("invoice_id")]
+        // public string InvoiceId { get; set; }
+
+        // [JsonPropertyName("invoice_number")]
+        // public string InvoiceNumber { get; set; }
+
+        [JsonPropertyName("billing_details")]
+        public BillingDetails? BillingDetails { get; set; }
+
+        [JsonPropertyName("billing_period")]
+        public BillingPeriod? BillingPeriod { get; set; }
+
+        // [JsonPropertyName("currency_code")]
+        // public string CurrencyCode { get; set; }
+
+        // [JsonPropertyName("discount_id")]
+        // public string DiscountId { get; set; }
+
+        [JsonPropertyName("created_at")]
+        public DateTimeOffset CreatedAt { get; set; }
+
+        // [JsonPropertyName("updated_at")]
+        // public DateTimeOffset UpdatedAt { get; set; }
+
+        [JsonPropertyName("billed_at")]
+        public DateTimeOffset? BilledAt { get; set; }
+
+        [JsonPropertyName("items")]
+        public Item[]? Items { get; set; }
+
+        [JsonPropertyName("details")]
+        public Details? Details { get; set; }
+
+        // [JsonPropertyName("payments")]
+        // public Payment[] Payments { get; set; }
+
+        // [JsonPropertyName("checkout")]
+        // public Checkout Checkout { get; set; }
+    }
+
+    public partial class BillingDetails
+    {
+        // [JsonPropertyName("enable_checkout")]
+        // public bool EnableCheckout { get; set; }
+
+        [JsonPropertyName("payment_terms")]
+        public PaymentTerms? PaymentTerms { get; set; }
+
+        // [JsonPropertyName("purchase_order_number")]
+        // public string PurchaseOrderNumber { get; set; }
+
+        // [JsonPropertyName("additional_information")]
+        // public object AdditionalInformation { get; set; }
+    }
+
+    public partial class PaymentTerms
+    {
+        [JsonPropertyName("interval")]
+        public string? Interval { get; set; }
+
+        [JsonPropertyName("frequency")]
+        public long Frequency { get; set; }
+    }
+
+    public partial class BillingPeriod
+    {
+        [JsonPropertyName("starts_at")]
+        public DateTimeOffset StartsAt { get; set; }
+
+        [JsonPropertyName("ends_at")]
+        public DateTimeOffset EndsAt { get; set; }
+    }
+
+    // public partial class Checkout
+    // {
+    //     [JsonPropertyName("url")]
+    //     public Uri Url { get; set; }
+    // }
+
+    public partial class Details
+    {
+        // [JsonPropertyName("tax_rates_used")]
+        // public TaxRatesUsed[] TaxRatesUsed { get; set; }
+
+        [JsonPropertyName("totals")]
+        public Totals? Totals { get; set; }
+
+        // [JsonPropertyName("adjusted_totals")]
+        // public AdjustedTotals AdjustedTotals { get; set; }
+
+        // [JsonPropertyName("payout_totals")]
+        // public Dictionary<string, string> PayoutTotals { get; set; }
+
+        // [JsonPropertyName("adjusted_payout_totals")]
+        // public AdjustedTotals AdjustedPayoutTotals { get; set; }
+
+        [JsonPropertyName("line_items")]
+        public LineItem[]? LineItems { get; set; }
+    }
+
+    public partial class Totals
+    {
+        [JsonPropertyName("subtotal")]
+        public long Subtotal { get; set; }
+
+        [JsonPropertyName("tax")]
+        public long Tax { get; set; }
+
+        [JsonPropertyName("discount")]
+        public long Discount { get; set; }
+
+        [JsonPropertyName("total")]
+        public long Total { get; set; }
+
+        [JsonPropertyName("grand_total")]
+        public long GrandTotal { get; set; }
+
+        // [JsonPropertyName("fee")]
+        // public object Fee { get; set; }
+
+        // [JsonPropertyName("credit")]
+        // public long Credit { get; set; }
+
+        // [JsonPropertyName("credit_to_balance")]
+        // public long CreditToBalance { get; set; }
+
+        [JsonPropertyName("balance")]
+        public long Balance { get; set; }
+
+        // [JsonPropertyName("earnings")]
+        // public object Earnings { get; set; }
+
+        [JsonPropertyName("currency_code")]
+        public string? CurrencyCode { get; set; }
+    }
+    // public partial class AdjustedTotals
+    // {
+    //     [JsonPropertyName("subtotal")]
+    //     [JsonConverter(typeof(ParseStringConverter))]
+    //     public long Subtotal { get; set; }
+
+    //     [JsonPropertyName("tax")]
+    //     [JsonConverter(typeof(ParseStringConverter))]
+    //     public long Tax { get; set; }
+
+    //     [JsonPropertyName("total")]
+    //     [JsonConverter(typeof(ParseStringConverter))]
+    //     public long Total { get; set; }
+
+    //     [JsonPropertyName("fee")]
+    //     [JsonConverter(typeof(ParseStringConverter))]
+    //     public long Fee { get; set; }
+
+    //     [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
+    //     [JsonPropertyName("chargeback_fee")]
+    //     public ChargebackFee ChargebackFee { get; set; }
+
+    //     [JsonPropertyName("earnings")]
+    //     [JsonConverter(typeof(ParseStringConverter))]
+    //     public long Earnings { get; set; }
+
+    //     [JsonPropertyName("currency_code")]
+    //     public string CurrencyCode { get; set; }
+
+    //     [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
+    //     [JsonPropertyName("grand_total")]
+    //     [JsonConverter(typeof(ParseStringConverter))]
+    //     public long? GrandTotal { get; set; }
+    // }
+
+    // public partial class ChargebackFee
+    // {
+    //     [JsonPropertyName("amount")]
+    //     [JsonConverter(typeof(ParseStringConverter))]
+    //     public long Amount { get; set; }
+
+    //     [JsonPropertyName("original")]
+    //     public object Original { get; set; }
+    // }
+
+    public partial class LineItem
+    {
+        [JsonPropertyName("id")]
+        public string? Id { get; set; }
+
+        [JsonPropertyName("price_id")]
+        public string? PriceId { get; set; }
+
+        // [JsonPropertyName("quantity")]
+        // public long Quantity { get; set; }
+
+        // [JsonPropertyName("totals")]
+        // public Totals Totals { get; set; }
+
+        // [JsonPropertyName("product")]
+        // public Product Product { get; set; }
+
+        // [JsonPropertyName("tax_rate")]
+        // public string TaxRate { get; set; }
+
+        // [JsonPropertyName("unit_totals")]
+        // public Totals UnitTotals { get; set; }
+
+        [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
+        [JsonPropertyName("proration")]
+        public Proration? Proration { get; set; }
+    }
+
+    // public partial class Product
+    // {
+    //     [JsonPropertyName("id")]
+    //     public string Id { get; set; }
+
+    //     [JsonPropertyName("name")]
+    //     public string Name { get; set; }
+
+    //     [JsonPropertyName("description")]
+    //     public string Description { get; set; }
+
+    //     [JsonPropertyName("type")]
+    //     public TypeEnum Type { get; set; }
+
+    //     [JsonPropertyName("tax_category")]
+    //     public TypeEnum TaxCategory { get; set; }
+
+    //     [JsonPropertyName("image_url")]
+    //     public Uri ImageUrl { get; set; }
+
+    //     [JsonPropertyName("custom_data")]
+    //     public CustomData CustomData { get; set; }
+
+    //     [JsonPropertyName("status")]
+    //     public Status Status { get; set; }
+
+    //     [JsonPropertyName("created_at")]
+    //     public DateTimeOffset CreatedAt { get; set; }
+
+    //     [JsonPropertyName("updated_at")]
+    //     public DateTimeOffset UpdatedAt { get; set; }
+
+    //     [JsonPropertyName("import_meta")]
+    //     public object ImportMeta { get; set; }
+    // }
+
+    // public partial class CustomData
+    // {
+    //     [JsonPropertyName("features")]
+    //     public Features Features { get; set; }
+
+    //     [JsonPropertyName("suggested_addons")]
+    //     public string[] SuggestedAddons { get; set; }
+
+    //     [JsonPropertyName("upgrade_description")]
+    //     public string UpgradeDescription { get; set; }
+    // }
+
+    // public partial class Features
+    // {
+    //     [JsonPropertyName("aircraft_performance")]
+    //     public bool AircraftPerformance { get; set; }
+
+    //     [JsonPropertyName("compliance_monitoring")]
+    //     public bool ComplianceMonitoring { get; set; }
+
+    //     [JsonPropertyName("flight_log_management")]
+    //     public bool FlightLogManagement { get; set; }
+
+    //     [JsonPropertyName("payment_by_invoice")]
+    //     public bool PaymentByInvoice { get; set; }
+
+    //     [JsonPropertyName("route_planning")]
+    //     public bool RoutePlanning { get; set; }
+
+    //     [JsonPropertyName("sso")]
+    //     public bool Sso { get; set; }
+    // }
+
+    public partial class Proration
+    {
+        [JsonPropertyName("billing_period")]
+        public BillingPeriod? BillingPeriod { get; set; }
+    }
+
+    // public partial class Totals
+    // {
+    //     [JsonPropertyName("subtotal")]
+    //     [JsonConverter(typeof(ParseStringConverter))]
+    //     public long Subtotal { get; set; }
+
+    //     [JsonPropertyName("discount")]
+    //     [JsonConverter(typeof(ParseStringConverter))]
+    //     public long Discount { get; set; }
+
+    //     [JsonPropertyName("tax")]
+    //     [JsonConverter(typeof(ParseStringConverter))]
+    //     public long Tax { get; set; }
+
+    //     [JsonPropertyName("total")]
+    //     [JsonConverter(typeof(ParseStringConverter))]
+    //     public long Total { get; set; }
+    // }
+
+    // public partial class TaxRatesUsed
+    // {
+    //     [JsonPropertyName("tax_rate")]
+    //     public string TaxRate { get; set; }
+
+    //     [JsonPropertyName("totals")]
+    //     public Totals Totals { get; set; }
+    // }
+
+    public partial class Item
+    {
+        [JsonPropertyName("price")]
+        public Price? Price { get; set; }
+
+        [JsonPropertyName("quantity")]
+        public long Quantity { get; set; }
+
+        [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
+        [JsonPropertyName("proration")]
+        public Proration? Proration { get; set; }
+    }
+
+    public partial class Price
+    {
+        [JsonPropertyName("id")]
+        public string? Id { get; set; }
+
+        // [JsonPropertyName("description")]
+        // public string Description { get; set; }
+
+        // [JsonPropertyName("type")]
+        // public TypeEnum Type { get; set; }
+
+        [JsonPropertyName("name")]
+        public string? Name { get; set; }
+
+        // [JsonPropertyName("product_id")]
+        // public string ProductId { get; set; }
+
+        // [JsonPropertyName("billing_cycle")]
+        // public PaymentTerms BillingCycle { get; set; }
+
+        // [JsonPropertyName("trial_period")]
+        // public object TrialPeriod { get; set; }
+
+        // [JsonPropertyName("tax_mode")]
+        // public TaxMode TaxMode { get; set; }
+
+        // [JsonPropertyName("unit_price")]
+        // public UnitPrice UnitPrice { get; set; }
+
+        // [JsonPropertyName("unit_price_overrides")]
+        // public object[] UnitPriceOverrides { get; set; }
+
+        // [JsonPropertyName("custom_data")]
+        // public object CustomData { get; set; }
+
+        // [JsonPropertyName("quantity")]
+        // public Quantity Quantity { get; set; }
+
+        // [JsonPropertyName("status")]
+        // public Status Status { get; set; }
+
+        // [JsonPropertyName("created_at")]
+        // public DateTimeOffset CreatedAt { get; set; }
+
+        // [JsonPropertyName("updated_at")]
+        // public DateTimeOffset UpdatedAt { get; set; }
+
+        // [JsonPropertyName("import_meta")]
+        // public object ImportMeta { get; set; }
+    }
+
+    // public partial class Quantity
+    // {
+    //     [JsonPropertyName("minimum")]
+    //     public long Minimum { get; set; }
+
+    //     [JsonPropertyName("maximum")]
+    //     public long Maximum { get; set; }
+    // }
+
+    // public partial class UnitPrice
+    // {
+    //     [JsonPropertyName("amount")]
+    //     [JsonConverter(typeof(ParseStringConverter))]
+    //     public long Amount { get; set; }
+
+    //     [JsonPropertyName("currency_code")]
+    //     public CurrencyCode CurrencyCode { get; set; }
+    // }
+
+    // public partial class Payment
+    // {
+    //     [JsonPropertyName("payment_attempt_id")]
+    //     public Guid PaymentAttemptId { get; set; }
+
+    //     [JsonPropertyName("stored_payment_method_id")]
+    //     public Guid StoredPaymentMethodId { get; set; }
+
+    //     [JsonPropertyName("payment_method_id")]
+    //     public string PaymentMethodId { get; set; }
+
+    //     [JsonPropertyName("amount")]
+    //     [JsonConverter(typeof(ParseStringConverter))]
+    //     public long Amount { get; set; }
+
+    //     [JsonPropertyName("status")]
+    //     public string Status { get; set; }
+
+    //     [JsonPropertyName("error_code")]
+    //     public string ErrorCode { get; set; }
+
+    //     [JsonPropertyName("method_details")]
+    //     public MethodDetails MethodDetails { get; set; }
+
+    //     [JsonPropertyName("created_at")]
+    //     public DateTimeOffset CreatedAt { get; set; }
+
+    //     [JsonPropertyName("captured_at")]
+    //     public DateTimeOffset? CapturedAt { get; set; }
+    // }
+
+    // public partial class MethodDetails
+    // {
+    //     [JsonPropertyName("type")]
+    //     public string Type { get; set; }
+
+    //     [JsonPropertyName("card")]
+    //     public Card Card { get; set; }
+    // }
+
+    // public partial class Card
+    // {
+    //     [JsonPropertyName("type")]
+    //     public string Type { get; set; }
+
+    //     [JsonPropertyName("last4")]
+    //     public string Last4 { get; set; }
+
+    //     [JsonPropertyName("expiry_month")]
+    //     public long ExpiryMonth { get; set; }
+
+    //     [JsonPropertyName("expiry_year")]
+    //     public long ExpiryYear { get; set; }
+
+    //     [JsonPropertyName("cardholder_name")]
+    //     public string CardholderName { get; set; }
+    // }
+
+    public partial class Pagination
+    {
+        [JsonPropertyName("per_page")]
+        public long PerPage { get; set; }
+
+        [JsonPropertyName("next")]
+        public Uri? Next { get; set; }
+
+        [JsonPropertyName("has_more")]
+        public bool HasMore { get; set; }
+
+        [JsonPropertyName("estimated_total")]
+        public long EstimatedTotal { get; set; }
+    }
+}

Streetwriters.Common/Models/ListUsersResponse.cs

@@ -0,0 +1,47 @@
+using System;
+using System.Text.Json.Serialization;
+
+namespace Streetwriters.Common.Models
+{
+    public partial class ListUsersResponse
+    {
+        [JsonPropertyName("success")]
+        public bool Success { get; set; }
+
+        [JsonPropertyName("response")]
+        public PaddleUser[]? Users { get; set; }
+    }
+
+    public class PaddleUser
+    {
+        [JsonPropertyName("subscription_id")]
+        public long SubscriptionId { get; set; }
+
+        [JsonPropertyName("plan_id")]
+        public long PlanId { get; set; }
+
+        [JsonPropertyName("user_id")]
+        public long UserId { get; set; }
+
+        [JsonPropertyName("user_email")]
+        public string? UserEmail { get; set; }
+
+        [JsonPropertyName("marketing_consent")]
+        public bool MarketingConsent { get; set; }
+
+        [JsonPropertyName("update_url")]
+        public string? UpdateUrl { get; set; }
+
+        [JsonPropertyName("cancel_url")]
+        public string? CancelUrl { get; set; }
+
+        [JsonPropertyName("state")]
+        public string? State { get; set; }
+
+        [JsonPropertyName("signup_date")]
+        public string? SignupDate { get; set; }
+
+        [JsonPropertyName("quantity")]
+        public long Quantity { get; set; }
+    }
+}

Streetwriters.Common/Models/PaddleResponse.cs

@@ -0,0 +1,24 @@
+namespace Streetwriters.Common.Models
+{
+    using System;
+    using System.Collections.Generic;
+
+    using System.Text.Json;
+    using System.Text.Json.Serialization;
+    using System.Globalization;
+
+    public partial class PaddleResponse
+    {
+        [JsonPropertyName("error")]
+        public PaddleError? Error { get; set; }
+    }
+
+    public class PaddleError
+    {
+        public string? Type { get; set; }
+        public string? Code { get; set; }
+        public string? Detail { get; set; }
+        [JsonPropertyName("documentation_url")]
+        public string? DocumentationUrl { get; set; }
+    }
+}

Streetwriters.Common/Models/RefundPaymentResponse.cs

@@ -0,0 +1,20 @@
+using System;
+using System.Text.Json.Serialization;
+
+namespace Streetwriters.Common.Models
+{
+    public partial class RefundPaymentResponse
+    {
+        [JsonPropertyName("success")]
+        public bool Success { get; set; }
+
+        [JsonPropertyName("response")]
+        public required Refund Refund { get; set; }
+    }
+
+    public partial class Refund
+    {
+        [JsonPropertyName("refund_request_id")]
+        public long RefundRequestId { get; set; }
+    }
+}

Streetwriters.Common/Models/Subscription.cs

@@ -93,9 +93,6 @@ namespace Streetwriters.Common.Models
         [JsonPropertyName("trialsAvailed")]
         public SubscriptionPlan[]? TrialsAvailed { get; set; }
 
-        [JsonPropertyName("extensionsAvailed")]
-        public SubscriptionExtension[]? ExtensionsAvailed { get; set; }
-
         [JsonPropertyName("updatedAt")]
         public long UpdatedAt { get; set; }
 
@@ -107,16 +104,4 @@ namespace Streetwriters.Common.Models
         [JsonPropertyName("status")]
         public SubscriptionStatus Status { get; set; }
     }
-
-    public class SubscriptionExtension
-    {
-        [JsonPropertyName("timestamp")]
-        public required long Timestamp { get; set; }
-
-        [JsonPropertyName("expiry")]
-        public required long ExpiryDate { get; set; }
-
-        [JsonPropertyName("type")]
-        public required string Type { get; set; }
-    }
 }

Streetwriters.Common/Models/SubscriptionPreviewResponse.cs

@@ -0,0 +1,57 @@
+namespace Streetwriters.Common.Models
+{
+    using System;
+    using System.Collections.Generic;
+
+    using System.Text.Json;
+    using System.Text.Json.Serialization;
+    using System.Globalization;
+
+    public partial class SubscriptionPreviewResponse : PaddleResponse
+    {
+        [JsonPropertyName("data")]
+        public SubscriptionPreviewData? Data { get; set; }
+    }
+
+    public partial class SubscriptionPreviewData
+    {
+        [JsonPropertyName("currency_code")]
+        public string? CurrencyCode { get; set; }
+
+        [JsonPropertyName("billing_cycle")]
+        public BillingCycle? BillingCycle { get; set; }
+
+        [JsonPropertyName("update_summary")]
+        public UpdateSummary? UpdateSummary { get; set; }
+
+        [JsonPropertyName("immediate_transaction")]
+        public TransactionV2? ImmediateTransaction { get; set; }
+
+        [JsonPropertyName("next_transaction")]
+        public TransactionV2? NextTransaction { get; set; }
+
+        [JsonPropertyName("recurring_transaction_details")]
+        public Details? RecurringTransactionDetails { get; set; }
+    }
+
+    public partial class UpdateSummary
+    {
+        [JsonPropertyName("charge")]
+        public UpdateSummaryItem? Charge { get; set; }
+
+        [JsonPropertyName("credit")]
+        public UpdateSummaryItem? Credit { get; set; }
+
+        [JsonPropertyName("result")]
+        public UpdateSummaryItem? Result { get; set; }
+    }
+
+    public partial class UpdateSummaryItem
+    {
+        [JsonPropertyName("amount")]
+        public long Amount { get; set; }
+
+        [JsonPropertyName("action")]
+        public string? Action { get; set; }
+    }
+}

Streetwriters.Common/Services/EmailSender.cs

@@ -27,7 +27,7 @@ namespace Streetwriters.Common.Services
         public async Task SendEmailAsync(
             string email,
             EmailTemplate template,
-            System.Net.Mail.MailAddress from,
+            IClient client,
             GnuPGContext? gpgContext = null,
             Dictionary<string, byte[]>? attachments = null
         )
@@ -55,7 +55,8 @@ namespace Streetwriters.Common.Services
                 );
 
             var message = new MimeMessage();
-            message.From.Add(new MailboxAddress(from.DisplayName, from.Address));
+            var sender = new MailboxAddress(client.SenderName, client.SenderEmail);
+            message.From.Add(sender);
             message.To.Add(new MailboxAddress("", email));
             message.Subject = await Template.Parse(template.Subject).RenderAsync(template.Data);
 
@@ -64,7 +65,8 @@ namespace Streetwriters.Common.Services
 
             message.Body = await GetEmailBodyAsync(
                 template,
-                new MailboxAddress(from.DisplayName, from.Address),
+                client,
+                sender,
                 gpgContext,
                 attachments
             );
@@ -74,6 +76,7 @@ namespace Streetwriters.Common.Services
 
         private async Task<MimeEntity> GetEmailBodyAsync(
             EmailTemplate template,
+            IClient client,
             MailboxAddress sender,
             GnuPGContext? gpgContext = null,
             Dictionary<string, byte[]>? attachments = null
@@ -104,7 +107,7 @@ namespace Streetwriters.Common.Services
                         }
                         outputStream.Seek(0, SeekOrigin.Begin);
                         builder.Attachments.Add(
-                            $"pub.asc",
+                            $"{client.Id}_pub.asc",
                             Encoding.ASCII.GetBytes(
                                 Encoding.ASCII.GetString(outputStream.ToArray())
                             )

Streetwriters.Common/Services/PaddleBillingService.cs

@@ -0,0 +1,138 @@
+using System.Collections.Generic;
+using System.Net.Http;
+using System.Net.Http.Headers;
+using System.Net.Http.Json;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.WebUtilities;
+using Streetwriters.Common.Models;
+
+namespace Streetwriters.Common.Services
+{
+    public class PaddleBillingService
+    {
+#if DEBUG
+        private const string PADDLE_BASE_URI = "https://sandbox-api.paddle.com";
+#else
+        private const string PADDLE_BASE_URI = "https://api.paddle.com";
+#endif
+        private readonly HttpClient httpClient = new();
+        public PaddleBillingService(string paddleApiKey)
+        {
+            httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", paddleApiKey);
+        }
+
+        public async Task<GetSubscriptionResponse?> GetSubscriptionAsync(string subscriptionId)
+        {
+            var url = $"{PADDLE_BASE_URI}/subscriptions/{subscriptionId}";
+            var response = await httpClient.GetAsync(url);
+            return await response.Content.ReadFromJsonAsync<GetSubscriptionResponse>();
+        }
+
+        public async Task<GetTransactionResponse?> GetTransactionAsync(string transactionId)
+        {
+            var url = $"{PADDLE_BASE_URI}/transactions/{transactionId}";
+            var response = await httpClient.GetAsync(url);
+            return await response.Content.ReadFromJsonAsync<GetTransactionResponse>();
+        }
+
+        public async Task<GetTransactionInvoiceResponse?> GetTransactionInvoiceAsync(string transactionId)
+        {
+            var url = $"{PADDLE_BASE_URI}/transactions/{transactionId}/invoice";
+            var response = await httpClient.GetAsync(url);
+            return await response.Content.ReadFromJsonAsync<GetTransactionInvoiceResponse>();
+        }
+
+        public async Task<ListTransactionsResponseV2?> ListTransactionsAsync(string? subscriptionId = null, string? customerId = null, string[]? status = null, string[]? origin = null)
+        {
+            var url = $"{PADDLE_BASE_URI}/transactions";
+            var parameters = new Dictionary<string, string?>()
+            {
+                { "subscription_id", subscriptionId },
+                { "customer_id", customerId },
+                { "status", string.Join(',', status ?? ["billed","completed"]) },
+                { "order_by", "billed_at[DESC]" }
+            };
+            if (origin is not null) parameters.Add("origin", string.Join(',', origin));
+            var response = await httpClient.GetAsync(QueryHelpers.AddQueryString(url, parameters));
+
+            return await response.Content.ReadFromJsonAsync<ListTransactionsResponseV2>();
+        }
+
+        public async Task<PaddleResponse?> RefundTransactionAsync(string transactionId, string transactionItemId, string reason = "")
+        {
+            var url = $"{PADDLE_BASE_URI}/adjustments";
+            var response = await httpClient.PostAsync(url, JsonContent.Create(new Dictionary<string, object>
+            {
+                { "action", "refund" },
+                {
+                    "items",
+                    new object[]
+                    {
+                        new Dictionary<string, string> {
+                            {"item_id", transactionItemId},
+                            {"type", "full"}
+                        }
+                    }
+                },
+                { "reason", reason },
+                { "transaction_id", transactionId }
+            }));
+            return await response.Content.ReadFromJsonAsync<PaddleResponse>();
+        }
+
+        public async Task<SubscriptionPreviewResponse?> PreviewSubscriptionChangeAsync(string subscriptionId, string newProductId, bool isTrialing)
+        {
+            var url = $"{PADDLE_BASE_URI}/subscriptions/{subscriptionId}/preview";
+            var response = await httpClient.PatchAsync(url, JsonContent.Create(new
+            {
+                proration_billing_mode = isTrialing ? "do_not_bill" : "prorated_immediately",
+                items = new[] { new { price_id = newProductId, quantity = 1 } }
+            }));
+            return await response.Content.ReadFromJsonAsync<SubscriptionPreviewResponse>();
+        }
+
+        public async Task<PaddleResponse?> ChangeSubscriptionAsync(string subscriptionId, string newProductId, bool isTrialing)
+        {
+            var url = $"{PADDLE_BASE_URI}/subscriptions/{subscriptionId}";
+            var response = await httpClient.PatchAsync(url, JsonContent.Create(new
+            {
+                proration_billing_mode = isTrialing ? "do_not_bill" : "prorated_immediately",
+                items = new[] { new { price_id = newProductId, quantity = 1 } }
+            }));
+            return await response.Content.ReadFromJsonAsync<PaddleResponse>();
+        }
+
+        public async Task<PaddleResponse?> CancelSubscriptionAsync(string subscriptionId)
+        {
+            var url = $"{PADDLE_BASE_URI}/subscriptions/{subscriptionId}/cancel";
+            var response = await httpClient.PostAsync(url, JsonContent.Create(new { effective_from = "immediately" }));
+            return await response.Content.ReadFromJsonAsync<PaddleResponse>();
+        }
+
+        public async Task<PaddleResponse?> PauseSubscriptionAsync(string subscriptionId)
+        {
+            var url = $"{PADDLE_BASE_URI}/subscriptions/{subscriptionId}/pause";
+            var response = await httpClient.PostAsync(url, JsonContent.Create(new { }));
+            return await response.Content.ReadFromJsonAsync<PaddleResponse>();
+        }
+
+        public async Task<PaddleResponse?> ResumeSubscriptionAsync(string subscriptionId)
+        {
+            var url = $"{PADDLE_BASE_URI}/subscriptions/{subscriptionId}";
+            var response = await httpClient.PatchAsync(url, JsonContent.Create(new Dictionary<string, string?>
+            {
+                {"scheduled_change", null}
+            }));
+            return await response.Content.ReadFromJsonAsync<PaddleResponse>();
+        }
+
+        public async Task<GetCustomerResponse?> FindCustomerFromTransactionAsync(string transactionId)
+        {
+            var transaction = await GetTransactionAsync(transactionId);
+            if (transaction?.Transaction?.CustomerId == null) return null;
+            var url = $"{PADDLE_BASE_URI}/customers/{transaction.Transaction.CustomerId}";
+            var response = await httpClient.GetFromJsonAsync<GetCustomerResponse>(url);
+            return response;
+        }
+    }
+}

Streetwriters.Common/Services/PaddleService.cs

@@ -0,0 +1,188 @@
+using System;
+using System.Collections.Generic;
+using System.Net.Http;
+using System.Net.Http.Json;
+using System.Text.Json.Serialization;
+using System.Threading.Tasks;
+using Streetwriters.Common.Models;
+
+namespace Streetwriters.Common.Services
+{
+    public class PaddleService(string vendorId, string vendorAuthCode)
+    {
+#if (DEBUG || STAGING)
+        const string PADDLE_BASE_URI = "https://sandbox-vendors.paddle.com/api";
+#else
+        const string PADDLE_BASE_URI = "https://vendors.paddle.com/api";
+#endif
+
+        HttpClient httpClient = new HttpClient();
+
+        public async Task<ListUsersResponse?> ListUsersAsync(
+            string subscriptionId,
+            int results
+        )
+        {
+            var url = $"{PADDLE_BASE_URI}/2.0/subscription/users";
+            var httpClient = new HttpClient();
+            var response = await httpClient.PostAsync(
+                url,
+                new FormUrlEncodedContent(
+                    new Dictionary<string, string>
+                    {
+                        { "vendor_id", vendorId },
+                        { "vendor_auth_code", vendorAuthCode },
+                        { "subscription_id", subscriptionId },
+                        { "results_per_page", results.ToString() },
+                    }
+                )
+            );
+
+            return await response.Content.ReadFromJsonAsync<ListUsersResponse>();
+        }
+
+        public async Task<ListPaymentsResponse?> ListPaymentsAsync(
+            string subscriptionId,
+            long planId
+        )
+        {
+            var url = $"{PADDLE_BASE_URI}/2.0/subscription/payments";
+            var httpClient = new HttpClient();
+            var response = await httpClient.PostAsync(
+                url,
+                new FormUrlEncodedContent(
+                    new Dictionary<string, string>
+                    {
+                        { "vendor_id", vendorId },
+                        { "vendor_auth_code", vendorAuthCode },
+                        { "subscription_id", subscriptionId },
+                        { "is_paid", "1" },
+                        { "plan", planId.ToString() },
+                        { "is_one_off_charge", "0" },
+                    }
+                )
+            );
+
+            return await response.Content.ReadFromJsonAsync<ListPaymentsResponse>();
+        }
+
+        public async Task<ListTransactionsResponse?> ListTransactionsAsync(
+            string subscriptionId
+        )
+        {
+            var url = $"{PADDLE_BASE_URI}/2.0/subscription/{subscriptionId}/transactions";
+            var httpClient = new HttpClient();
+            var response = await httpClient.PostAsync(
+                url,
+                new FormUrlEncodedContent(
+                    new Dictionary<string, string>
+                    {
+                        { "vendor_id", vendorId },
+                        { "vendor_auth_code", vendorAuthCode },
+                    }
+                )
+            );
+
+            return await response.Content.ReadFromJsonAsync<ListTransactionsResponse>();
+        }
+
+        public async Task<PaddleTransactionUser?> FindUserFromOrderAsync(string orderId)
+        {
+            var url = $"{PADDLE_BASE_URI}/2.0/order/{orderId}/transactions";
+            var httpClient = new HttpClient();
+            var response = await httpClient.PostAsync(
+                url,
+                new FormUrlEncodedContent(
+                    new Dictionary<string, string>
+                    {
+                        { "vendor_id", vendorId },
+                        { "vendor_auth_code", vendorAuthCode },
+                    }
+                )
+            );
+            var transactions = await response.Content.ReadFromJsonAsync<ListTransactionsResponse>();
+            if (transactions?.Transactions == null || transactions.Transactions.Length == 0) return null;
+            return transactions.Transactions[0].User;
+        }
+
+        public async Task<bool> RefundPaymentAsync(string paymentId, string reason = "")
+        {
+            var url = $"{PADDLE_BASE_URI}/2.0/payment/refund";
+            var httpClient = new HttpClient();
+            var response = await httpClient.PostAsync(
+                url,
+                new FormUrlEncodedContent(
+                    new Dictionary<string, string>
+                    {
+                        { "vendor_id", vendorId },
+                        { "vendor_auth_code", vendorAuthCode },
+                        { "order_id", paymentId },
+                        { "reason", reason },
+                    }
+                )
+            );
+
+            var refundResponse = await response.Content.ReadFromJsonAsync<RefundPaymentResponse>();
+            return refundResponse?.Success ?? false;
+        }
+
+        public async Task<bool> CancelSubscriptionAsync(string subscriptionId)
+        {
+            var url = $"{PADDLE_BASE_URI}/2.0/subscription/users_cancel";
+            var httpClient = new HttpClient();
+            var response = await httpClient.PostAsync(
+                url,
+                new FormUrlEncodedContent(
+                    new Dictionary<string, string>
+                    {
+                        { "vendor_id", vendorId },
+                        { "vendor_auth_code", vendorAuthCode },
+                        { "subscription_id", subscriptionId },
+                    }
+                )
+            );
+
+            return response.IsSuccessStatusCode;
+        }
+
+        public async Task<bool> PauseSubscriptionAsync(string subscriptionId)
+        {
+            var url = $"{PADDLE_BASE_URI}/2.0/subscription/users/update";
+            var httpClient = new HttpClient();
+            var response = await httpClient.PostAsync(
+                url,
+                new FormUrlEncodedContent(
+                    new Dictionary<string, string>
+                    {
+                        { "vendor_id", vendorId },
+                        { "vendor_auth_code", vendorAuthCode },
+                        { "subscription_id", subscriptionId },
+                        { "pause", "true" },
+                    }
+                )
+            );
+
+            return response.IsSuccessStatusCode;
+        }
+
+        public async Task<bool> ResumeSubscriptionAsync(string subscriptionId)
+        {
+            var url = $"{PADDLE_BASE_URI}/2.0/subscription/users/update";
+            var httpClient = new HttpClient();
+            var response = await httpClient.PostAsync(
+                url,
+                new FormUrlEncodedContent(
+                    new Dictionary<string, string>
+                    {
+                        { "vendor_id", vendorId },
+                        { "vendor_auth_code", vendorAuthCode },
+                        { "subscription_id", subscriptionId },
+                        { "pause", "false" },
+                    }
+                )
+            );
+
+            return response.IsSuccessStatusCode;
+        }
+    }
+}

Streetwriters.Identity/Controllers/AccountController.cs

@@ -190,8 +190,8 @@ namespace Streetwriters.Identity.Controllers
             var client = Clients.FindClientById(form.ClientId);
             if (client == null) return BadRequest("Invalid client_id.");
 
-            var user = await UserManager.FindByEmailAsync(form.Email);
+            var user = await UserManager.FindByEmailAsync(form.Email) ?? throw new Exception("User not found.");
-            if (user == null || !await UserService.IsUserValidAsync(UserManager, user, form.ClientId)) return Ok();
+            if (!await UserService.IsUserValidAsync(UserManager, user, form.ClientId)) return Ok();
 
             var code = await UserManager.GenerateUserTokenAsync(user, TokenOptions.DefaultProvider, "ResetPassword");
             var callbackUrl = UrlExtensions.TokenLink(user.Id.ToString(), code, client.Id, TokenType.RESET_PASSWORD);

Streetwriters.Identity/Controllers/MFAController.cs

@@ -79,9 +79,12 @@ namespace Streetwriters.Identity.Controllers
         }
 
         [HttpDelete]
-        public IActionResult Disable2FA()
+        public async Task<IActionResult> Disable2FA()
         {
-            return BadRequest("2FA is mandatory and cannot be disabled.");
+            var user = await UserManager.GetUserAsync(User) ?? throw new Exception("User not found.");
+            if (!await UserManager.GetTwoFactorEnabledAsync(user)) return Ok();
+            await MFAService.DisableMFAAsync(user);
+            return Ok();
         }
 
         [HttpGet("codes")]

Streetwriters.Identity/Interfaces/ISMSSender.cs

@@ -24,7 +24,7 @@ namespace Streetwriters.Identity.Interfaces
 {
     public interface ISMSSender
     {
-        Task<string?> SendOTPAsync(string number, IClient client);
+        Task<string> SendOTPAsync(string number, IClient client);
         Task<bool> VerifyOTPAsync(string id, string code);
     }
 }

Streetwriters.Identity/Services/MFAService.cs

@@ -186,8 +186,6 @@ namespace Streetwriters.Identity.Services
                     ArgumentNullException.ThrowIfNull(form.PhoneNumber);
                     await UserManager.SetPhoneNumberAsync(user, form.PhoneNumber);
                     var id = await SMSSender.SendOTPAsync(form.PhoneNumber, client);
-                    if (string.IsNullOrEmpty(id)) throw new Exception("Failed to send SMS. Please try again.");
-
                     logger.LogInformation("SMS OTP sent for user: {UserId}, SMS ID: {SmsId}", user.Id, id);
                     await this.ReplaceClaimAsync(user, MFAService.SMS_ID_CLAIM, id);
                     break;

Streetwriters.Identity/Services/SMSSender.cs

@@ -23,26 +23,20 @@ using Streetwriters.Common;
 using Twilio.Rest.Verify.V2.Service;
 using Twilio;
 using System.Threading.Tasks;
-using System;
-using Microsoft.Extensions.Logging;
 
 namespace Streetwriters.Identity.Services
 {
     public class SMSSender : ISMSSender
     {
-        private readonly ILogger<SMSSender> Logger;
+        public SMSSender()
-        public SMSSender(ILogger<SMSSender> logger)
         {
-            Logger = logger;
             if (!string.IsNullOrEmpty(Constants.TWILIO_ACCOUNT_SID) && !string.IsNullOrEmpty(Constants.TWILIO_AUTH_TOKEN))
             {
                 TwilioClient.Init(Constants.TWILIO_ACCOUNT_SID, Constants.TWILIO_AUTH_TOKEN);
             }
         }
 
-        public async Task<string?> SendOTPAsync(string number, IClient app)
+        public async Task<string> SendOTPAsync(string number, IClient app)
-        {
-            try
         {
             var verification = await VerificationResource.CreateAsync(
                 to: number,
@@ -51,16 +45,8 @@ namespace Streetwriters.Identity.Services
             );
             return verification.Sid;
         }
-            catch (Exception ex)
-            {
-                Logger.LogError(ex, "Error sending OTP with Twilio");
-                return null;
-            }
-        }
 
         public async Task<bool> VerifyOTPAsync(string id, string code)
-        {
-            try
         {
             return (await VerificationCheckResource.CreateAsync(
                 verificationSid: id,
@@ -68,11 +54,5 @@ namespace Streetwriters.Identity.Services
                 code: code
             )).Status == "approved";
         }
-            catch (Exception ex)
-            {
-                Logger.LogError(ex, "Error verifying OTP with Twilio");
-                return false;
-            }
-        }
     }
 }

Streetwriters.Identity/Services/TemplatedEmailSender.cs

@@ -104,7 +104,7 @@ namespace Streetwriters.Identity.Services
                 Subject = Email2FATemplate.Subject,
                 Data = new { app_name = client.Name, code },
             };
-            await EmailSender.SendEmailAsync(email, template, new System.Net.Mail.MailAddress(client.SenderEmail, client.SenderName), NNGnuPGContext);
+            await EmailSender.SendEmailAsync(email, template, client, NNGnuPGContext);
         }
 
         public async Task SendConfirmationEmailAsync(
@@ -120,7 +120,7 @@ namespace Streetwriters.Identity.Services
                 Subject = ConfirmEmailTemplate.Subject,
                 Data = new { app_name = client.Name, confirm_link = callbackUrl },
             };
-            await EmailSender.SendEmailAsync(email, template, new System.Net.Mail.MailAddress(client.SenderEmail, client.SenderName), NNGnuPGContext);
+            await EmailSender.SendEmailAsync(email, template, client, NNGnuPGContext);
         }
 
         public async Task SendChangeEmailConfirmationAsync(
@@ -136,7 +136,7 @@ namespace Streetwriters.Identity.Services
                 Subject = ConfirmChangeEmailTemplate.Subject,
                 Data = new { app_name = client.Name, code },
             };
-            await EmailSender.SendEmailAsync(email, template, new System.Net.Mail.MailAddress(client.SenderEmail, client.SenderName), NNGnuPGContext);
+            await EmailSender.SendEmailAsync(email, template, client, NNGnuPGContext);
         }
 
         public async Task SendPasswordResetEmailAsync(
@@ -152,7 +152,7 @@ namespace Streetwriters.Identity.Services
                 Subject = PasswordResetEmailTemplate.Subject,
                 Data = new { app_name = client.Name, reset_link = callbackUrl },
             };
-            await EmailSender.SendEmailAsync(email, template, new System.Net.Mail.MailAddress(client.SenderEmail, client.SenderName), NNGnuPGContext);
+            await EmailSender.SendEmailAsync(email, template, client, NNGnuPGContext);
         }
 
         public async Task SendFailedLoginAlertAsync(string email, string deviceInfo, IClient client)
@@ -168,7 +168,7 @@ namespace Streetwriters.Identity.Services
                     device_info = deviceInfo.Replace("\n", "<br>"),
                 },
             };
-            await EmailSender.SendEmailAsync(email, template, new System.Net.Mail.MailAddress(client.SenderEmail, client.SenderName), NNGnuPGContext);
+            await EmailSender.SendEmailAsync(email, template, client, NNGnuPGContext);
         }
     }
 

Streetwriters.Identity/Services/UserAccountService.cs

@@ -34,12 +34,6 @@ namespace Streetwriters.Identity.Services
             var claims = await userManager.GetClaimsAsync(user);
             var marketingConsentClaim = claims.FirstOrDefault((claim) => claim.Type == $"{clientId}:marketing_consent");
 
-            if (await userManager.IsEmailConfirmedAsync(user) && !await userManager.GetTwoFactorEnabledAsync(user))
-            {
-                await mfaService.EnableMFAAsync(user, MFAMethods.Email);
-                user = await userManager.FindByIdAsync(userId);
-                ArgumentNullException.ThrowIfNull(user);
-            }
             ArgumentNullException.ThrowIfNull(user.Email);
 
             return new UserModel
@@ -85,13 +79,6 @@ namespace Streetwriters.Identity.Services
 
             await mfaService.ResetMFAAsync(user);
             result = await userManager.AddPasswordAsync(user, newPassword);
-
-            // force change email to lowercase if it is not already
-            if (user.Email != null && user.Email != user.Email.ToLower())
-            {
-                var token = await userManager.GenerateChangeEmailTokenAsync(user, user.Email.ToLower());
-                result = await userManager.ChangeEmailAsync(user, user.Email.ToLower(), token);
-            }
             return result.Succeeded;
         }
 
@@ -170,6 +157,7 @@ namespace Streetwriters.Identity.Services
                     }
                     else
                     {
+                        await mfaService.EnableMFAAsync(user, MFAMethods.Email);
                         if (userAgent != null) await userManager.AddClaimAsync(user, new Claim("platform", PlatformFromUserAgent(userAgent)));
                         var code = await userManager.GenerateEmailConfirmationTokenAsync(user);
                         var callbackUrl = UrlExtensions.TokenLink(user.Id.ToString(), code, client.Id, TokenType.CONFRIM_EMAIL);

Streetwriters.Identity/Templates/ConfirmEmail.html

@@ -504,6 +504,7 @@
                                                 text-align: start;
                                                 text-indent: 0px;
                                                 text-transform: none;
+                                                white-space: pre-wrap;
                                                 widows: 2;
                                                 word-spacing: 0px;
                                                 -webkit-text-stroke-width: 0px;
@@ -535,6 +536,7 @@
                                                 text-align: start;
                                                 text-indent: 0px;
                                                 text-transform: none;
+                                                white-space: pre-wrap;
                                                 widows: 2;
                                                 word-spacing: 0px;
                                                 -webkit-text-stroke-width: 0px;
@@ -565,6 +567,7 @@
                                                 text-align: start;
                                                 text-indent: 0px;
                                                 text-transform: none;
+                                                white-space: pre-wrap;
                                                 widows: 2;
                                                 word-spacing: 0px;
                                                 -webkit-text-stroke-width: 0px;

Streetwriters.Identity/Templates/Email2FACode.html

@@ -309,6 +309,7 @@
                                                 text-align: start;
                                                 text-indent: 0px;
                                                 text-transform: none;
+                                                white-space: pre-wrap;
                                                 widows: 2;
                                                 word-spacing: 0px;
                                                 -webkit-text-stroke-width: 0px;

Streetwriters.Identity/Templates/EmailChangeConfirmation.html

@@ -401,6 +401,7 @@
                                                 text-align: start;
                                                 text-indent: 0px;
                                                 text-transform: none;
+                                                white-space: pre-wrap;
                                                 word-spacing: 0px;
                                                 -webkit-text-stroke-width: 0px;
                                                 background-color: rgb(

Streetwriters.Identity/Templates/ResetAccountPassword.html

@@ -467,6 +467,7 @@
                                                 text-align: start;
                                                 text-indent: 0px;
                                                 text-transform: none;
+                                                white-space: pre-wrap;
                                                 widows: 2;
                                                 word-spacing: 0px;
                                                 -webkit-text-stroke-width: 0px;
@@ -482,7 +483,9 @@
                                                 display: inline;
                                               "
                                               ><em
-                                                >If you did not request to reset your account password, you can safely ignore this email.</em
+                                                >If you did not request to reset
+                                                your account password, you can
+                                                safely ignore this email.</em
                                               ></span
                                             >
                                           </div>
@@ -551,6 +554,7 @@
                                 >
                                   <tbody>
                                     <tr>
+                                      .
                                       <td
                                         style="
                                           padding: 18px 0px 18px 0px;

Streetwriters.Identity/Validation/EmailGrantValidator.cs

@@ -59,7 +59,6 @@ namespace Streetwriters.Identity.Validation
 
         public string GrantType => Config.EMAIL_GRANT_TYPE;
 
-
         public async Task ValidateAsync(ExtensionGrantValidationContext context)
         {
             var email = context.Request.Raw["email"];
@@ -76,8 +75,14 @@ namespace Streetwriters.Identity.Validation
             };
 
             var isMultiFactor = await UserManager.GetTwoFactorEnabledAsync(user);
+            if (!isMultiFactor)
+            {
+                context.Result.IsError = false;
+                context.Result.Subject = await TokenGenerationService.TransformTokenRequestAsync(context.Request, user, GrantType, [Config.MFA_PASSWORD_GRANT_TYPE_SCOPE]);
+                return;
+            }
 
-            var primaryMethod = isMultiFactor ? MFAService.GetPrimaryMethod(user) : MFAMethods.Email;
+            var primaryMethod = MFAService.GetPrimaryMethod(user);
             var secondaryMethod = MFAService.GetSecondaryMethod(user);
             var sendPhoneNumber = primaryMethod == MFAMethods.SMS || secondaryMethod == MFAMethods.SMS;
 

Streetwriters.Messenger/Helpers/SSEHelper.cs

@@ -18,49 +18,28 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 using System.Linq;
-using System;
-using System.Threading;
 using System.Threading.Tasks;
 using Lib.AspNetCore.ServerSentEvents;
 using System.Security.Claims;
-using System.Collections.Generic;
 
 namespace Streetwriters.Messenger.Helpers
 {
     public class SSEHelper
     {
-        public static async Task SendEventToUserAsync(string data, IServerSentEventsService sseService, string userId, string? originTokenId = null, CancellationToken cancellationToken = default)
+        public static async Task SendEventToUserAsync(string data, IServerSentEventsService sseService, string userId, string? originTokenId = null)
-        {
-            var clients = sseService.GetClients()
-                .Where(c => c.User?.FindFirstValue("sub") == userId)
-                .Where(c => originTokenId == null || c.User?.FindFirstValue("jti") != originTokenId);
-
-            await SendEventToClientsAsync(clients, data, cancellationToken);
-        }
-
-        public static async Task SendEventToAllUsersAsync(string data, IServerSentEventsService sseService, CancellationToken cancellationToken = default)
-        {
-            await SendEventToClientsAsync(sseService.GetClients(), data, cancellationToken);
-        }
-
-        private static async Task SendEventToClientsAsync(IEnumerable<IServerSentEventsClient> clients, string data, CancellationToken cancellationToken)
         {
+            var clients = sseService.GetClients().Where(c => c.User.FindFirstValue("sub") == userId);
             foreach (var client in clients)
             {
+                if (originTokenId != null && client.User.FindFirstValue("jti") == originTokenId) continue;
                 if (!client.IsConnected) continue;
+                await client.SendEventAsync(data);
+            }
+        }
 
-                try
+        public static async Task SendEventToAllUsersAsync(string data, IServerSentEventsService sseService)
-                {
-                    await client.SendEventAsync(data, cancellationToken);
-                }
-                catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested)
-                {
-                    break;
-                }
-                catch
         {
-                }
+            await sseService.SendEventAsync(data);
-            }
         }
     }
 }

Streetwriters.Messenger/Services/HeartbeatService.cs

@@ -21,7 +21,6 @@ using System;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.Extensions.Hosting;
-using Microsoft.Extensions.Logging;
 using Lib.AspNetCore.ServerSentEvents;
 using Streetwriters.Messenger.Helpers;
 using System.Text.Json;
@@ -34,14 +33,12 @@ namespace Streetwriters.Messenger.Services
         private const string HEARTBEAT_MESSAGE_FORMAT = "Streetwriters Heartbeat ({0} UTC)";
 
         private readonly IServerSentEventsService _serverSentEventsService;
-        private readonly ILogger<HeartbeatService> _logger;
         #endregion
 
         #region Constructor
-        public HeartbeatService(IServerSentEventsService serverSentEventsService, ILogger<HeartbeatService> logger)
+        public HeartbeatService(IServerSentEventsService serverSentEventsService)
         {
             _serverSentEventsService = serverSentEventsService;
-            _logger = logger;
         }
         #endregion
 
@@ -49,8 +46,6 @@ namespace Streetwriters.Messenger.Services
         protected override async Task ExecuteAsync(CancellationToken stoppingToken)
         {
             while (!stoppingToken.IsCancellationRequested)
-            {
-                try
             {
                 var message = JsonSerializer.Serialize(new
                 {
@@ -60,18 +55,7 @@ namespace Streetwriters.Messenger.Services
                         t = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds()
                     })
                 });
-
+                await SSEHelper.SendEventToAllUsersAsync(message, _serverSentEventsService);
-                    await SSEHelper.SendEventToAllUsersAsync(message, _serverSentEventsService, stoppingToken);
-                }
-                catch (OperationCanceledException) when (stoppingToken.IsCancellationRequested)
-                {
-                    break;
-                }
-                catch (Exception ex)
-                {
-                    _logger.LogWarning(ex, "Failed to send SSE heartbeat to one or more clients.");
-                }
-
                 await Task.Delay(TimeSpan.FromSeconds(5), stoppingToken);
             }
         }

Streetwriters.Messenger/Streetwriters.Messenger.csproj

@@ -8,7 +8,7 @@
 
   <ItemGroup>
     <PackageReference Include="DotNetEnv" Version="2.3.0" />
-    <PackageReference Include="Lib.AspNetCore.ServerSentEvents" Version="9.1.0" />
+    <PackageReference Include="Lib.AspNetCore.ServerSentEvents" Version="6.0.0" />
     <PackageReference Include="Microsoft.AspNetCore.Authentication.JwtBearer" Version="5.0.0"
       NoWarn="NU1605" />
     <PackageReference Include="Microsoft.AspNetCore.Authentication.OpenIdConnect" Version="5.0.0"